anchor.diff:          | _ -> false
       in
       let simplify arg = (simp_t (fst arg), arg) in
  -    match is_quantified_true tm with
  +    match is_quantified_const 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 *)
  
positive.code:                       end
  
              // Case 2)
              | Some (QAll (bs, pats, phi)) ->
                  begin match is_applied_maybe_squashed bs phi with
                  | Some bv ->
                      let ftrue = U.abs bs U.t_true (Some (U.residual_tot U.ktype0)) in
                      Some (SS.subst [NT (bv, ftrue)] q)
                  | None ->
                      None
                  end
  
  
negative.code:     in
      // A very F*-specific optimization:
      //  1)                        (p ==> E[p])     ~>     E[True]
      //  2)                       (~p ==> E[p])     ~>     E[False]
      //  3)  (forall j1 j2 ... jn. p j1 j2 ... jn)    ==> E[p]    ~>    E[(fun j1 j2 ... jn -> True)]
      //  4)  (forall j1 j2 ... jn. ~(p j1 j2 ... jn)) ==> E[p]    ~>    E[(fun j1 j2 ... jn -> False)]
      let is_quantified_const (phi : term) : option<term> =
          match U.destruct_typ_as_formula phi with
          | Some (BaseConn (lid, [(p, _); (q, _)])) when Ident.lid_equals lid PC.imp_lid ->
              begin match U.destruct_typ_as_formula p with
  