anchor.diff:              | _ -> failwith "impos"
             end
   
  -        | _ -> failwith "Impos" in
  +        | _ -> failwith "Impos"
  +    in
   
       let vars, guards, env, decls, _ = encode_binders None binders env in
  -
  -
  -    let pats, decls' = patterns |> List.map (fun branch ->
  -        let pats, decls = branch |> List.map (fun (t, _) ->  encode_term t ({env with use_zfuel_name=true})) |> List.unzip in
  -        pats, decls) |> List.unzip 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 pats =
  -      match induction_on with
  -      | None -> pats
  -      | Some e ->
  -        begin match vars with
  -          | [] -> pats
  -          | [l] -> pats |> List.map (fun p -> mk_Precedes (mkFreeV l) e::p)
  -          | _ ->
  -            let rec aux tl vars = match vars with
  -              | [] -> pats |> List.map (fun p -> mk_Precedes tl e::p)
  -              | (x, Term_sort)::vars -> aux (mk_LexCons (mkFreeV(x,Term_sort)) tl) vars
  -              | _ -> pats
  -            in
  -            aux (mkFreeV ("Prims.LexTop", Term_sort)) vars
  -        end
  -    in
   
       let env = {env with nolabels=true} in
       let pre, decls'' = encode_formula (U.unmeta pre) env in
  
positive.code: (* Each entry maps a Syntax variable to its encoding as a SMT2 term *)
  type binding =
      | Binding_var   of bv * term
      | Binding_fvar  of lident * string * option<term> * option<term> (* free variables, depending on whether or not they are fully applied ...  *)
                                                                       (* ... are mapped either to SMT2 functions, or to nullary tokens *)
  
  let binder_of_eithervar v = (v, None)
  type cache_entry = {
  
negative.code: let lookup_free_var_sym env a =
      let name, sym, zf_opt = lookup_lid env a.v in
      match zf_opt with
      | Some mkf when env.use_zfuel_name ->
        begin match (mkf 0).tm with
          | App(g, zf) -> g, zf
          | _ -> failwith "Impossible"
        end
      | _ ->
        match sym with
        | None -> Var name, []
        | Some sym ->
          match sym.tm with
          | App(g, [fuel]) -> g, [fuel]
          | _ -> Var name, []
  
  let tok_of_name env nm =
      BU.find_map env.bindings (function
  