LLVMFuzzerTestOneInput:
   22|    534|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   23|    534|  static std::shared_ptr<spdlog::logger> my_logger;
   24|    534|  if (!my_logger.get()) {
  ------------------
  |  Branch (24:7): [True: 1, False: 533]
  ------------------
   25|      1|    my_logger = spdlog::basic_logger_mt("basic_logger", "/dev/null");
   26|      1|    spdlog::set_default_logger(my_logger);
   27|      1|  }
   28|       |
   29|    534|  if (size == 0) {
  ------------------
  |  Branch (29:7): [True: 0, False: 534]
  ------------------
   30|      0|    return 0;
   31|      0|  }
   32|       |
   33|    534|  FuzzedDataProvider stream(data, size);
   34|       |
   35|    534|  const uint16_t size_arg = stream.ConsumeIntegral<uint16_t>();
   36|       |
   37|    534|  spdlog::enable_backtrace(size_arg);
   38|  15.1M|  for(int i=0; i<size_arg; i++){
  ------------------
  |  Branch (38:16): [True: 15.1M, False: 534]
  ------------------
   39|  15.1M|    spdlog::debug(stream.ConsumeRandomLengthString(size));
   40|  15.1M|  }
   41|    534|  spdlog::dump_backtrace();
   42|    534|  return 0;
   43|    534|}

_ZN6spdlog5level14to_string_viewENS0_10level_enumE:
   23|  15.1M|SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
   24|  15.1M|    return level_string_views[l];
   25|  15.1M|}

_ZN6spdlog19file_event_handlersC2Ev:
  333|      1|          after_close(nullptr) {}
_ZN6spdlog7details11make_uniqueINS0_14full_formatterEJNS0_12padding_infoEEEENSt3__110unique_ptrIT_NS4_14default_deleteIS6_EEEEDpOT0_:
  389|      3|std::unique_ptr<T> make_unique(Args &&...args) {
  390|      3|    static_assert(!std::is_array<T>::value, "arrays not supported");
  391|      3|    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
  392|      3|}
_ZNK6spdlog10source_loc5emptyEv:
  322|  15.1M|    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
_ZN6spdlog7details11make_uniqueINS_17pattern_formatterEJEEENSt3__110unique_ptrIT_NS3_14default_deleteIS5_EEEEDpOT0_:
  389|      2|std::unique_ptr<T> make_unique(Args &&...args) {
  390|      2|    static_assert(!std::is_array<T>::value, "arrays not supported");
  391|      2|    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
  392|      2|}
_ZN6spdlog7details11make_uniqueINS0_14full_formatterEJRNS0_12padding_infoEEEENSt3__110unique_ptrIT_NS5_14default_deleteIS7_EEEEDpOT0_:
  389|      1|std::unique_ptr<T> make_unique(Args &&...args) {
  390|      1|    static_assert(!std::is_array<T>::value, "arrays not supported");
  391|      1|    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
  392|      1|}
_ZN6spdlog10source_locC2Ev:
  316|  45.3M|    SPDLOG_CONSTEXPR source_loc() = default;
_ZN6spdlog7details11make_uniqueINS_17pattern_formatterEJRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS_17pattern_time_typeESB_NS3_13unordered_mapIcNS3_10unique_ptrINS_21custom_flag_formatterENS3_14default_deleteISH_EEEENS3_4hashIcEENS3_8equal_toIcEENS7_INS3_4pairIKcSK_EEEEEEEEENSG_IT_NSI_ISU_EEEEDpOT0_:
  389|      1|std::unique_ptr<T> make_unique(Args &&...args) {
  390|      1|    static_assert(!std::is_array<T>::value, "arrays not supported");
  391|      1|    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
  392|      1|}

_ZN6spdlog7details10backtracer6enableEm:
   30|  1.06k|SPDLOG_INLINE void backtracer::enable(size_t size) {
   31|  1.06k|    std::lock_guard<std::mutex> lock{mutex_};
   32|  1.06k|    enabled_.store(true, std::memory_order_relaxed);
   33|  1.06k|    messages_ = circular_q<log_msg_buffer>{size};
   34|  1.06k|}
_ZNK6spdlog7details10backtracer7enabledEv:
   41|  15.1M|SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }
_ZNK6spdlog7details10backtracer5emptyEv:
   48|    534|SPDLOG_INLINE bool backtracer::empty() const {
   49|    534|    std::lock_guard<std::mutex> lock{mutex_};
   50|    534|    return messages_.empty();
   51|    534|}
_ZN6spdlog7details10backtracer11foreach_popENSt3__18functionIFvRKNS0_7log_msgEEEE:
   54|    532|SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun) {
   55|    532|    std::lock_guard<std::mutex> lock{mutex_};
   56|  15.1M|    while (!messages_.empty()) {
  ------------------
  |  Branch (56:12): [True: 15.1M, False: 532]
  ------------------
   57|  15.1M|        auto &front_msg = messages_.front();
   58|  15.1M|        fun(front_msg);
   59|  15.1M|        messages_.pop_front();
   60|  15.1M|    }
   61|    532|}
_ZN6spdlog7details10backtracer9push_backERKNS0_7log_msgE:
   43|  15.1M|SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) {
   44|  15.1M|    std::lock_guard<std::mutex> lock{mutex_};
   45|  15.1M|    messages_.push_back(log_msg_buffer{msg});
   46|  15.1M|}

_ZN6spdlog7details10backtracerC2Ev:
   24|      2|    backtracer() = default;

_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEEC2Ev:
   26|      2|    circular_q() = default;
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEEC2Em:
   31|  1.06k|          v_(max_items_) {}
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEEaSEOS3_:
   40|  1.06k|    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT {
   41|  1.06k|        copy_moveable(std::move(other));
   42|  1.06k|        return *this;
   43|  1.06k|    }
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEE13copy_moveableEOS3_:
  101|  1.06k|    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT {
  102|  1.06k|        max_items_ = other.max_items_;
  103|  1.06k|        head_ = other.head_;
  104|  1.06k|        tail_ = other.tail_;
  105|  1.06k|        overrun_counter_ = other.overrun_counter_;
  106|  1.06k|        v_ = std::move(other.v_);
  107|       |
  108|       |        // put &&other in disabled, but valid state
  109|  1.06k|        other.max_items_ = 0;
  110|  1.06k|        other.head_ = other.tail_ = 0;
  111|  1.06k|        other.overrun_counter_ = 0;
  112|  1.06k|    }
_ZNK6spdlog7details10circular_qINS0_14log_msg_bufferEE5emptyEv:
   85|  15.1M|    bool empty() const { return tail_ == head_; }
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEE5frontEv:
   63|  15.1M|    T &front() { return v_[head_]; }
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEE9pop_frontEv:
   83|  15.1M|    void pop_front() { head_ = (head_ + 1) % max_items_; }
_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEE9push_backEOS2_:
   46|  15.1M|    void push_back(T &&item) {
   47|  15.1M|        if (max_items_ > 0) {
  ------------------
  |  Branch (47:13): [True: 15.1M, False: 0]
  ------------------
   48|  15.1M|            v_[tail_] = std::move(item);
   49|  15.1M|            tail_ = (tail_ + 1) % max_items_;
   50|       |
   51|  15.1M|            if (tail_ == head_)  // overrun last item if full
  ------------------
  |  Branch (51:17): [True: 0, False: 15.1M]
  ------------------
   52|      0|            {
   53|      0|                head_ = (head_ + 1) % max_items_;
   54|      0|                ++overrun_counter_;
   55|      0|            }
   56|  15.1M|        }
   57|  15.1M|    }

_ZN6spdlog7details13console_mutex5mutexEv:
   14|      1|    static mutex_t &mutex() {
   15|      1|        static mutex_t s_mutex;
   16|      1|        return s_mutex;
   17|      1|    }

_ZN6spdlog7details11file_helperC2ERKNS_19file_event_handlersE:
   24|      1|    : event_handlers_(event_handlers) {}
_ZN6spdlog7details11file_helper4openERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb:
   28|      1|SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
   29|      1|    close();
   30|      1|    filename_ = fname;
   31|       |
   32|      1|    auto *mode = SPDLOG_FILENAME_T("ab");
  ------------------
  |  |  138|      1|    #define SPDLOG_FILENAME_T(s) s
  ------------------
   33|      1|    auto *trunc_mode = SPDLOG_FILENAME_T("wb");
  ------------------
  |  |  138|      1|    #define SPDLOG_FILENAME_T(s) s
  ------------------
   34|       |
   35|      1|    if (event_handlers_.before_open) {
  ------------------
  |  Branch (35:9): [True: 0, False: 1]
  ------------------
   36|      0|        event_handlers_.before_open(filename_);
   37|      0|    }
   38|      1|    for (int tries = 0; tries < open_tries_; ++tries) {
  ------------------
  |  Branch (38:25): [True: 1, False: 0]
  ------------------
   39|       |        // create containing folder if not exists already.
   40|      1|        os::create_dir(os::dir_name(fname));
   41|      1|        if (truncate) {
  ------------------
  |  Branch (41:13): [True: 0, False: 1]
  ------------------
   42|       |            // Truncate by opening-and-closing a tmp file in "wb" mode, always
   43|       |            // opening the actual log-we-write-to in "ab" mode, since that
   44|       |            // interacts more politely with eternal processes that might
   45|       |            // rotate/truncate the file underneath us.
   46|      0|            std::FILE *tmp;
   47|      0|            if (os::fopen_s(&tmp, fname, trunc_mode)) {
  ------------------
  |  Branch (47:17): [True: 0, False: 0]
  ------------------
   48|      0|                continue;
   49|      0|            }
   50|      0|            std::fclose(tmp);
   51|      0|        }
   52|      1|        if (!os::fopen_s(&fd_, fname, mode)) {
  ------------------
  |  Branch (52:13): [True: 1, False: 0]
  ------------------
   53|      1|            if (event_handlers_.after_open) {
  ------------------
  |  Branch (53:17): [True: 0, False: 1]
  ------------------
   54|      0|                event_handlers_.after_open(filename_, fd_);
   55|      0|            }
   56|      1|            return;
   57|      1|        }
   58|       |
   59|      0|        details::os::sleep_for_millis(open_interval_);
   60|      0|    }
   61|       |
   62|      0|    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing",
   63|      0|                    errno);
   64|      0|}
_ZN6spdlog7details11file_helper5closeEv:
   85|      2|SPDLOG_INLINE void file_helper::close() {
   86|      2|    if (fd_ != nullptr) {
  ------------------
  |  Branch (86:9): [True: 1, False: 1]
  ------------------
   87|      1|        if (event_handlers_.before_close) {
  ------------------
  |  Branch (87:13): [True: 0, False: 1]
  ------------------
   88|      0|            event_handlers_.before_close(filename_, fd_);
   89|      0|        }
   90|       |
   91|      1|        std::fclose(fd_);
   92|      1|        fd_ = nullptr;
   93|       |
   94|      1|        if (event_handlers_.after_close) {
  ------------------
  |  Branch (94:13): [True: 0, False: 1]
  ------------------
   95|      0|            event_handlers_.after_close(filename_);
   96|      0|        }
   97|      1|    }
   98|      2|}
