anchor.diff:      Util.abs (S.binders_of_list [ a; c; the_a; the_c ]) (
         let l_ite = fvar Const.ite_lid (S.Delta_unfoldable 2) None in
         Util.mk_app c_lift2 (List.map S.as_arg [
  +        unknown; unknown; unknown;
           Util.mk_app l_ite [S.as_arg (S.bv_to_name c)]
         ])
       ) ret
  
positive.code:         (fun t -> Util.arrow wp_binders { comp with n = Total t }),
          (fun t -> Util.arrow wp_binders { comp with n = GTotal t }),
          (fun () -> List.map (fun (bv, _) ->
            i := !i + 1;
            S.gen_bv ("g" ^ string_of_int !i) None bv.sort
          ) wp_binders)
  
negative.code: 
    (* A variation where we can specify implicit parameters. *)
    let binders_of_list = List.map (fun (t, b) -> t, S.as_implicit b) in
  
    let implicit_binders_of_list = List.map (fun t -> t, S.as_implicit true) in
  
    (* A debug / sanity check. *)
    let check str t =
      Util.print2 "Generated term for %s: %s\n" str (Print.term_to_string t);
      let n = N.normalize [ N.Beta; N.Inline; N.UnfoldUntil S.Delta_constant ] env in
      let t = n t in
      let t = SS.compress t in
      let e, { res_typ = res_typ }, _ = tc_term env t in
      Util.print2 "Inferred type for %s: %s\n" str (Print.term_to_string (n res_typ));
      Util.print2 "Elaborated term for %s: %s\n" str (Print.term_to_string (n e))
    in
  
    (* val st2_pure : #heap:Type -> #a:Type -> #t:Type -> x:t ->
  