anchor.diff:                                    delta_level=[Unfold delta_constant];
                                     normalize_pure_lets=true} in
               begin
  -            match get_norm_request (norm cfg' env []) args with
  +            match get_norm_request cfg (norm cfg' env []) args with
               | None -> //just normalize it as a normal application
                 let stack =
                   stack |>
  
positive.code: let tr_norm_steps s =
      List.concatMap tr_norm_step s
  
  let get_norm_request (full_norm:term -> term) args =
      let parse_steps s =
        match EMB.try_unembed (EMB.e_list EMB.e_norm_step) s with
        | Some steps -> Some (tr_norm_steps steps)
        | None -> None
      in
      match args with
      | [_; (tm, _)]
      | [(tm, _)] ->
        let s = [Beta; Zeta; Iota; Primops; UnfoldUntil delta_constant; Reify] in
        Some (s, tm)
      | [(steps, _); _; (tm, _)] ->
        let add_exclude s z = if List.contains z s then s else Exclude z :: s in
        begin
  
negative.code:         let s = Beta::s in
          let s = add_exclude s Zeta in
          let s = add_exclude s Iota in
          Some (inherited_steps @ s, tm)
        end
      | _ ->
        None
  