_ZN6spdlog7details11file_helperD2Ev:
   26|      1|SPDLOG_INLINE file_helper::~file_helper() { close(); }
_ZN6spdlog7details11file_helper5writeERKN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
  100|  15.1M|SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
  101|  15.1M|    if (fd_ == nullptr) return;
  ------------------
  |  Branch (101:9): [True: 0, False: 15.1M]
  ------------------
  102|  15.1M|    size_t msg_size = buf.size();
  103|  15.1M|    auto data = buf.data();
  104|  15.1M|    if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
  ------------------
  |  Branch (104:9): [True: 0, False: 15.1M]
  ------------------
  105|      0|        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
  106|      0|    }
  107|  15.1M|}

_ZN6spdlog7details10fmt_helper18append_string_viewEN3fmt3v1017basic_string_viewIcEERNS3_19basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
   21|  60.4M|inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
   22|  60.4M|    auto *buf_ptr = view.data();
   23|  60.4M|    dest.append(buf_ptr, buf_ptr + view.size());
   24|  60.4M|}
_ZN6spdlog7details10fmt_helper10append_intIiEEvT_RN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
   42|     34|inline void append_int(T n, memory_buf_t &dest) {
   43|     34|    fmt::format_int i(n);
   44|     34|    dest.append(i.data(), i.data() + i.size());
   45|     34|}
_ZN6spdlog7details10fmt_helper4pad2EiRN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
   84|    170|inline void pad2(int n, memory_buf_t &dest) {
   85|    170|    if (n >= 0 && n < 100)  // 0-99
  ------------------
  |  Branch (85:9): [True: 170, False: 0]
  |  Branch (85:19): [True: 170, False: 0]
  ------------------
   86|    170|    {
   87|    170|        dest.push_back(static_cast<char>('0' + n / 10));
   88|    170|        dest.push_back(static_cast<char>('0' + n % 10));
   89|    170|    } else  // unlikely, but just in case, let fmt deal with it
   90|      0|    {
   91|      0|        fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
  ------------------
  |  |   55|      0|    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
  |  |  ------------------
  |  |  |  | 1848|      0|#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, )
  |  |  |  |  ------------------
  |  |  |  |  |  | 1825|      0|  [] {                                                                        \
  |  |  |  |  |  | 1826|      0|    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */    \
  |  |  |  |  |  | 1827|      0|    /* Use a macro-like name to avoid shadowing warnings. */                  \
  |  |  |  |  |  | 1828|      0|    struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {               \
  |  |  |  |  |  | 1829|      0|      using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \
  |  |  |  |  |  | 1830|      0|      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                                 \
  |  |  |  |  |  | 1831|      0|      operator fmt::basic_string_view<char_type>() const {                    \
  |  |  |  |  |  | 1832|      0|        return fmt::detail_exported::compile_string_to_view<char_type>(s);    \
  |  |  |  |  |  | 1833|      0|      }                                                                       \
  |  |  |  |  |  | 1834|      0|    };                                                                        \
  |  |  |  |  |  | 1835|      0|    return FMT_COMPILE_STRING();                                              \
  |  |  |  |  |  | 1836|      0|  }()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   92|      0|    }
   93|    170|}
_ZN6spdlog7details10fmt_helper13time_fractionINSt3__16chrono8durationIxNS3_5ratioILl1ELl1000EEEEEEET_NS4_10time_pointINS4_12system_clockENS5_IxNS6_ILl1ELl1000000EEEEEEE:
  131|  15.1M|inline ToDuration time_fraction(log_clock::time_point tp) {
  132|  15.1M|    using std::chrono::duration_cast;
  133|  15.1M|    using std::chrono::seconds;
  134|  15.1M|    auto duration = tp.time_since_epoch();
  135|  15.1M|    auto secs = duration_cast<seconds>(duration);
  136|  15.1M|    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
  137|  15.1M|}
_ZN6spdlog7details10fmt_helper4pad3IjEEvT_RN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
  105|  15.1M|inline void pad3(T n, memory_buf_t &dest) {
  106|  15.1M|    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
  107|  15.1M|    if (n < 1000) {
  ------------------
  |  Branch (107:9): [True: 15.1M, False: 0]
  ------------------
  108|  15.1M|        dest.push_back(static_cast<char>(n / 100 + '0'));
  109|  15.1M|        n = n % 100;
  110|  15.1M|        dest.push_back(static_cast<char>((n / 10) + '0'));
  111|  15.1M|        dest.push_back(static_cast<char>((n % 10) + '0'));
  112|  15.1M|    } else {
  113|      0|        append_int(n, dest);
  114|      0|    }
  115|  15.1M|}

_ZN6spdlog7details7log_msgC2EN3fmt3v1017basic_string_viewIcEENS_5level10level_enumES5_:
   41|  1.06k|    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}
_ZN6spdlog7details7log_msgC2ENSt3__16chrono10time_pointINS3_12system_clockENS3_8durationIxNS2_5ratioILl1ELl1000000EEEEEEENS_10source_locEN3fmt3v1017basic_string_viewIcEENS_5level10level_enumESF_:
   29|  15.1M|      payload(msg) {
   30|  15.1M|}
_ZN6spdlog7details7log_msgC2ENS_10source_locEN3fmt3v1017basic_string_viewIcEENS_5level10level_enumES6_:
   36|  15.1M|    : log_msg(os::now(), loc, a_logger_name, lvl, msg) {}

_ZN6spdlog7details7log_msgC2Ev:
   12|  30.2M|    log_msg() = default;

_ZN6spdlog7details14log_msg_buffer19update_string_viewsEv:
   48|  30.2M|SPDLOG_INLINE void log_msg_buffer::update_string_views() {
   49|  30.2M|    logger_name = string_view_t{buffer.data(), logger_name.size()};
   50|  30.2M|    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
   51|  30.2M|}
_ZN6spdlog7details14log_msg_bufferaSEOS1_:
   41|  15.1M|SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT {
   42|  15.1M|    log_msg::operator=(other);
   43|  15.1M|    buffer = std::move(other.buffer);
   44|  15.1M|    update_string_views();
   45|  15.1M|    return *this;
   46|  15.1M|}
_ZN6spdlog7details14log_msg_bufferC2ERKNS0_7log_msgE:
   14|  15.1M|    : log_msg{orig_msg} {
   15|  15.1M|    buffer.append(logger_name.begin(), logger_name.end());
   16|  15.1M|    buffer.append(payload.begin(), payload.end());
   17|  15.1M|    update_string_views();
   18|  15.1M|}

_ZN6spdlog7details14log_msg_bufferC2Ev:
   19|  30.2M|    log_msg_buffer() = default;

_ZN6spdlog7details2os11in_terminalEP8_IO_FILE:
  432|      1|SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
  433|       |#ifdef _WIN32
  434|       |    return ::_isatty(_fileno(file)) != 0;
  435|       |#else
  436|      1|    return ::isatty(fileno(file)) != 0;
  437|      1|#endif
  438|      1|}
_ZN6spdlog7details2os3nowEv:
   76|  15.1M|SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
   77|       |#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
   78|       |    timespec ts;
   79|       |    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
   80|       |    return std::chrono::time_point<log_clock, typename log_clock::duration>(
   81|       |        std::chrono::duration_cast<typename log_clock::duration>(
   82|       |            std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
   83|       |
   84|       |#else
   85|  15.1M|    return log_clock::now();
   86|  15.1M|#endif
   87|  15.1M|}
_ZN6spdlog7details2os9thread_idEv:
  361|  15.1M|SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
  362|       |#if defined(SPDLOG_NO_TLS)
  363|       |    return _thread_id();
  364|       |#else  // cache thread id in tls
  365|  15.1M|    static thread_local const size_t tid = _thread_id();
  366|  15.1M|    return tid;
  367|  15.1M|#endif
  368|  15.1M|}
_ZN6spdlog7details2os10_thread_idEv:
  310|      1|SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
  311|       |#ifdef _WIN32
  312|       |    return static_cast<size_t>(::GetCurrentThreadId());
  313|       |#elif defined(__linux__)
  314|       |    #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
  315|       |        #define SYS_gettid __NR_gettid
  316|       |    #endif
  317|      1|    return static_cast<size_t>(::syscall(SYS_gettid));
  318|       |#elif defined(_AIX)
  319|       |    struct __pthrdsinfo buf;
  320|       |    int reg_size = 0;
  321|       |    pthread_t pt = pthread_self();
  322|       |    int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, &reg_size);
  323|       |    int tid = (!retval) ? buf.__pi_tid : 0;
  324|       |    return static_cast<size_t>(tid);
  325|       |#elif defined(__DragonFly__) || defined(__FreeBSD__)
  326|       |    return static_cast<size_t>(::pthread_getthreadid_np());
  327|       |#elif defined(__NetBSD__)
  328|       |    return static_cast<size_t>(::_lwp_self());
  329|       |#elif defined(__OpenBSD__)
  330|       |    return static_cast<size_t>(::getthrid());
  331|       |#elif defined(__sun)
  332|       |    return static_cast<size_t>(::thr_self());
  333|       |#elif __APPLE__
  334|       |    uint64_t tid;
  335|       |    // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
  336|       |    // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
  337|       |    #ifdef MAC_OS_X_VERSION_MAX_ALLOWED
  338|       |    {
  339|       |        #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
  340|       |        tid = pthread_mach_thread_np(pthread_self());
  341|       |        #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
  342|       |        if (&pthread_threadid_np) {
  343|       |            pthread_threadid_np(nullptr, &tid);
  344|       |        } else {
  345|       |            tid = pthread_mach_thread_np(pthread_self());
  346|       |        }
  347|       |        #else
  348|       |        pthread_threadid_np(nullptr, &tid);
  349|       |        #endif
  350|       |    }
  351|       |    #else
  352|       |    pthread_threadid_np(nullptr, &tid);
  353|       |    #endif
  354|       |    return static_cast<size_t>(tid);
  355|       |#else  // Default to standard C++11 (other Unix)
  356|       |    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
  357|       |#endif
  358|      1|}
_ZN6spdlog7details2os9localtimeERKl:
   88|     34|SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
   89|       |#ifdef _WIN32
   90|       |    std::tm tm;
   91|       |    ::localtime_s(&tm, &time_tt);
   92|       |#else
   93|     34|    std::tm tm;
   94|     34|    ::localtime_r(&time_tt, &tm);
   95|     34|#endif
   96|     34|    return tm;
   97|     34|}
