anchor.diff:            in
             let eqns = List.rev eqns in
             prefix_decls@rest@eqns, env0
  +        in
  +
  +        if quals |> BU.for_some (function HasMaskedEffect -> true | _ -> false)
  +        || typs  |> BU.for_some (fun t -> not <| (U.is_pure_or_ghost_function t ||
  +                                                  is_reifiable_function env.tcenv t))
  +        then decls, env
  +        else
  +          try
  +            if not is_rec
  +            then
  +              (* Encoding non-recursive definitions *)
  +              encode_non_rec_lbdef bindings typs toks env
  +            else
  +              encode_rec_lbdefs bindings typs toks env
  +          with Inner_let_rec -> decls, env  //decls are type declarations for the lets, if there is an inner let rec, only those are encoded to the solver
   
       with Let_rec_unencodeable ->
         let msg = bindings |> List.map (fun lb -> Print.lbname_to_string lb.lbname) |> String.concat " and " in
  
positive.code:  }
  exception Let_rec_unencodeable
  
  let encode_const = function
      | Const_unit -> mk_Term_unit
      | Const_bool true -> boxBool mkTrue
  
negative.code:                   else mkApp(f, List.map mkFreeV vars)
          in
  
          let encode_non_rec_lbdef (bindings:list<letbinding>) (typs:list<S.term>) (toks:list<(S.fv * (string * option<term>))>) (env:env_t) =
              match bindings, typs, toks with
              | [{lbunivs=uvs;lbdef=e}], [t_norm], [(flid_fv, (f, ftok))] ->
  
                  (* Open universes *)
                  let flid = flid_fv.fv_name.v in
                  let env', e, t_norm =
                  let tcenv', _, e_t =
                      Env.open_universes_in env.tcenv uvs [e; t_norm] in
                  let e, t_norm =
  