anchor.diff:          Some (cfg', stack')
   
       | Should_unfold_reify ->
  -        // Reifying, remove the reify from the stack
  -        Some (cfg, List.tl stack)
  +        // Reifying, adding a reflect on the stack to cancel the reify
  +        // NB: The fv in the Const_reflect is bogus, it'll be ignored anyway
  +        let ref = S.mk (Tm_constant (Const_reflect (S.lid_of_fv fv)))
  +                       None Range.dummyRange in
  +        Some (cfg, App (env, ref, None, Range.dummyRange) :: stack)
   
   let rec norm : cfg -> env -> stack -> term -> term =
       fun cfg env stack t ->
  
positive.code:                                           (Print.term_to_string head))
          end;
  
          let head_app, found_action = maybe_unfold_action head_app in
          let mk tm = S.mk tm None head.pos in
          let body = mk (Tm_app(head_app, args)) in
          let body = match found_action with
            (* This is not an action let's just keep the reify marker *)
            | None -> U.mk_reify body
  
            (* The action was found but not unfolded (maybe abstract ?) *)
            | Some false -> mk (Tm_meta (body, Meta_monadic(m, t)))
  
            (* An action was found and successfully unfolded *)
            | Some true -> body
          in
          log cfg (fun () -> BU.print2 "Reified (2) <%s> to %s\n" (Print.term_to_string head0) (Print.term_to_string body));
          norm cfg env (List.tl stack) body
  
      // Doubly-annotated effect.. just take the outmost one. (unsure..)
      | Tm_meta(e, Meta_monadic _) ->
  
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 =
  