_ZN6spdlog7details2os10create_dirERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  519|      1|SPDLOG_INLINE bool create_dir(const filename_t &path) {
  520|      1|    if (path_exists(path)) {
  ------------------
  |  Branch (520:9): [True: 1, False: 0]
  ------------------
  521|      1|        return true;
  522|      1|    }
  523|       |
  524|      0|    if (path.empty()) {
  ------------------
  |  Branch (524:9): [True: 0, False: 0]
  ------------------
  525|      0|        return false;
  526|      0|    }
  527|       |
  528|      0|    size_t search_offset = 0;
  529|      0|    do {
  530|      0|        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
  531|       |        // treat the entire path as a folder if no folder separator not found
  532|      0|        if (token_pos == filename_t::npos) {
  ------------------
  |  Branch (532:13): [True: 0, False: 0]
  ------------------
  533|      0|            token_pos = path.size();
  534|      0|        }
  535|       |
  536|      0|        auto subdir = path.substr(0, token_pos);
  537|       |#ifdef _WIN32
  538|       |        // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
  539|       |        // otherwise path_exists(subdir) returns false (issue #3079)
  540|       |        const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
  541|       |        if (is_drive) {
  542|       |            subdir += '\\';
  543|       |            token_pos++;
  544|       |        }
  545|       |#endif
  546|       |
  547|      0|        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
  ------------------
  |  Branch (547:13): [True: 0, False: 0]
  |  Branch (547:32): [True: 0, False: 0]
  |  Branch (547:56): [True: 0, False: 0]
  ------------------
  548|      0|            return false;  // return error if failed creating dir
  549|      0|        }
  550|      0|        search_offset = token_pos + 1;
  551|      0|    } while (search_offset < path.size());
  ------------------
  |  Branch (551:14): [True: 0, False: 0]
  ------------------
  552|       |
  553|      0|    return true;
  554|      0|}
_ZN6spdlog7details2os11path_existsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  178|      1|SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
  179|       |#ifdef _WIN32
  180|       |    struct _stat buffer;
  181|       |    #ifdef SPDLOG_WCHAR_FILENAMES
  182|       |    return (::_wstat(filename.c_str(), &buffer) == 0);
  183|       |    #else
  184|       |    return (::_stat(filename.c_str(), &buffer) == 0);
  185|       |    #endif
  186|       |#else  // common linux/unix all have the stat system call
  187|      1|    struct stat buffer;
  188|      1|    return (::stat(filename.c_str(), &buffer) == 0);
  189|      1|#endif
  190|      1|}
_ZN6spdlog7details2os8dir_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  561|      1|SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
  562|      1|    auto pos = path.find_last_of(folder_seps_filename);
  563|      1|    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
  ------------------
  |  Branch (563:12): [True: 1, False: 0]
  ------------------
  564|      1|}
_ZN6spdlog7details2os7fopen_sEPP8_IO_FILERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  121|      1|SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
  122|       |#ifdef _WIN32
  123|       |    #ifdef SPDLOG_WCHAR_FILENAMES
  124|       |    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
  125|       |    #else
  126|       |    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
  127|       |    #endif
  128|       |    #if defined(SPDLOG_PREVENT_CHILD_FD)
  129|       |    if (*fp != nullptr) {
  130|       |        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
  131|       |        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
  132|       |            ::fclose(*fp);
  133|       |            *fp = nullptr;
  134|       |        }
  135|       |    }
  136|       |    #endif
  137|       |#else  // unix
  138|       |    #if defined(SPDLOG_PREVENT_CHILD_FD)
  139|       |    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
  140|       |    const int fd =
  141|       |        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
  142|       |    if (fd == -1) {
  143|       |        return true;
  144|       |    }
  145|       |    *fp = ::fdopen(fd, mode.c_str());
  146|       |    if (*fp == nullptr) {
  147|       |        ::close(fd);
  148|       |    }
  149|       |    #else
  150|      1|    *fp = ::fopen((filename.c_str()), mode.c_str());
  151|      1|    #endif
  152|      1|#endif
  153|       |
  154|      1|    return *fp == nullptr;
  155|      1|}

_ZN6spdlog7details8registry8instanceEv:
  236|  15.1M|SPDLOG_INLINE registry &registry::instance() {
  237|  15.1M|    static registry s_instance;
  238|  15.1M|    return s_instance;
  239|  15.1M|}
_ZN6spdlog7details8registryC2Ev:
   34|      1|    : formatter_(new pattern_formatter()) {
   35|      1|#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
   36|       |    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
   37|       |    #ifdef _WIN32
   38|       |    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
   39|       |    #else
   40|      1|    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
   41|      1|    #endif
   42|       |
   43|      1|    const char *default_logger_name = "";
   44|      1|    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
   45|      1|    loggers_[default_logger_name] = default_logger_;
   46|       |
   47|      1|#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
   48|      1|}
_ZN6spdlog7details8registryD2Ev:
   50|      1|SPDLOG_INLINE registry::~registry() = default;
_ZN6spdlog7details8registry18set_default_loggerENSt3__110shared_ptrINS_6loggerEEE:
  100|      1|SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
  101|      1|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
  102|      1|    if (new_default_logger != nullptr) {
  ------------------
  |  Branch (102:9): [True: 1, False: 0]
  ------------------
  103|      1|        loggers_[new_default_logger->name()] = new_default_logger;
  104|      1|    }
  105|      1|    default_logger_ = std::move(new_default_logger);
  106|      1|}
_ZN6spdlog7details8registry16enable_backtraceEm:
  127|    534|SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) {
  128|    534|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
  129|    534|    backtrace_n_messages_ = n_messages;
  130|       |
  131|  1.06k|    for (auto &l : loggers_) {
  ------------------
  |  Branch (131:18): [True: 1.06k, False: 534]
  ------------------
  132|  1.06k|        l.second->enable_backtrace(n_messages);
  133|  1.06k|    }
  134|    534|}
_ZN6spdlog7details8registry15get_default_rawEv:
   96|  15.1M|SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }
_ZN6spdlog7details8registry17initialize_loggerENSt3__110shared_ptrINS_6loggerEEE:
   57|      1|SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {
   58|      1|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
   59|      1|    new_logger->set_formatter(formatter_->clone());
   60|       |
   61|      1|    if (err_handler_) {
  ------------------
  |  Branch (61:9): [True: 0, False: 1]
  ------------------
   62|      0|        new_logger->set_error_handler(err_handler_);
   63|      0|    }
   64|       |
   65|       |    // set new level according to previously configured level or default level
   66|      1|    auto it = log_levels_.find(new_logger->name());
   67|      1|    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
  ------------------
  |  Branch (67:22): [True: 0, False: 1]
  ------------------
   68|      1|    new_logger->set_level(new_level);
   69|       |
   70|      1|    new_logger->flush_on(flush_level_);
   71|       |
   72|      1|    if (backtrace_n_messages_ > 0) {
  ------------------
  |  Branch (72:9): [True: 0, False: 1]
  ------------------
   73|      0|        new_logger->enable_backtrace(backtrace_n_messages_);
   74|      0|    }
   75|       |
   76|      1|    if (automatic_registration_) {
  ------------------
  |  Branch (76:9): [True: 1, False: 0]
  ------------------
   77|      1|        register_logger_(std::move(new_logger));
   78|      1|    }
   79|      1|}
_ZN6spdlog7details8registry16register_logger_ENSt3__110shared_ptrINS_6loggerEEE:
  254|      1|SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
  255|      1|    auto logger_name = new_logger->name();
  256|      1|    throw_if_exists_(logger_name);
  257|      1|    loggers_[logger_name] = std::move(new_logger);
  258|      1|}
_ZN6spdlog7details8registry16throw_if_exists_ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  248|      1|SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
  249|      1|    if (loggers_.find(logger_name) != loggers_.end()) {
  ------------------
  |  Branch (249:9): [True: 0, False: 1]
  ------------------
  250|      0|        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
  251|      0|    }
  252|      1|}

_ZN6spdlog19synchronous_factory6createINS_5sinks15basic_file_sinkINSt3__15mutexEEEJRKNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERbRKNS_19file_event_handlersEEEENS4_10shared_ptrINS_6loggerEEESC_DpOT0_:
   15|      1|    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
   16|      1|        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
   17|      1|        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
   18|      1|        details::registry::instance().initialize_logger(new_logger);
   19|      1|        return new_logger;
   20|      1|    }

_ZN3fmt3v106detail6bufferIcEC2EPcmm:
  828|  60.4M|      : ptr_(p), size_(sz), capacity_(cap) {}
_ZN3fmt3v106detail6bufferIcE3setEPcm:
  834|  75.5M|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
  835|  75.5M|    ptr_ = buf_data;
  836|  75.5M|    capacity_ = buf_capacity;
  837|  75.5M|  }
_ZN3fmt3v106detail13ignore_unusedIJbEEEvDpRKT_:
  319|  25.6k|template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
_ZNK3fmt3v106detail6bufferIcE8capacityEv:
  860|  15.1M|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v106detail6bufferIcE4dataEv:
  863|   151M|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZNK3fmt3v106detail6bufferIcE4sizeEv:
  857|  75.5M|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZNK3fmt3v1017basic_string_viewIcE4dataEv:
  457|  60.4M|  constexpr auto data() const noexcept -> const Char* { return data_; }
_ZN3fmt3v106detail11to_unsignedIlEENSt3__113make_unsignedIT_E4typeES5_:
  392|  90.6M|    typename std::make_unsigned<Int>::type {
  393|  90.6M|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  354|   181M|      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (354:9): [Folded - Ignored]
  |  |  |  Branch (354:9): [True: 90.6M, False: 0]
  |  |  ------------------
  |  |  355|  90.6M|           ? (void)0                                                          \
  |  |  356|  90.6M|           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  394|  90.6M|  return static_cast<typename std::make_unsigned<Int>::type>(value);
  395|  90.6M|}
_ZN3fmt3v106detail6bufferIcE11try_reserveEm:
  880|   256M|  FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) {
  881|   256M|    if (new_capacity > capacity_) grow(new_capacity);
  ------------------
  |  Branch (881:9): [True: 25.6k, False: 256M]
  ------------------
  882|   256M|  }
_ZNK3fmt3v1017basic_string_viewIcE4sizeEv:
  460|   166M|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1017basic_string_viewIcEC2INSt3__111char_traitsIcEENS4_9allocatorIcEEEERKNS4_12basic_stringIcT_T0_EE:
  449|  45.3M|      : data_(s.data()), size_(s.size()) {}
_ZN3fmt3v1017basic_string_viewIcEC2EPKc:
  443|  1.09k|                  : std::char_traits<Char>::length(s)) {}
_ZN3fmt3v106detail6bufferIcE5clearEv:
  867|  8.80k|  void clear() { size_ = 0; }
