anchor.diff:          end;
           if nsuccess < lo then begin
               let report errs = report_errors ({default_settings with query_errors=errs}) in
  -            List.iter (function | Inr _ -> ()
  -                                | Inl es -> report es) rs;
  +            let all_errs = List.concatMap (function | Inr _ -> []
  +                                                    | Inl es -> [es]) rs in
  +            (* Unless we are running with --query_stats, summarize errors
  +             * so quaking does not show hundreds of them *)
  +            let () =
  +              if Options.query_stats ()
  +              then List.iter report all_errs
  +              else
  +                let errs = List.flatten all_errs in
  +                let errs = collect errs in
  +                let tag_er n er =
  +                    if n <= 1 then er else
  +                    { er with error_messages =
  +                              er.error_messages |>
  +                              List.map (fun (e, m, r) ->
  +                                          let m = m ^ BU.format1 " (%s times)" (string_of_int n) in
  +                                          (e, m, r)) }
  +                in
  +                let tag_with_n n errs =
  +                  List.map (tag_er n) errs
  +                in
  +                let errs = List.map (fun (errs, n) -> tag_er n errs) errs in
  +                (* let errs = List.map (fun (err, n) -> err) errs in *)
  +                (* Now report them *)
  +                report errs
  +            in
  +
               let rng = match snd (env.qtbl_name_and_index) with
                         | Some (l, _) -> Ident.range_of_lid l
                         | _ -> Range.dummyRange
  
positive.code: let full_query_id settings =
      "(" ^ settings.query_name ^ ", " ^ (BU.string_of_int settings.query_index) ^ ")"
  
  let ask_and_report_errors env all_labels prefix query suffix : unit =
      Z3.giveZ3 prefix; //feed the context of the query to the solver
  
  
negative.code: let find_localized_errors errs =
      errs |> List.tryFind (fun err -> match err.error_messages with [] -> false | _ -> true)
  
  let report_errors (settings : query_settings) : unit =
      let format_smt_error msg =
        BU.format1 "SMT solver says:\n\t%s;\n\t\
                    Note: 'canceled' or 'resource limits reached' means the SMT query timed out, so you might want to increase the rlimit;\n\t\
  