anchor.diff:                   rebuild cfg env stack t
   
             | Tm_arrow(bs, c) ->
  -            if List.contains Weak cfg.steps
  +            if cfg.steps.weak
               then rebuild cfg env stack (closure_as_term cfg env t)
               else let bs, c = open_comp bs c in
                    let c = norm_comp cfg (bs |> List.fold_left (fun env _ -> dummy::env) env) c in
                    let t = arrow (norm_binders cfg env bs) c in
                    rebuild cfg env stack t
   
  -          | Tm_ascribed(t1, (tc, tacopt), l) when List.contains Unascribe cfg.steps ->
  +          | Tm_ascribed(t1, (tc, tacopt), l) when cfg.steps.unascribe ->
               norm cfg env stack t1
   
             | Tm_ascribed(t1, (tc, tacopt), l) ->
  
positive.code: let rec closure_as_term cfg (env:env) t =
      log cfg  (fun () -> BU.print2 ">>> %s Closure_as_term %s\n" (Print.tag_of_term t) (Print.term_to_string t));
      match env with
          | [] when not <| List.contains CompressUvars cfg.steps -> t
          | _ ->
          let t = compress t in
          match t.n with
  
negative.code:             norm cfg env stack head
  
            | Tm_refine(x, f) -> //non tail-recursive; the alternative is to keep marks on the stack to rebuild the term ... but that's very heavy
              if cfg.steps.weak
              then match env, stack with
                      | [], [] -> //TODO: Make this work in general!
                        let t_x = norm cfg env [] x.sort in
  