_ZN3fmt3v106detail6bufferIcE9push_backERKc:
  884|   166M|  FMT_CONSTEXPR20 void push_back(const T& value) {
  885|   166M|    try_reserve(size_ + 1);
  886|   166M|    ptr_[size_++] = value;
  887|   166M|  }
_ZN3fmt3v106detail6bufferIcE10try_resizeEm:
  871|  15.1M|  FMT_CONSTEXPR20 void try_resize(size_t count) {
  872|  15.1M|    try_reserve(count);
  873|  15.1M|    size_ = count <= capacity_ ? count : capacity_;
  ------------------
  |  Branch (873:13): [True: 15.1M, False: 0]
  ------------------
  874|  15.1M|  }
_ZNK3fmt3v1017basic_string_viewIcE5beginEv:
  462|  30.2M|  constexpr auto begin() const noexcept -> iterator { return data_; }
_ZNK3fmt3v1017basic_string_viewIcE3endEv:
  463|  30.2M|  constexpr auto end() const noexcept -> iterator { return data_ + size_; }
_ZN3fmt3v1017basic_string_viewIcEC2EPKcm:
  428|  60.4M|      : data_(s), size_(count) {}
_ZN3fmt3v1017basic_string_viewIcEC2Ev:
  424|  60.4M|  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
_ZN3fmt3v106detail6bufferIcE5beginEv:
  850|  15.1M|  FMT_INLINE auto begin() noexcept -> T* { return ptr_; }
_ZN3fmt3v106detail6bufferIcE3endEv:
  851|  15.1M|  FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; }
_ZNK3fmt3v106detail6bufferIcE4dataEv:
  864|  15.1M|  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
_ZN3fmt3v106detail8copy_strIcccLi0EEEPT1_PT0_S6_S4_:
  803|  15.0M|FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* {
  804|  15.0M|  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
  ------------------
  |  Branch (804:7): [Folded - Ignored]
  ------------------
  805|  15.0M|  auto size = to_unsigned(end - begin);
  806|  15.0M|  if (size > 0) memcpy(out, begin, size * sizeof(U));
  ------------------
  |  Branch (806:7): [True: 15.0M, False: 0]
  ------------------
  807|  15.0M|  return out + size;
  808|  15.0M|}

_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEC2ERKS4_:
  926|  60.4M|      : alloc_(alloc) {
  927|  60.4M|    this->set(store_, SIZE);
  928|  60.4M|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (928:9): [Folded - Ignored]
  ------------------
  929|  60.4M|  }
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEE4growEm:
  897|  25.6k|  FMT_CONSTEXPR20 void grow(size_t size) override {
  898|  25.6k|    detail::abort_fuzzing_if(size > 5000);
  899|  25.6k|    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
  900|  25.6k|    size_t old_capacity = this->capacity();
  901|  25.6k|    size_t new_capacity = old_capacity + old_capacity / 2;
  902|  25.6k|    if (size > new_capacity)
  ------------------
  |  Branch (902:9): [True: 10.8k, False: 14.7k]
  ------------------
  903|  10.8k|      new_capacity = size;
  904|  14.7k|    else if (new_capacity > max_size)
  ------------------
  |  Branch (904:14): [True: 0, False: 14.7k]
  ------------------
  905|      0|      new_capacity = size > max_size ? size : max_size;
  ------------------
  |  Branch (905:22): [True: 0, False: 0]
  ------------------
  906|  25.6k|    T* old_data = this->data();
  907|  25.6k|    T* new_data =
  908|  25.6k|        std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
  909|       |    // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
  910|  25.6k|    detail::assume(this->size() <= new_capacity);
  911|       |    // The following code doesn't throw, so the raw pointer above doesn't leak.
  912|  25.6k|    std::uninitialized_copy_n(old_data, this->size(), new_data);
  913|  25.6k|    this->set(new_data, new_capacity);
  914|       |    // deallocate must not throw according to the standard, but even if it does,
  915|       |    // the buffer already uses the new storage and will deallocate it in
  916|       |    // destructor.
  917|  25.6k|    if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
  ------------------
  |  Branch (917:9): [True: 6.06k, False: 19.5k]
  ------------------
  918|  25.6k|  }
_ZN3fmt3v106detail16abort_fuzzing_ifEb:
  282|  25.6k|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  283|  25.6k|  ignore_unused(condition);
  284|       |#ifdef FMT_FUZZ
  285|       |  if (condition) throw std::runtime_error("fuzzing limit reached");
  286|       |#endif
  287|  25.6k|}
_ZN3fmt3v106detail6assumeEb:
  500|  25.6k|FMT_INLINE void assume(bool condition) {
  501|  25.6k|  (void)condition;
  502|  25.6k|#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
  503|  25.6k|  __builtin_assume(condition);
  504|       |#elif FMT_GCC_VERSION
  505|       |  if (!condition) __builtin_unreachable();
  506|       |#endif
  507|  25.6k|}
_ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_:
  836|   105M|void buffer<T>::append(const U* begin, const U* end) {
  837|   181M|  while (begin != end) {
  ------------------
  |  Branch (837:10): [True: 75.5M, False: 105M]
  ------------------
  838|  75.5M|    auto count = to_unsigned(end - begin);
  839|  75.5M|    try_reserve(size_ + count);
  840|  75.5M|    auto free_cap = capacity_ - size_;
  841|  75.5M|    if (free_cap < count) count = free_cap;
  ------------------
  |  Branch (841:9): [True: 0, False: 75.5M]
  ------------------
  842|  75.5M|    std::uninitialized_copy_n(begin, count, ptr_ + size_);
  843|  75.5M|    size_ += count;
  844|  75.5M|    begin += count;
  845|  75.5M|  }
  846|   105M|}
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEED2Ev:
  930|  60.4M|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEE10deallocateEv:
  891|  75.5M|  FMT_CONSTEXPR20 void deallocate() {
  892|  75.5M|    T* data = this->data();
  893|  75.5M|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (893:9): [True: 19.5k, False: 75.4M]
  ------------------
  894|  75.5M|  }
_ZN3fmt3v1010format_intC2Ei:
 3993|     34|  explicit format_int(int value) : str_(format_signed(value)) {}
_ZN3fmt3v1010format_int13format_signedIiEEPcT_:
 3983|     34|  template <typename Int> auto format_signed(Int value) -> char* {
 3984|     34|    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
 3985|     34|    bool negative = value < 0;
 3986|     34|    if (negative) abs_value = 0 - abs_value;
  ------------------
  |  Branch (3986:9): [True: 0, False: 34]
  ------------------
 3987|     34|    auto begin = format_unsigned(abs_value);
 3988|     34|    if (negative) *--begin = '-';
  ------------------
  |  Branch (3988:9): [True: 0, False: 34]
  ------------------
 3989|     34|    return begin;
 3990|     34|  }
_ZN3fmt3v1010format_int15format_unsignedIjEEPcT_:
 3978|     34|  template <typename UInt> auto format_unsigned(UInt value) -> char* {
 3979|     34|    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
 3980|     34|    return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
 3981|     34|  }
_ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i:
 1309|     34|    -> format_decimal_result<Char*> {
 1310|     34|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  354|     34|      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (354:8): [True: 34, False: 0]
  |  |  ------------------
  |  |  355|     34|           ? (void)0                                                          \
  |  |  356|     34|           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1311|     34|  out += size;
 1312|     34|  Char* end = out;
 1313|     68|  while (value >= 100) {
  ------------------
  |  Branch (1313:10): [True: 34, False: 34]
  ------------------
 1314|       |    // Integer division is slow so do it for a group of two digits instead
 1315|       |    // of for every digit. The idea comes from the talk by Alexandrescu
 1316|       |    // "Three Optimization Tips for C++". See speed-test for a comparison.
 1317|     34|    out -= 2;
 1318|     34|    copy2(out, digits2(static_cast<size_t>(value % 100)));
 1319|     34|    value /= 100;
 1320|     34|  }
 1321|     34|  if (value < 10) {
  ------------------
  |  Branch (1321:7): [True: 0, False: 34]
  ------------------
 1322|      0|    *--out = static_cast<Char>('0' + value);
 1323|      0|    return {out, end};
 1324|      0|  }
 1325|     34|  out -= 2;
 1326|     34|  copy2(out, digits2(static_cast<size_t>(value)));
 1327|     34|  return {out, end};
 1328|     34|}
_ZN3fmt3v106detail12count_digitsEj:
 1239|     34|FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
 1240|     34|#ifdef FMT_BUILTIN_CLZ
 1241|     34|  if (!is_constant_evaluated()) {
  ------------------
  |  Branch (1241:7): [Folded - Ignored]
  ------------------
 1242|     34|    return do_count_digits(n);
 1243|     34|  }
 1244|      0|#endif
 1245|      0|  return count_digits_fallback(n);
 1246|     34|}
_ZN3fmt3v106detail15do_count_digitsEj:
 1216|     34|FMT_INLINE auto do_count_digits(uint32_t n) -> int {
 1217|       |// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
 1218|       |// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
 1220|     34|  static constexpr uint64_t table[] = {
 1221|     34|      FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1222|     34|      FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1223|     34|      FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1224|     34|      FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1225|     34|      FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1226|     34|      FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1227|     34|      FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1228|     34|      FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1229|     34|      FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1230|     34|      FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1231|       |      FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
  ------------------
  |  | 1219|     34|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1232|     34|  };
 1233|     34|  auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];
  ------------------
  |  |  180|     34|#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
  ------------------
 1234|     34|  return static_cast<int>((n + inc) >> 32);
 1235|     34|}
_ZN3fmt3v106detail5copy2IcEEvPT_PKc:
 1290|     68|FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) {
 1291|     68|  if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {
  ------------------
  |  Branch (1291:7): [Folded - Ignored]
  |  Branch (1291:35): [Folded - Ignored]
  ------------------
 1292|     68|    memcpy(dst, src, 2);
 1293|     68|    return;
 1294|     68|  }
 1295|      0|  *dst++ = static_cast<Char>(*src++);
 1296|      0|  *dst = static_cast<Char>(*src);
 1297|      0|}
_ZN3fmt3v106detail7digits2Em:
 1127|     68|constexpr auto digits2(size_t value) -> const char* {
 1128|       |  // GCC generates slightly better code when value is pointer-size.
 1129|     68|  return &"0001020304050607080910111213141516171819"
 1130|     68|         "2021222324252627282930313233343536373839"
 1131|     68|         "4041424344454647484950515253545556575859"
 1132|     68|         "6061626364656667686970717273747576777879"
 1133|     68|         "8081828384858687888990919293949596979899"[value * 2];
 1134|     68|}
_ZNK3fmt3v1010format_int4dataEv:
 4010|     68|  auto data() const -> const char* { return str_; }
