anchor.diff:          | _ -> false
       in
       let simplify arg = (simp_t (fst arg), arg) in
  -    let tm = match is_quantified_true tm with
  -             | Some tm ->
  -                (* We need to recurse! *)
  -                maybe_simplify_aux cfg env stack tm
  -             | None -> tm
  -    in
  +    match is_quantified_true tm with
  +    (* We need to recurse, and maybe reduce further! *)
  +    | Some tm -> maybe_simplify_aux cfg env stack (norm cfg env [] tm)
  +    (* Otherwise try to simplify this point *)
  +    | None ->
       match (SS.compress tm).n with
       | Tm_app({n=Tm_uinst({n=Tm_fvar fv}, _)}, args)
       | Tm_app({n=Tm_fvar fv}, args) ->
  
positive.code:     reduce_primops ({cfg with steps = { default_steps with primops = true };
                                primitive_steps=equality_ops}) tm
  
  (*******************************************************************)
  (* Simplification steps are not part of definitional equality      *)
  (* simplifies True /\ t, t /\ True, t /\ False, False /\ t etc.    *)
  (*******************************************************************)
  let rec maybe_simplify_aux cfg env stack tm =
      let tm = reduce_primops cfg env stack tm in
      if not <| cfg.steps.simplify then tm
      else
  
negative.code:         end
      | _ -> tm
  
  
  and rebuild (cfg:cfg) (env:env) (stack:stack) (t:term) : term =
    (* Pre-condition: t is in either weak or strong normal form w.r.t env, depending on *)
  