anchor.diff:  
               | _ -> None
               end
  +        | _ -> None
  +    in
  +    let is_const_match (phi : term) : option<bool> =
  +        match (SS.compress phi).n with
  +        (* Trying to be efficient, but just checking if they all agree *)
  +        (* Note, if we wanted to do this for any term instead of just True/False
  +         * we need to open the terms *)
  +        | Tm_match (_, br::brs) ->
  +            let (_, _, e) = br in
  +            let r = begin match simp_t e with
  +            | None -> None
  +            | Some b -> if List.for_all (fun (_, _, e') -> simp_t e' = Some b) brs
  +                        then Some b
  +                        else None
  +            end
  +            in
  +            r
           | _ -> None
       in
       let maybe_auto_squash t =
  
positive.code:         | Some false -> tm
          | None -> tm
          end
      | _ -> tm
  
  let maybe_simplify cfg env stack tm =
  
negative.code:           let flags = filter_out_lcomp_cflags rc.residual_flags in
            Some ({rc with residual_typ=BU.map_opt rc.residual_typ (norm cfg env [])})
         | _ -> lopt
  
  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 *)
  