_ZNK3fmt3v1010format_int4sizeEv:
 4002|     34|  auto size() const -> size_t {
 4003|     34|    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
 4004|     34|  }
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEE6resizeEm:
  981|  15.1M|  FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); }
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEaSEOS5_:
  967|  15.1M|  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
  968|  15.1M|    FMT_ASSERT(this != &other, "");
  ------------------
  |  |  354|  15.1M|      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (354:8): [True: 15.1M, False: 0]
  |  |  ------------------
  |  |  355|  15.1M|           ? (void)0                                                          \
  |  |  356|  15.1M|           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  969|  15.1M|    deallocate();
  970|  15.1M|    move(other);
  971|  15.1M|    return *this;
  972|  15.1M|  }
_ZN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEE4moveERS5_:
  934|  15.1M|  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
  935|  15.1M|    alloc_ = std::move(other.alloc_);
  936|  15.1M|    T* data = other.data();
  937|  15.1M|    size_t size = other.size(), capacity = other.capacity();
  938|  15.1M|    if (data == other.store_) {
  ------------------
  |  Branch (938:9): [True: 15.0M, False: 8.77k]
  ------------------
  939|  15.0M|      this->set(store_, capacity);
  940|  15.0M|      detail::copy_str<T>(other.store_, other.store_ + size, store_);
  941|  15.0M|    } else {
  942|  8.77k|      this->set(data, capacity);
  943|       |      // Set pointer to the inline array so that delete is not called
  944|       |      // when deallocating.
  945|  8.77k|      other.set(other.store_, 0);
  946|  8.77k|      other.clear();
  947|  8.77k|    }
  948|  15.1M|    this->resize(size);
  949|  15.1M|  }

_ZN6spdlog9formatterD2Ev:
   13|      4|    virtual ~formatter() = default;

_ZNK6spdlog6logger4nameEv:
   68|  1.06k|SPDLOG_INLINE const std::string &logger::name() const { return name_; }
_ZN6spdlog6logger16enable_backtraceEm:
   90|  1.06k|SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); }
_ZN6spdlog6logger14dump_backtraceEv:
   95|    534|SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); }
_ZN6spdlog6logger15dump_backtrace_Ev:
  155|    534|SPDLOG_INLINE void logger::dump_backtrace_() {
  156|    534|    using details::log_msg;
  157|    534|    if (tracer_.enabled() && !tracer_.empty()) {
  ------------------
  |  Branch (157:9): [True: 534, False: 0]
  |  Branch (157:30): [True: 532, False: 2]
  ------------------
  158|    532|        sink_it_(
  159|    532|            log_msg{name(), level::info, "****************** Backtrace Start ******************"});
  160|    532|        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
  161|    532|        sink_it_(
  162|    532|            log_msg{name(), level::info, "****************** Backtrace End ********************"});
  163|    532|    }
  164|    534|}
_ZZN6spdlog6logger15dump_backtrace_EvENKUlRKNS_7details7log_msgEE_clES4_:
  160|  15.1M|        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
_ZN6spdlog6logger8sink_it_ERKNS_7details7log_msgE:
  135|  15.1M|SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {
  136|  15.1M|    for (auto &sink : sinks_) {
  ------------------
  |  Branch (136:21): [True: 15.1M, False: 15.1M]
  ------------------
  137|  15.1M|        if (sink->should_log(msg.level)) {
  ------------------
  |  Branch (137:13): [True: 15.1M, False: 0]
  ------------------
  138|  15.1M|            SPDLOG_TRY { sink->log(msg); }
  ------------------
  |  |  116|  15.1M|    #define SPDLOG_TRY try
  ------------------
  139|  15.1M|            SPDLOG_LOGGER_CATCH(msg.source)
  ------------------
  |  |   32|  15.1M|        catch (const std::exception &ex) {                                                \
  |  |   33|      0|            if (location.filename) {                                                      \
  |  |  ------------------
  |  |  |  Branch (33:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
  |  |  ------------------
  |  |  |  |   55|      0|    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1848|      0|#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, )
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1825|      0|  [] {                                                                        \
  |  |  |  |  |  |  |  | 1826|      0|    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */    \
  |  |  |  |  |  |  |  | 1827|      0|    /* Use a macro-like name to avoid shadowing warnings. */                  \
  |  |  |  |  |  |  |  | 1828|      0|    struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {               \
  |  |  |  |  |  |  |  | 1829|      0|      using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \
  |  |  |  |  |  |  |  | 1830|      0|      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                                 \
  |  |  |  |  |  |  |  | 1831|      0|      operator fmt::basic_string_view<char_type>() const {                    \
  |  |  |  |  |  |  |  | 1832|      0|        return fmt::detail_exported::compile_string_to_view<char_type>(s);    \
  |  |  |  |  |  |  |  | 1833|      0|      }                                                                       \
  |  |  |  |  |  |  |  | 1834|      0|    };                                                                        \
  |  |  |  |  |  |  |  | 1835|      0|    return FMT_COMPILE_STRING();                                              \
  |  |  |  |  |  |  |  | 1836|      0|  }()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|                                             location.filename, location.line));          \
  |  |   36|      0|            } else {                                                                      \
  |  |   37|      0|                err_handler_(ex.what());                                                  \
  |  |   38|      0|            }                                                                             \
  |  |   39|      0|        }                                                                                 \
  |  |   40|  15.1M|        catch (...) {                                                                     \
  |  |   41|      0|            err_handler_("Rethrowing unknown exception in logger");                       \
  |  |   42|      0|            throw;                                                                        \
  |  |   43|      0|        }
  ------------------
  140|  15.1M|        }
  141|  15.1M|    }
  142|       |
  143|  15.1M|    if (should_flush_(msg)) {
  ------------------
  |  Branch (143:9): [True: 0, False: 15.1M]
  ------------------
  144|      0|        flush_();
  145|      0|    }
  146|  15.1M|}
_ZN6spdlog6logger13should_flush_ERKNS_7details7log_msgE:
  166|  15.1M|SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) {
  167|  15.1M|    auto flush_level = flush_level_.load(std::memory_order_relaxed);
  168|  15.1M|    return (msg.level >= flush_level) && (msg.level != level::off);
  ------------------
  |  Branch (168:12): [True: 0, False: 15.1M]
  |  Branch (168:42): [True: 0, False: 0]
  ------------------
  169|  15.1M|}
_ZN6spdlog6logger13set_formatterENSt3__110unique_ptrINS_9formatterENS1_14default_deleteIS3_EEEE:
   72|      1|SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) {
   73|      1|    for (auto it = sinks_.begin(); it != sinks_.end(); ++it) {
  ------------------
  |  Branch (73:36): [True: 1, False: 0]
  ------------------
   74|      1|        if (std::next(it) == sinks_.end()) {
  ------------------
  |  Branch (74:13): [True: 1, False: 0]
  ------------------
   75|       |            // last element - we can be move it.
   76|      1|            (*it)->set_formatter(std::move(f));
   77|      1|            break;  // to prevent clang-tidy warning
   78|      1|        } else {
   79|      0|            (*it)->set_formatter(f->clone());
   80|      0|        }
   81|      1|    }
   82|      1|}
_ZN6spdlog6logger9set_levelENS_5level10level_enumE:
   62|      1|SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }
_ZN6spdlog6logger8flush_onENS_5level10level_enumE:
  100|      1|SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); }
_ZN6spdlog6logger7log_it_ERKNS_7details7log_msgEbb:
  126|  15.1M|                                   bool traceback_enabled) {
  127|  15.1M|    if (log_enabled) {
  ------------------
  |  Branch (127:9): [True: 0, False: 15.1M]
  ------------------
  128|      0|        sink_it_(log_msg);
  129|      0|    }
  130|  15.1M|    if (traceback_enabled) {
  ------------------
  |  Branch (130:9): [True: 15.1M, False: 0]
  ------------------
  131|  15.1M|        tracer_.push_back(log_msg);
  132|  15.1M|    }
  133|  15.1M|}

_ZN6spdlog6loggerC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_10shared_ptrINS_5sinks4sinkEEE:
   65|      2|        : logger(std::move(name), {std::move(single_sink)}) {}
_ZN6spdlog6loggerC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESt16initializer_listINS1_10shared_ptrINS_5sinks4sinkEEEE:
   69|      2|        : logger(std::move(name), sinks.begin(), sinks.end()) {}
_ZN6spdlog6loggerC2IPKNSt3__110shared_ptrINS_5sinks4sinkEEEEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEET_SF_:
   61|      2|          sinks_(begin, end) {}
_ZN6spdlog6loggerD2Ev:
   71|      2|    virtual ~logger() = default;
_ZN6spdlog6logger5debugINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRKT_:
  237|  15.1M|    void debug(const T &msg) {
  238|  15.1M|        log(level::debug, msg);
  239|  15.1M|    }
_ZN6spdlog6logger3logINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvNS_5level10level_enumERKT_:
   89|  15.1M|    void log(level::level_enum lvl, const T &msg) {
   90|  15.1M|        log(source_loc{}, lvl, msg);
   91|  15.1M|    }
_ZN6spdlog6logger3logENS_10source_locENS_5level10level_enumEN3fmt3v1017basic_string_viewIcEE:
  115|  15.1M|    void log(source_loc loc, level::level_enum lvl, string_view_t msg) {
  116|  15.1M|        bool log_enabled = should_log(lvl);
  117|  15.1M|        bool traceback_enabled = tracer_.enabled();
  118|  15.1M|        if (!log_enabled && !traceback_enabled) {
  ------------------
  |  Branch (118:13): [True: 15.1M, False: 0]
  |  Branch (118:29): [True: 0, False: 15.1M]
  ------------------
  119|      0|            return;
  120|      0|        }
  121|       |
  122|  15.1M|        details::log_msg log_msg(loc, name_, lvl, msg);
  123|  15.1M|        log_it_(log_msg, log_enabled, traceback_enabled);
  124|  15.1M|    }
_ZNK6spdlog6logger10should_logENS_5level10level_enumE:
  262|  15.1M|    bool should_log(level::level_enum msg_level) const {
  263|  15.1M|        return msg_level >= level_.load(std::memory_order_relaxed);
  264|  15.1M|    }

_ZN6spdlog3mdc11get_contextEv:
   40|  15.1M|    static mdc_map_t &get_context() {
   41|  15.1M|        static thread_local mdc_map_t context;
   42|  15.1M|        return context;
   43|  15.1M|    }

_ZNK6spdlog17pattern_formatter5cloneEv:
  949|      1|SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const {
  950|      1|    custom_flags cloned_custom_formatters;
  951|      1|    for (auto &it : custom_handlers_) {
  ------------------
  |  Branch (951:19): [True: 0, False: 1]
  ------------------
  952|      0|        cloned_custom_formatters[it.first] = it.second->clone();
  953|      0|    }
  954|      1|    auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_,
  955|      1|                                                          std::move(cloned_custom_formatters));
  956|      1|    cloned->need_localtime(need_localtime_);
  957|      1|#if defined(__GNUC__) && __GNUC__ < 5
  958|      1|    return std::move(cloned);
  959|       |#else
  960|       |    return cloned;
  961|       |#endif
  962|      1|}
