anchor.diff:  
   let encode_smt_lemma env fv t =
       let lid = fv.fv_name.v in
  -    let form, decls = encode_function_type_as_formula None None t env in
  +    let form, decls = encode_function_type_as_formula None t env in
       decls@[Util.mkAssume(form, Some ("Lemma: " ^ lid.str), ("lemma_"^lid.str))]
   
   let encode_free_var env fv tt t_norm quals =
  
positive.code:     {env with bindings=Binding_fvar(x, fname, ftok, None)::env.bindings}
  let push_zfuel_name env (x:lident) f =
      let t1, t2, _ = lookup_lid env x in
      let t3 = mkApp(f, [mkApp("ZFuel", [])]) in
      {env with bindings=Binding_fvar(x, t1, t2, Some t3)::env.bindings}
  let try_lookup_free_var env l =
      match try_lookup_lid env l with
          | None -> None
          | Some (name, sym, zf_opt) ->
              match zf_opt with
                  | Some f when (env.use_zfuel_name) -> Some f
                  | _ ->
                    match sym with
                      | Some t ->
  
negative.code:             | _ -> failwith "impos"
            end
  
          | _ -> failwith "Impos"
      in
  
      let vars, guards, env, decls, _ = encode_binders None binders env in
      let env = {env with use_zfuel_name=true} in
      let pats, decls' =
          patterns |>
          List.map (fun branch ->
                      branch |>
                      List.map (fun t ->  encode_term t env) |>
                      List.unzip) |>
          List.unzip in
  
      let decls' = List.flatten decls' in
  
      let env = {env with nolabels=true} in
      let pre, decls'' = encode_formula (U.unmeta pre) env in
  