anchor.diff:                else tail in
               norm cfg' env stack' tm
   
  -          | Tm_app({n=Tm_constant Const_range_of}, a1::a2::rest)
  -          | Tm_app({n=Tm_constant FC.Const_reify}, a1::a2::rest) ->
  -            let hd, _ = U.head_and_args t in
  -            let t' = S.mk (Tm_app(hd, [a1])) None t.pos in
  -            let t = S.mk(Tm_app(t', a2::rest)) None t.pos in
  -            norm cfg env stack t
  -
  -          | Tm_app({n=Tm_constant Const_set_range_of}, a1::a2::a3::rest) ->
  -            let hd, _ = U.head_and_args t in
  -            let t' = S.mk (Tm_app(hd, [a1;a2])) None t.pos in
  -            let t = S.mk(Tm_app(t', a3::rest)) None t.pos in
  -            norm cfg env stack t
  -
  -          | Tm_app({n=Tm_constant (FC.Const_reflect _)}, [a])
  -                when (cfg.steps |> List.contains Reify &&
  -                      is_reify_head stack) ->
  -            norm cfg env (List.tl stack) (fst a)
  -
  -          | Tm_app({n=Tm_constant FC.Const_reify}, [a])
  -                when (cfg.steps |> List.contains Reify) ->
  -            let reify_head, _ = U.head_and_args t in
  -            let a = SS.compress (U.unascribe <| fst a) in
  -            //BU.print2_warning "TRYING NORMALIZATION OF REIFY: %s ... %s\n" (Print.tag_of_term a) (Print.term_to_string a);
  -            begin match a.n with
  -              (* KM : This assumes that reflect is never tagged by a Meta_monadic flag *)
  -              (* Is that really the case ? *)
  -              | Tm_app({n=Tm_constant (FC.Const_reflect _)}, [a]) ->
  -                //reify (reflect e) ~> e
  -                norm cfg env stack (fst a)
  -
  -              (* KM : This case reall y does not make any sense to me *)
  -              // | Tm_match(e, branches) ->
  -              //   //reify (match e with p -> e') ~> match (reify e) with p -> reify e'
  -              //   let e = U.mk_reify e in
  -              //   let branches = branches |> List.map (fun (pat, wopt, tm) -> pat, wopt, U.mk_reify tm) in
  -              //   let tm = mk (Tm_match(e, branches)) t.pos in
  -              //   norm cfg env stack tm
  -
  -              | _ ->
  -                let stack = App(env, reify_head, None, t.pos)::stack in
  -                norm cfg env stack a
  -            end
  -
             | Tm_type u ->
               let u = norm_universe cfg env u in
               rebuild cfg env stack (mk (Tm_type u) t.pos)
  
positive.code:     end
  
    | App(env, head, aq, r)::stack' when should_reify cfg stack ->
      begin match (SS.compress t).n with
      | Tm_meta (t, Meta_monadic (m, ty)) ->
         log cfg (fun () -> BU.print1 "Will reify: %s \n" (stack_to_string stack));
         do_reify_monadic cfg env stack t m ty
  
      | Tm_meta (t, Meta_monadic_lift (m, m', ty)) ->
         log cfg (fun () -> BU.print1 "Will reify lift: %s \n" (stack_to_string stack));
         norm cfg env stack (reify_lift cfg.tcenv t m m' (closure_as_term cfg env ty))
  
      | _ ->
         log cfg (fun () -> BU.print1 "Not reifying: %s \n" (stack_to_string stack));
         let t = S.extend_app head (t,aq) None r in
         rebuild cfg env stack' (maybe_simplify cfg env stack' t)
      end
  
    | App(env, head, aq, r)::stack ->
  
negative.code:             norm cfg body_env stack body
  
            | Tm_meta (head, m) ->
              log cfg (fun () -> BU.print1 ">> metadata = %s\n" (Print.metadata_to_string m));
              begin match m with
                | Meta_monadic (m, t) ->
                  reduce_impure_comp cfg env stack head (Inl m) t
  