_ZN6spdlog17pattern_formatter14need_localtimeEb:
  987|      1|SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; }
_ZN6spdlog17pattern_formatterC2ENS_17pattern_time_typeENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  944|      3|      last_log_secs_(0) {
  945|      3|    std::memset(&cached_tm_, 0, sizeof(cached_tm_));
  946|      3|    formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{}));
  947|      3|}
_ZN6spdlog7details14full_formatterC2ENS0_12padding_infoE:
  833|      4|        : flag_formatter(padinfo) {}
_ZN6spdlog7details13mdc_formatterINS0_18null_scoped_padderEEC2ENS0_12padding_infoE:
  793|      4|        : flag_formatter(padinfo) {}
_ZN6spdlog7details14full_formatter6formatERKNS0_7log_msgERK2tmRN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
  835|  15.1M|    void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {
  836|  15.1M|        using std::chrono::duration_cast;
  837|  15.1M|        using std::chrono::milliseconds;
  838|  15.1M|        using std::chrono::seconds;
  839|       |
  840|       |        // cache the date/time part for the next second.
  841|  15.1M|        auto duration = msg.time.time_since_epoch();
  842|  15.1M|        auto secs = duration_cast<seconds>(duration);
  843|       |
  844|  15.1M|        if (cache_timestamp_ != secs || cached_datetime_.size() == 0) {
  ------------------
  |  Branch (844:13): [True: 34, False: 15.1M]
  |  Branch (844:41): [True: 0, False: 15.1M]
  ------------------
  845|     34|            cached_datetime_.clear();
  846|     34|            cached_datetime_.push_back('[');
  847|     34|            fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
  848|     34|            cached_datetime_.push_back('-');
  849|       |
  850|     34|            fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
  851|     34|            cached_datetime_.push_back('-');
  852|       |
  853|     34|            fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
  854|     34|            cached_datetime_.push_back(' ');
  855|       |
  856|     34|            fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
  857|     34|            cached_datetime_.push_back(':');
  858|       |
  859|     34|            fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
  860|     34|            cached_datetime_.push_back(':');
  861|       |
  862|     34|            fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
  863|     34|            cached_datetime_.push_back('.');
  864|       |
  865|     34|            cache_timestamp_ = secs;
  866|     34|        }
  867|  15.1M|        dest.append(cached_datetime_.begin(), cached_datetime_.end());
  868|       |
  869|  15.1M|        auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
  870|  15.1M|        fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
  871|  15.1M|        dest.push_back(']');
  872|  15.1M|        dest.push_back(' ');
  873|       |
  874|       |        // append logger name if exists
  875|  15.1M|        if (msg.logger_name.size() > 0) {
  ------------------
  |  Branch (875:13): [True: 15.1M, False: 0]
  ------------------
  876|  15.1M|            dest.push_back('[');
  877|  15.1M|            fmt_helper::append_string_view(msg.logger_name, dest);
  878|  15.1M|            dest.push_back(']');
  879|  15.1M|            dest.push_back(' ');
  880|  15.1M|        }
  881|       |
  882|  15.1M|        dest.push_back('[');
  883|       |        // wrap the level name with color
  884|  15.1M|        msg.color_range_start = dest.size();
  885|       |        // fmt_helper::append_string_view(level::to_c_str(msg.level), dest);
  886|  15.1M|        fmt_helper::append_string_view(level::to_string_view(msg.level), dest);
  887|  15.1M|        msg.color_range_end = dest.size();
  888|  15.1M|        dest.push_back(']');
  889|  15.1M|        dest.push_back(' ');
  890|       |
  891|       |        // add source location if present
  892|  15.1M|        if (!msg.source.empty()) {
  ------------------
  |  Branch (892:13): [True: 0, False: 15.1M]
  ------------------
  893|      0|            dest.push_back('[');
  894|      0|            const char *filename =
  895|      0|                details::short_filename_formatter<details::null_scoped_padder>::basename(
  896|      0|                    msg.source.filename);
  897|      0|            fmt_helper::append_string_view(filename, dest);
  898|      0|            dest.push_back(':');
  899|      0|            fmt_helper::append_int(msg.source.line, dest);
  900|      0|            dest.push_back(']');
  901|      0|            dest.push_back(' ');
  902|      0|        }
  903|       |
  904|       |        // add mdc if present
  905|  15.1M|        auto &mdc_map = mdc::get_context();
  906|  15.1M|        if (!mdc_map.empty()) {
  ------------------
  |  Branch (906:13): [True: 0, False: 15.1M]
  ------------------
  907|      0|            dest.push_back('[');
  908|      0|            mdc_formatter_.format_mdc(mdc_map, dest);
  909|      0|            dest.push_back(']');
  910|      0|            dest.push_back(' ');
  911|      0|        }
  912|       |        // fmt_helper::append_string_view(msg.msg(), dest);
  913|  15.1M|        fmt_helper::append_string_view(msg.payload, dest);
  914|  15.1M|    }
_ZN6spdlog17pattern_formatterC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17pattern_time_typeES7_NS1_13unordered_mapIcNS1_10unique_ptrINS_21custom_flag_formatterENS1_14default_deleteISB_EEEENS1_4hashIcEENS1_8equal_toIcEENS5_INS1_4pairIKcSE_EEEEEE:
  933|      1|      custom_handlers_(std::move(custom_user_flags)) {
  934|      1|    std::memset(&cached_tm_, 0, sizeof(cached_tm_));
  935|      1|    compile_pattern_(pattern_);
  936|      1|}
_ZN6spdlog17pattern_formatter16compile_pattern_ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1289|      1|SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) {
 1290|      1|    auto end = pattern.end();
 1291|      1|    std::unique_ptr<details::aggregate_formatter> user_chars;
 1292|      1|    formatters_.clear();
 1293|      2|    for (auto it = pattern.begin(); it != end; ++it) {
  ------------------
  |  Branch (1293:37): [True: 1, False: 1]
  ------------------
 1294|      1|        if (*it == '%') {
  ------------------
  |  Branch (1294:13): [True: 1, False: 0]
  ------------------
 1295|      1|            if (user_chars)  // append user chars found so far
  ------------------
  |  Branch (1295:17): [True: 0, False: 1]
  ------------------
 1296|      0|            {
 1297|      0|                formatters_.push_back(std::move(user_chars));
 1298|      0|            }
 1299|       |
 1300|      1|            auto padding = handle_padspec_(++it, end);
 1301|       |
 1302|      1|            if (it != end) {
  ------------------
  |  Branch (1302:17): [True: 1, False: 0]
  ------------------
 1303|      1|                if (padding.enabled()) {
  ------------------
  |  Branch (1303:21): [True: 0, False: 1]
  ------------------
 1304|      0|                    handle_flag_<details::scoped_padder>(*it, padding);
 1305|      1|                } else {
 1306|      1|                    handle_flag_<details::null_scoped_padder>(*it, padding);
 1307|      1|                }
 1308|      1|            } else {
 1309|      0|                break;
 1310|      0|            }
 1311|      1|        } else  // chars not following the % sign should be displayed as is
 1312|      0|        {
 1313|      0|            if (!user_chars) {
  ------------------
  |  Branch (1313:17): [True: 0, False: 0]
  ------------------
 1314|      0|                user_chars = details::make_unique<details::aggregate_formatter>();
 1315|      0|            }
 1316|      0|            user_chars->add_ch(*it);
 1317|      0|        }
 1318|      1|    }
 1319|      1|    if (user_chars)  // append raw chars found so far
  ------------------
  |  Branch (1319:9): [True: 0, False: 1]
  ------------------
 1320|      0|    {
 1321|      0|        formatters_.push_back(std::move(user_chars));
 1322|      0|    }
 1323|      1|}
_ZN6spdlog17pattern_formatter15handle_padspec_ERNSt3__111__wrap_iterIPKcEES5_:
 1245|      1|    std::string::const_iterator &it, std::string::const_iterator end) {
 1246|      1|    using details::padding_info;
 1247|      1|    using details::scoped_padder;
 1248|      1|    const size_t max_width = 64;
 1249|      1|    if (it == end) {
  ------------------
  |  Branch (1249:9): [True: 0, False: 1]
  ------------------
 1250|      0|        return padding_info{};
 1251|      0|    }
 1252|       |
 1253|      1|    padding_info::pad_side side;
 1254|      1|    switch (*it) {
 1255|      0|        case '-':
  ------------------
  |  Branch (1255:9): [True: 0, False: 1]
  ------------------
 1256|      0|            side = padding_info::pad_side::right;
 1257|      0|            ++it;
 1258|      0|            break;
 1259|      0|        case '=':
  ------------------
  |  Branch (1259:9): [True: 0, False: 1]
  ------------------
 1260|      0|            side = padding_info::pad_side::center;
 1261|      0|            ++it;
 1262|      0|            break;
 1263|      1|        default:
  ------------------
  |  Branch (1263:9): [True: 1, False: 0]
  ------------------
 1264|      1|            side = details::padding_info::pad_side::left;
 1265|      1|            break;
 1266|      1|    }
 1267|       |
 1268|      1|    if (it == end || !std::isdigit(static_cast<unsigned char>(*it))) {
  ------------------
  |  Branch (1268:9): [True: 0, False: 1]
  |  Branch (1268:22): [True: 1, False: 0]
  ------------------
 1269|      1|        return padding_info{};  // no padding if no digit found here
 1270|      1|    }
 1271|       |
 1272|      0|    auto width = static_cast<size_t>(*it) - '0';
 1273|      0|    for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it) {
  ------------------
  |  Branch (1273:16): [True: 0, False: 0]
  |  Branch (1273:29): [True: 0, False: 0]
  ------------------
 1274|      0|        auto digit = static_cast<size_t>(*it) - '0';
 1275|      0|        width = width * 10 + digit;
 1276|      0|    }
 1277|       |
 1278|       |    // search for the optional truncate marker '!'
 1279|      0|    bool truncate;
 1280|      0|    if (it != end && *it == '!') {
  ------------------
  |  Branch (1280:9): [True: 0, False: 0]
  |  Branch (1280:22): [True: 0, False: 0]
  ------------------
 1281|      0|        truncate = true;
 1282|      0|        ++it;
 1283|      0|    } else {
 1284|      0|        truncate = false;
 1285|      0|    }
 1286|      0|    return details::padding_info{std::min<size_t>(width, max_width), side, truncate};
 1287|      1|}
