anchor.diff:          (* resulting application is reified again                                     *)
           (* ****************************************************************************)
   
  -        (* [maybe_unfold_action head] test whether [head] is an action and tries to unfold it if it is *)
  -        let maybe_unfold_action head : term * option<bool> =
  -          let maybe_extract_fv t =
  -            let t = match (SS.compress t).n with
  -              | Tm_uinst (t, _) -> t
  -              | _ -> head
  -            in match (SS.compress t).n with
  -              | Tm_fvar x -> Some x
  -              | _ -> None
  -          in
  -          match maybe_extract_fv head with
  -          | Some x when Env.is_action cfg.tcenv (S.lid_of_fv x) ->
  -            (* Note that this is not a tail call, but it's a bounded (small) number of recursive steps *)
  -            let head = norm cfg env [] head in
  -            let action_unfolded = match maybe_extract_fv head with | Some _ -> Some true | _ -> Some false in
  -            head, action_unfolded
  -          | _ ->
  -            head, None
  -        in
  -
           (* Checking that the typechecker did its job correctly and hoisted all impure *)
           (* terms to explicit let-bindings (see TcTerm, monadic_application) *)
           (* GM: Now only when --defensive is on, so we don't waste cycles otherwise *)
  
positive.code:         Some (cfg', stack')
  
      | Should_unfold_reify ->
          // Reifying, remove the reify from the stack
          Some (cfg, List.tl stack)
  
  let rec norm : cfg -> env -> stack -> term -> term =
      fun cfg env stack t ->
  
negative.code:       false
  
  let firstn k l = if List.length l < k then l,[] else first_N k l
  let should_reify cfg stack =
      let rec drop_irrel = function
          | MemoLazy _ :: s -> drop_irrel s
          | s -> s
      in
      match drop_irrel stack with
      | App (_, {n=Tm_constant FC.Const_reify}, _, _) :: _ ->
          // BU.print1 "Found a reify on the stack. %s" "" ;
          cfg.steps.reify_
      | _ -> false
  
  let rec maybe_weakly_reduced tm :  bool =
      let aux_comp c =
  