anchor.diff:      let one_pat p =
           let head, args = U.unmeta p |> U.head_and_args in
           match (U.un_uinst head).n, args with
  -        | Tm_fvar fv, [(_, _); (e, _)] when S.fv_eq_lid fv Const.smtpat_lid -> (e, None)
  -        | Tm_fvar fv, [(e, _)] when S.fv_eq_lid fv Const.smtpatT_lid -> (e, None)
  -        | _ -> failwith "Unexpected pattern term"  in
  +        | Tm_fvar fv, [(_, _); (e, _)] when S.fv_eq_lid fv Const.smtpat_lid -> e
  +        | Tm_fvar fv, [(e, _)] when S.fv_eq_lid fv Const.smtpatT_lid -> e
  +        | _ -> failwith "Unexpected pattern term"
  +    in
   
       let lemma_pats p =
           let elts = list_elements p in
  
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
  