_ZN6spdlog17pattern_formatter12handle_flag_INS_7details18null_scoped_padderEEEvcNS2_12padding_infoE:
  997|      1|SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) {
  998|       |    // process custom flags
  999|      1|    auto it = custom_handlers_.find(flag);
 1000|      1|    if (it != custom_handlers_.end()) {
  ------------------
  |  Branch (1000:9): [True: 0, False: 1]
  ------------------
 1001|      0|        auto custom_handler = it->second->clone();
 1002|      0|        custom_handler->set_padding_info(padding);
 1003|      0|        formatters_.push_back(std::move(custom_handler));
 1004|      0|        return;
 1005|      0|    }
 1006|       |
 1007|       |    // process built-in flags
 1008|      1|    switch (flag) {
 1009|      1|        case ('+'):  // default formatter
  ------------------
  |  Branch (1009:9): [True: 1, False: 0]
  ------------------
 1010|      1|            formatters_.push_back(details::make_unique<details::full_formatter>(padding));
 1011|      1|            need_localtime_ = true;
 1012|      1|            break;
 1013|       |
 1014|      0|        case 'n':  // logger name
  ------------------
  |  Branch (1014:9): [True: 0, False: 1]
  ------------------
 1015|      0|            formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding));
 1016|      0|            break;
 1017|       |
 1018|      0|        case 'l':  // level
  ------------------
  |  Branch (1018:9): [True: 0, False: 1]
  ------------------
 1019|      0|            formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding));
 1020|      0|            break;
 1021|       |
 1022|      0|        case 'L':  // short level
  ------------------
  |  Branch (1022:9): [True: 0, False: 1]
  ------------------
 1023|      0|            formatters_.push_back(
 1024|      0|                details::make_unique<details::short_level_formatter<Padder>>(padding));
 1025|      0|            break;
 1026|       |
 1027|      0|        case ('t'):  // thread id
  ------------------
  |  Branch (1027:9): [True: 0, False: 1]
  ------------------
 1028|      0|            formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding));
 1029|      0|            break;
 1030|       |
 1031|      0|        case ('v'):  // the message text
  ------------------
  |  Branch (1031:9): [True: 0, False: 1]
  ------------------
 1032|      0|            formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding));
 1033|      0|            break;
 1034|       |
 1035|      0|        case ('a'):  // weekday
  ------------------
  |  Branch (1035:9): [True: 0, False: 1]
  ------------------
 1036|      0|            formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding));
 1037|      0|            need_localtime_ = true;
 1038|      0|            break;
 1039|       |
 1040|      0|        case ('A'):  // short weekday
  ------------------
  |  Branch (1040:9): [True: 0, False: 1]
  ------------------
 1041|      0|            formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding));
 1042|      0|            need_localtime_ = true;
 1043|      0|            break;
 1044|       |
 1045|      0|        case ('b'):
  ------------------
  |  Branch (1045:9): [True: 0, False: 1]
  ------------------
 1046|      0|        case ('h'):  // month
  ------------------
  |  Branch (1046:9): [True: 0, False: 1]
  ------------------
 1047|      0|            formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding));
 1048|      0|            need_localtime_ = true;
 1049|      0|            break;
 1050|       |
 1051|      0|        case ('B'):  // short month
  ------------------
  |  Branch (1051:9): [True: 0, False: 1]
  ------------------
 1052|      0|            formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding));
 1053|      0|            need_localtime_ = true;
 1054|      0|            break;
 1055|       |
 1056|      0|        case ('c'):  // datetime
  ------------------
  |  Branch (1056:9): [True: 0, False: 1]
  ------------------
 1057|      0|            formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding));
 1058|      0|            need_localtime_ = true;
 1059|      0|            break;
 1060|       |
 1061|      0|        case ('C'):  // year 2 digits
  ------------------
  |  Branch (1061:9): [True: 0, False: 1]
  ------------------
 1062|      0|            formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding));
 1063|      0|            need_localtime_ = true;
 1064|      0|            break;
 1065|       |
 1066|      0|        case ('Y'):  // year 4 digits
  ------------------
  |  Branch (1066:9): [True: 0, False: 1]
  ------------------
 1067|      0|            formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding));
 1068|      0|            need_localtime_ = true;
 1069|      0|            break;
 1070|       |
 1071|      0|        case ('D'):
  ------------------
  |  Branch (1071:9): [True: 0, False: 1]
  ------------------
 1072|      0|        case ('x'):  // datetime MM/DD/YY
  ------------------
  |  Branch (1072:9): [True: 0, False: 1]
  ------------------
 1073|      0|            formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding));
 1074|      0|            need_localtime_ = true;
 1075|      0|            break;
 1076|       |
 1077|      0|        case ('m'):  // month 1-12
  ------------------
  |  Branch (1077:9): [True: 0, False: 1]
  ------------------
 1078|      0|            formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding));
 1079|      0|            need_localtime_ = true;
 1080|      0|            break;
 1081|       |
 1082|      0|        case ('d'):  // day of month 1-31
  ------------------
  |  Branch (1082:9): [True: 0, False: 1]
  ------------------
 1083|      0|            formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding));
 1084|      0|            need_localtime_ = true;
 1085|      0|            break;
 1086|       |
 1087|      0|        case ('H'):  // hours 24
  ------------------
  |  Branch (1087:9): [True: 0, False: 1]
  ------------------
 1088|      0|            formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding));
 1089|      0|            need_localtime_ = true;
 1090|      0|            break;
 1091|       |
 1092|      0|        case ('I'):  // hours 12
  ------------------
  |  Branch (1092:9): [True: 0, False: 1]
  ------------------
 1093|      0|            formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding));
 1094|      0|            need_localtime_ = true;
 1095|      0|            break;
 1096|       |
 1097|      0|        case ('M'):  // minutes
  ------------------
  |  Branch (1097:9): [True: 0, False: 1]
  ------------------
 1098|      0|            formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding));
 1099|      0|            need_localtime_ = true;
 1100|      0|            break;
 1101|       |
 1102|      0|        case ('S'):  // seconds
  ------------------
  |  Branch (1102:9): [True: 0, False: 1]
  ------------------
 1103|      0|            formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding));
 1104|      0|            need_localtime_ = true;
 1105|      0|            break;
 1106|       |
 1107|      0|        case ('e'):  // milliseconds
  ------------------
  |  Branch (1107:9): [True: 0, False: 1]
  ------------------
 1108|      0|            formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding));
 1109|      0|            break;
 1110|       |
 1111|      0|        case ('f'):  // microseconds
  ------------------
  |  Branch (1111:9): [True: 0, False: 1]
  ------------------
 1112|      0|            formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding));
 1113|      0|            break;
 1114|       |
 1115|      0|        case ('F'):  // nanoseconds
  ------------------
  |  Branch (1115:9): [True: 0, False: 1]
  ------------------
 1116|      0|            formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding));
 1117|      0|            break;
 1118|       |
 1119|      0|        case ('E'):  // seconds since epoch
  ------------------
  |  Branch (1119:9): [True: 0, False: 1]
  ------------------
 1120|      0|            formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding));
 1121|      0|            break;
 1122|       |
 1123|      0|        case ('p'):  // am/pm
  ------------------
  |  Branch (1123:9): [True: 0, False: 1]
  ------------------
 1124|      0|            formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding));
 1125|      0|            need_localtime_ = true;
 1126|      0|            break;
 1127|       |
 1128|      0|        case ('r'):  // 12 hour clock 02:55:02 pm
  ------------------
  |  Branch (1128:9): [True: 0, False: 1]
  ------------------
 1129|      0|            formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding));
 1130|      0|            need_localtime_ = true;
 1131|      0|            break;
 1132|       |
 1133|      0|        case ('R'):  // 24-hour HH:MM time
  ------------------
  |  Branch (1133:9): [True: 0, False: 1]
  ------------------
 1134|      0|            formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding));
 1135|      0|            need_localtime_ = true;
 1136|      0|            break;
 1137|       |
 1138|      0|        case ('T'):
  ------------------
  |  Branch (1138:9): [True: 0, False: 1]
  ------------------
 1139|      0|        case ('X'):  // ISO 8601 time format (HH:MM:SS)
  ------------------
  |  Branch (1139:9): [True: 0, False: 1]
  ------------------
 1140|      0|            formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding));
 1141|      0|            need_localtime_ = true;
 1142|      0|            break;
 1143|       |
 1144|      0|        case ('z'):  // timezone
  ------------------
  |  Branch (1144:9): [True: 0, False: 1]
  ------------------
 1145|      0|            formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
 1146|      0|            need_localtime_ = true;
 1147|      0|            break;
 1148|       |
 1149|      0|        case ('P'):  // pid
  ------------------
  |  Branch (1149:9): [True: 0, False: 1]
  ------------------
 1150|      0|            formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding));
 1151|      0|            break;
 1152|       |
 1153|      0|        case ('^'):  // color range start
  ------------------
  |  Branch (1153:9): [True: 0, False: 1]
  ------------------
 1154|      0|            formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
 1155|      0|            break;
 1156|       |
 1157|      0|        case ('$'):  // color range end
  ------------------
  |  Branch (1157:9): [True: 0, False: 1]
  ------------------
 1158|      0|            formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
 1159|      0|            break;
 1160|       |
 1161|      0|        case ('@'):  // source location (filename:filenumber)
  ------------------
  |  Branch (1161:9): [True: 0, False: 1]
  ------------------
 1162|      0|            formatters_.push_back(
 1163|      0|                details::make_unique<details::source_location_formatter<Padder>>(padding));
 1164|      0|            break;
 1165|       |
 1166|      0|        case ('s'):  // short source filename - without directory name
  ------------------
  |  Branch (1166:9): [True: 0, False: 1]
  ------------------
 1167|      0|            formatters_.push_back(
 1168|      0|                details::make_unique<details::short_filename_formatter<Padder>>(padding));
 1169|      0|            break;
 1170|       |
 1171|      0|        case ('g'):  // full source filename
  ------------------
  |  Branch (1171:9): [True: 0, False: 1]
  ------------------
 1172|      0|            formatters_.push_back(
 1173|      0|                details::make_unique<details::source_filename_formatter<Padder>>(padding));
 1174|      0|            break;
 1175|       |
 1176|      0|        case ('#'):  // source line number
  ------------------
  |  Branch (1176:9): [True: 0, False: 1]
  ------------------
 1177|      0|            formatters_.push_back(
 1178|      0|                details::make_unique<details::source_linenum_formatter<Padder>>(padding));
 1179|      0|            break;
 1180|       |
 1181|      0|        case ('!'):  // source funcname
  ------------------
  |  Branch (1181:9): [True: 0, False: 1]
  ------------------
 1182|      0|            formatters_.push_back(
 1183|      0|                details::make_unique<details::source_funcname_formatter<Padder>>(padding));
 1184|      0|            break;
 1185|       |
 1186|      0|        case ('%'):  // % char
  ------------------
  |  Branch (1186:9): [True: 0, False: 1]
  ------------------
 1187|      0|            formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
 1188|      0|            break;
 1189|       |
 1190|      0|        case ('u'):  // elapsed time since last log message in nanos
  ------------------
  |  Branch (1190:9): [True: 0, False: 1]
  ------------------
 1191|      0|            formatters_.push_back(
 1192|      0|                details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(
 1193|      0|                    padding));
 1194|      0|            break;
 1195|       |
 1196|      0|        case ('i'):  // elapsed time since last log message in micros
  ------------------
  |  Branch (1196:9): [True: 0, False: 1]
  ------------------
 1197|      0|            formatters_.push_back(
 1198|      0|                details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(
 1199|      0|                    padding));
 1200|      0|            break;
 1201|       |
 1202|      0|        case ('o'):  // elapsed time since last log message in millis
  ------------------
  |  Branch (1202:9): [True: 0, False: 1]
  ------------------
 1203|      0|            formatters_.push_back(
 1204|      0|                details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(
 1205|      0|                    padding));
 1206|      0|            break;
 1207|       |
 1208|      0|        case ('O'):  // elapsed time since last log message in seconds
  ------------------
  |  Branch (1208:9): [True: 0, False: 1]
  ------------------
 1209|      0|            formatters_.push_back(
 1210|      0|                details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(
 1211|      0|                    padding));
 1212|      0|            break;
 1213|       |
 1214|      0|        case ('&'):
  ------------------
  |  Branch (1214:9): [True: 0, False: 1]
  ------------------
 1215|      0|            formatters_.push_back(details::make_unique<details::mdc_formatter<Padder>>(padding));
 1216|      0|            break;
 1217|       |
 1218|      0|        default:  // Unknown flag appears as is
  ------------------
  |  Branch (1218:9): [True: 0, False: 1]
  ------------------
 1219|      0|            auto unknown_flag = details::make_unique<details::aggregate_formatter>();
 1220|       |
 1221|      0|            if (!padding.truncate_) {
  ------------------
  |  Branch (1221:17): [True: 0, False: 0]
  ------------------
 1222|      0|                unknown_flag->add_ch('%');
 1223|      0|                unknown_flag->add_ch(flag);
 1224|      0|                formatters_.push_back((std::move(unknown_flag)));
 1225|      0|            }
 1226|       |            // fix issue #1617 (prev char was '!' and should have been treated as funcname flag
 1227|       |            // instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[      main] some
 1228|       |            // message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message"
 1229|      0|            else {
 1230|      0|                padding.truncate_ = false;
 1231|      0|                formatters_.push_back(
 1232|      0|                    details::make_unique<details::source_funcname_formatter<Padder>>(padding));
 1233|      0|                unknown_flag->add_ch(flag);
 1234|      0|                formatters_.push_back((std::move(unknown_flag)));
 1235|      0|            }
 1236|       |
 1237|      0|            break;
 1238|      1|    }
 1239|      1|}
