anchor.diff:    in
     check "lift2" (Util.abs (binders @ [ S.mk_binder a ]) c_lift2 None);
   
  +  (* val st2_push : #heap:Type -> #a:Type -> #t1:Type -> #t2:Type ->
  +                    f:(t1 -> Tot (st2_gctx heap a t2)) ->
  +                    Tot (st2_ctx heap a (t1->GTot t2))
  +    let st2_push #heap #a #t1 #t2 f = fun p h e1 -> f e1 p h *)
  +  let c_push =
  +    let t1 = S.gen_bv "t1" None Util.ktype in
  +    let t2 = S.gen_bv "t2" None Util.ktype in
  +    let t_f = Util.arrow
  +      [ S.null_binder (S.bv_to_name t1) ]
  +      (S.mk_Total (mk_gctx (S.bv_to_name t2)))
  +    in
  +    let f = S.gen_bv "f" None t_f in
  +    let ret = Some (Inl (Util.lcomp_of_comp (mk_Total (mk_ctx (
  +      Util.arrow [ S.null_binder (S.bv_to_name t1) ] (S.mk_GTotal (S.bv_to_name t2)))))))
  +    in
  +    let e1 = S.gen_bv "e1" None (S.bv_to_name t1) in
  +    let gamma = mk_gamma () in
  +    let body = Util.abs (S.binders_of_list gamma @ [ S.mk_binder e1 ]) (
  +      Util.mk_app (S.bv_to_name f) (S.as_arg (S.bv_to_name e1) :: args_of_bv gamma)
  +    ) ret in
  +    Util.abs (binders_of_list [ t1, true; t2, true; f, false ]) body ret
  +  in
  +  check "push" (Util.abs (binders @ [ S.mk_binder a ]) c_push None);
  +
     let ret_tot_wp_a = Some (Inl (Util.lcomp_of_comp (mk_Total wp_a))) in
   
     (* val st2_if_then_else : heap:Type -> a:Type -> c:Type0 ->
  
positive.code:   let wp_assume =
      let q = S.gen_bv "q" None Util.ktype0 in
      let wp = S.gen_bv "wp" None wp_a in
      let l_imp = fvar Const.and_lid (S.Delta_unfoldable 1) None in
      let body =
        Util.mk_app c_app (List.map S.as_arg [
          unknown; unknown;
  
negative.code: 
    let implicit_binders_of_list = List.map (fun t -> t, S.as_implicit true) in
  
    let args_of_bv = List.map (fun bv -> S.as_arg (S.bv_to_name bv)) in
  
    (* val st2_pure : #heap:Type -> #a:Type -> #t:Type -> x:t ->
         Tot (st2_ctx heap a t)
       let st2_pure #heap #a #t x = fun _post _h -> x *)
  