_ZN6spdlog17pattern_formatter6formatERKNS_7details7log_msgERN3fmt3v1019basic_memory_bufferIcLm250ENSt3__19allocatorIcEEEE:
  964|  15.1M|SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) {
  965|  15.1M|    if (need_localtime_) {
  ------------------
  |  Branch (965:9): [True: 15.1M, False: 0]
  ------------------
  966|  15.1M|        const auto secs =
  967|  15.1M|            std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
  968|  15.1M|        if (secs != last_log_secs_) {
  ------------------
  |  Branch (968:13): [True: 34, False: 15.1M]
  ------------------
  969|     34|            cached_tm_ = get_time_(msg);
  970|     34|            last_log_secs_ = secs;
  971|     34|        }
  972|  15.1M|    }
  973|       |
  974|  15.1M|    for (auto &f : formatters_) {
  ------------------
  |  Branch (974:18): [True: 15.1M, False: 15.1M]
  ------------------
  975|  15.1M|        f->format(msg, cached_tm_, dest);
  976|  15.1M|    }
  977|       |    // write eol
  978|  15.1M|    details::fmt_helper::append_string_view(eol_, dest);
  979|  15.1M|}
_ZN6spdlog17pattern_formatter9get_time_ERKNS_7details7log_msgE:
  989|     34|SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) {
  990|     34|    if (pattern_time_type_ == pattern_time_type::local) {
  ------------------
  |  Branch (990:9): [True: 34, False: 0]
  ------------------
  991|     34|        return details::os::localtime(log_clock::to_time_t(msg.time));
  992|     34|    }
  993|      0|    return details::os::gmtime(log_clock::to_time_t(msg.time));
  994|     34|}

_ZN6spdlog7details14flag_formatterC2ENS0_12padding_infoE:
   43|      8|        : padinfo_(padinfo) {}
_ZN6spdlog7details14flag_formatterD2Ev:
   45|      8|    virtual ~flag_formatter() = default;
_ZN6spdlog7details12padding_infoC2Ev:
   26|      8|    padding_info() = default;
_ZNK6spdlog7details12padding_info7enabledEv:
   33|      1|    bool enabled() const { return enabled_; }

_ZN6spdlog5sinks21ansicolor_stdout_sinkINS_7details13console_mutexEEC2ENS_10color_modeE:
  127|      1|    : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEEC2EP8_IO_FILENS_10color_modeE:
   22|      1|{
   23|      1|    set_color_mode(mode);
   24|      1|    colors_.at(level::trace) = to_string_(white);
   25|      1|    colors_.at(level::debug) = to_string_(cyan);
   26|      1|    colors_.at(level::info) = to_string_(green);
   27|      1|    colors_.at(level::warn) = to_string_(yellow_bold);
   28|      1|    colors_.at(level::err) = to_string_(red_bold);
   29|      1|    colors_.at(level::critical) = to_string_(bold_on_red);
   30|      1|    colors_.at(level::off) = to_string_(reset);
   31|      1|}
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEE14set_color_modeENS_10color_modeE:
   90|      1|SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
   91|      1|    switch (mode) {
   92|      0|        case color_mode::always:
  ------------------
  |  Branch (92:9): [True: 0, False: 1]
  ------------------
   93|      0|            should_do_colors_ = true;
   94|      0|            return;
   95|      1|        case color_mode::automatic:
  ------------------
  |  Branch (95:9): [True: 1, False: 0]
  ------------------
   96|      1|            should_do_colors_ =
   97|      1|                details::os::in_terminal(target_file_) && details::os::is_color_terminal();
  ------------------
  |  Branch (97:17): [True: 0, False: 1]
  |  Branch (97:59): [True: 0, False: 0]
  ------------------
   98|      1|            return;
   99|      0|        case color_mode::never:
  ------------------
  |  Branch (99:9): [True: 0, False: 1]
  ------------------
  100|      0|            should_do_colors_ = false;
  101|      0|            return;
  102|      0|        default:
  ------------------
  |  Branch (102:9): [True: 0, False: 1]
  ------------------
  103|      0|            should_do_colors_ = false;
  104|      1|    }
  105|      1|}
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEE10to_string_ERKN3fmt3v1017basic_string_viewIcEE:
  120|      7|SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
  121|      7|    return std::string(sv.data(), sv.size());
  122|      7|}

_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEED2Ev:
   29|      1|    ~ansicolor_sink() override = default;

_ZN6spdlog5sinks9base_sinkINSt3__15mutexEEC2Ev:
   18|      1|    : formatter_{details::make_unique<spdlog::pattern_formatter>()} {}
_ZN6spdlog5sinks9base_sinkINSt3__15mutexEE3logERKNS_7details7log_msgE:
   26|  15.1M|void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) {
   27|  15.1M|    std::lock_guard<Mutex> lock(mutex_);
   28|  15.1M|    sink_it_(msg);
   29|  15.1M|}
_ZN6spdlog5sinks9base_sinkINSt3__15mutexEE13set_formatterENS2_10unique_ptrINS_9formatterENS2_14default_deleteIS6_EEEE:
   45|      1|spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
   46|      1|    std::lock_guard<Mutex> lock(mutex_);
   47|      1|    set_formatter_(std::move(sink_formatter));
   48|      1|}
_ZN6spdlog5sinks9base_sinkINSt3__15mutexEE14set_formatter_ENS2_10unique_ptrINS_9formatterENS2_14default_deleteIS6_EEEE:
   57|      1|spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) {
   58|      1|    formatter_ = std::move(sink_formatter);
   59|      1|}

_ZN6spdlog5sinks9base_sinkINSt3__15mutexEED2Ev:
   23|      1|    ~base_sink() override = default;

_ZN6spdlog5sinks15basic_file_sinkINSt3__15mutexEEC2ERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbRKNS_19file_event_handlersE:
   20|      1|    : file_helper_{event_handlers} {
   21|      1|    file_helper_.open(filename, truncate);
   22|      1|}
_ZN6spdlog5sinks15basic_file_sinkINSt3__15mutexEE8sink_it_ERKNS_7details7log_msgE:
   30|  15.1M|SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
   31|  15.1M|    memory_buf_t formatted;
   32|  15.1M|    base_sink<Mutex>::formatter_->format(msg, formatted);
   33|  15.1M|    file_helper_.write(formatted);
   34|  15.1M|}

_ZN6spdlog15basic_logger_mtINS_19synchronous_factoryEEENSt3__110shared_ptrINS_6loggerEEERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESD_bRKNS_19file_event_handlersE:
   47|      1|                                               const file_event_handlers &event_handlers = {}) {
   48|      1|    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate,
   49|      1|                                                               event_handlers);
   50|      1|}

_ZNK6spdlog5sinks4sink10should_logENS_5level10level_enumE:
   12|  15.1M|SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const {
   13|  15.1M|    return msg_level >= level_.load(std::memory_order_relaxed);
   14|  15.1M|}

_ZN6spdlog5sinks4sinkD2Ev:
   14|      2|    virtual ~sink() = default;

_ZN6spdlog18set_default_loggerENSt3__110shared_ptrINS_6loggerEEE:
   84|      1|SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) {
   85|      1|    details::registry::instance().set_default_logger(std::move(default_logger));
   86|      1|}
_ZN6spdlog16enable_backtraceEm:
   32|    534|SPDLOG_INLINE void enable_backtrace(size_t n_messages) {
   33|    534|    details::registry::instance().enable_backtrace(n_messages);
   34|    534|}
_ZN6spdlog14dump_backtraceEv:
   38|    534|SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); }
_ZN6spdlog18default_logger_rawEv:
   80|  15.1M|SPDLOG_INLINE spdlog::logger *default_logger_raw() {
   81|  15.1M|    return details::registry::instance().get_default_raw();
   82|  15.1M|}

_ZN6spdlog5debugINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRKT_:
  247|  15.1M|inline void debug(const T &msg) {
  248|  15.1M|    default_logger_raw()->debug(msg);
  249|  15.1M|}