LLVMFuzzerTestOneInput:
   24|  2.72k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   25|  2.72k|  if (size == 0) {
  ------------------
  |  Branch (25:7): [True: 0, False: 2.72k]
  ------------------
   26|      0|    return 0;
   27|      0|  }
   28|       |
   29|  2.72k|  static std::shared_ptr<spdlog::logger> my_logger;
   30|  2.72k|  if (!my_logger.get()) {
  ------------------
  |  Branch (30:7): [True: 1, False: 2.72k]
  ------------------
   31|      1|    my_logger = spdlog::basic_logger_mt("basic_logger", "/dev/null");
   32|      1|    spdlog::set_default_logger(my_logger);
   33|      1|  }
   34|       |
   35|  2.72k|  FuzzedDataProvider stream(data, size);
   36|       |  
   37|  2.72k|  std::vector<std::string> strings;
   38|  2.72k|  const unsigned char strsize = stream.ConsumeIntegral<unsigned char>();
   39|   246k|  for(unsigned char i=0; i<strsize; i++){
  ------------------
  |  Branch (39:26): [True: 243k, False: 2.72k]
  ------------------
   40|   243k|    strings.push_back(stream.ConsumeRandomLengthString());
   41|   243k|  }
   42|  2.72k|  std::vector<char*> argvv; argvv.reserve(strsize);
   43|   246k|  for(unsigned char i=0; i< strsize; ++i){
  ------------------
  |  Branch (43:26): [True: 243k, False: 2.72k]
  ------------------
   44|   243k|    argvv.push_back(const_cast<char*>(strings[i].c_str()));
   45|   243k|  }
   46|       |  
   47|  2.72k|  if(strsize==0) return 0;
  ------------------
  |  Branch (47:6): [True: 8, False: 2.71k]
  ------------------
   48|       |  
   49|  2.71k|  const char** argv = (const char**) &argvv[0];
   50|  2.71k|  spdlog::cfg::load_env_levels();
   51|  2.71k|  spdlog::cfg::load_argv_levels(strsize, argv);
   52|  2.71k|  spdlog::info(stream.ConsumeRemainingBytesAsString());
   53|       |  
   54|  2.71k|  return 0;
   55|  2.72k|}

_ZN6spdlog3cfg16load_argv_levelsEiPPKc:
   24|  2.71k|inline void load_argv_levels(int argc, const char **argv) {
   25|  2.71k|    const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
   26|   243k|    for (int i = 1; i < argc; i++) {
  ------------------
  |  Branch (26:21): [True: 240k, False: 2.71k]
  ------------------
   27|   240k|        std::string arg = argv[i];
   28|   240k|        if (arg.find(spdlog_level_prefix) == 0) {
  ------------------
  |  Branch (28:13): [True: 8.32k, False: 232k]
  ------------------
   29|  8.32k|            const auto levels_spec = arg.substr(spdlog_level_prefix.size());
   30|  8.32k|            helpers::load_levels(levels_spec);
   31|  8.32k|        }
   32|   240k|    }
   33|  2.71k|}

_ZN6spdlog3cfg15load_env_levelsEPKc:
   28|  2.71k|inline void load_env_levels(const char* var = "SPDLOG_LEVEL") {
   29|  2.71k|    const auto levels_spec = details::os::getenv(var);
   30|  2.71k|    if (!levels_spec.empty()) {
  ------------------
  |  Branch (30:9): [True: 0, False: 2.71k]
  ------------------
   31|      0|        helpers::load_levels(levels_spec);
   32|      0|    }
   33|  2.71k|}

_ZN6spdlog3cfg7helpers11load_levelsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   73|  8.32k|SPDLOG_INLINE void load_levels(const std::string &levels_spec) {
   74|  8.32k|    if (levels_spec.empty() || levels_spec.size() >= 32768) {
  ------------------
  |  Branch (74:9): [True: 82, False: 8.24k]
  |  Branch (74:32): [True: 118, False: 8.12k]
  ------------------
   75|    200|        return;
   76|    200|    }
   77|       |
   78|  8.12k|    auto key_vals = extract_key_vals_(levels_spec);
   79|  8.12k|    std::unordered_map<std::string, level::level_enum> levels;
   80|  8.12k|    level::level_enum global_level = level::info;
   81|  8.12k|    bool global_level_found = false;
   82|       |
   83|  70.0k|    for (auto &name_level : key_vals) {
  ------------------
  |  Branch (83:27): [True: 70.0k, False: 8.12k]
  ------------------
   84|  70.0k|        const auto &logger_name = name_level.first;
   85|  70.0k|        const auto &level_name = to_lower_(name_level.second);
   86|  70.0k|        const auto level = level::from_str(level_name);
   87|       |        // ignore unrecognized level names
   88|  70.0k|        if (level == level::off && level_name != "off") {
  ------------------
  |  Branch (88:13): [True: 47.0k, False: 22.9k]
  |  Branch (88:36): [True: 27.7k, False: 19.3k]
  ------------------
   89|  27.7k|            continue;
   90|  27.7k|        }
   91|  42.3k|        if (logger_name.empty())  // no logger name indicates global level
  ------------------
  |  Branch (91:13): [True: 612, False: 41.7k]
  ------------------
   92|    612|        {
   93|    612|            global_level_found = true;
   94|    612|            global_level = level;
   95|  41.7k|        } else {
   96|  41.7k|            levels[logger_name] = level;
   97|  41.7k|        }
   98|  42.3k|    }
   99|       |
  100|  8.12k|    details::registry::instance().set_levels(std::move(levels),
  101|  8.12k|                                             global_level_found ? &global_level : nullptr);
  ------------------
  |  Branch (101:46): [True: 612, False: 7.51k]
  ------------------
  102|  8.12k|}
_ZN6spdlog3cfg7helpers17extract_key_vals_ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   59|  8.12k|inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {
   60|  8.12k|    std::string token;
   61|  8.12k|    std::istringstream token_stream(str);
   62|  8.12k|    std::unordered_map<std::string, std::string> rv{};
   63|   113k|    while (std::getline(token_stream, token, ',')) {
  ------------------
  |  Branch (63:12): [True: 105k, False: 8.12k]
  ------------------
   64|   105k|        if (token.empty()) {
  ------------------
  |  Branch (64:13): [True: 6.61k, False: 98.6k]
  ------------------
   65|  6.61k|            continue;
   66|  6.61k|        }
   67|  98.6k|        auto kv = extract_kv_('=', token);
   68|  98.6k|        rv[kv.first] = kv.second;
   69|  98.6k|    }
   70|  8.12k|    return rv;
   71|  8.12k|}
_ZN6spdlog3cfg7helpers11extract_kv_EcRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   45|  98.6k|inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {
   46|  98.6k|    auto n = str.find(sep);
   47|  98.6k|    std::string k, v;
   48|  98.6k|    if (n == std::string::npos) {
  ------------------
  |  Branch (48:9): [True: 16.5k, False: 82.1k]
  ------------------
   49|  16.5k|        v = str;
   50|  82.1k|    } else {
   51|  82.1k|        k = str.substr(0, n);
   52|  82.1k|        v = str.substr(n + 1);
   53|  82.1k|    }
   54|  98.6k|    return std::make_pair(trim_(k), trim_(v));
   55|  98.6k|}
_ZN6spdlog3cfg7helpers5trim_ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   31|   197k|inline std::string &trim_(std::string &str) {
   32|   197k|    const char *spaces = " \n\r\t";
   33|   197k|    str.erase(str.find_last_not_of(spaces) + 1);
   34|   197k|    str.erase(0, str.find_first_not_of(spaces));
   35|   197k|    return str;
   36|   197k|}
_ZN6spdlog3cfg7helpers9to_lower_ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   23|  70.0k|inline std::string &to_lower_(std::string &str) {
   24|  70.0k|    std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
   25|  70.0k|        return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);
   26|  70.0k|    });
   27|  70.0k|    return str;
   28|  70.0k|}
_ZZN6spdlog3cfg7helpers9to_lower_ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENKUlcE_clEc:
   24|  2.32M|    std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
   25|  2.32M|        return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);
  ------------------
  |  Branch (25:35): [True: 1.57M, False: 753k]
  |  Branch (25:48): [True: 24.3k, False: 1.54M]
  ------------------
   26|  2.32M|    });

_ZN6spdlog5level14to_string_viewENS0_10level_enumE:
   24|  1.13k|SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
   25|  1.13k|    return level_string_views[l];
   26|  1.13k|}
_ZN6spdlog5level8from_strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   32|  70.0k|SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT {
   33|  70.0k|    auto it = std::find_if(std::begin(level_string_views), std::end(level_string_views),
   34|  70.0k|                           [&name](const string_view_t &level_name) {
   35|  70.0k|                               return level_name.size() == name.size() &&
   36|  70.0k|                                      std::equal(name.begin(), name.end(), level_name.begin(),
   37|  70.0k|                                                 [](char a, char b) {
   38|  70.0k|                                                     return std::tolower(static_cast<unsigned char>(a)) ==
   39|  70.0k|                                                            std::tolower(static_cast<unsigned char>(b));
   40|  70.0k|                                                 });
   41|  70.0k|                           });
   42|  70.0k|    if (it != std::end(level_string_views))
  ------------------
  |  Branch (42:9): [True: 21.9k, False: 48.1k]
  ------------------
   43|  21.9k|        return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));
   44|       |
   45|       |    // check also for "warn" and "err" before giving up..
   46|  48.1k|    auto iequals = [](const std::string &a, const std::string &b) {
   47|  48.1k|        return a.size() == b.size() &&
   48|  48.1k|               std::equal(a.begin(), a.end(), b.begin(), [](char ac, char bc) {
   49|  48.1k|                   return std::tolower(static_cast<unsigned char>(ac)) ==
   50|  48.1k|                          std::tolower(static_cast<unsigned char>(bc));
   51|  48.1k|               });
   52|  48.1k|    };
   53|       |
   54|  48.1k|    if (iequals(name, "warn")) {
  ------------------
  |  Branch (54:9): [True: 574, False: 47.5k]
  ------------------
   55|    574|        return level::warn;
   56|    574|    }
   57|  47.5k|    if (iequals(name, "err")) {
  ------------------
  |  Branch (57:9): [True: 19.8k, False: 27.7k]
  ------------------
   58|  19.8k|        return level::err;
   59|  19.8k|    }
   60|  27.7k|    return level::off;
   61|  47.5k|}
_ZZN6spdlog5level8from_strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENKUlRKN3fmt3v1217basic_string_viewIcEEE_clESF_:
   34|   479k|                           [&name](const string_view_t &level_name) {
   35|   479k|                               return level_name.size() == name.size() &&
  ------------------
  |  Branch (35:39): [True: 50.8k, False: 428k]
  ------------------
   36|  50.8k|                                      std::equal(name.begin(), name.end(), level_name.begin(),
  ------------------
  |  Branch (36:39): [True: 21.9k, False: 28.9k]
  ------------------
   37|  50.8k|                                                 [](char a, char b) {
   38|  50.8k|                                                     return std::tolower(static_cast<unsigned char>(a)) ==
   39|  50.8k|                                                            std::tolower(static_cast<unsigned char>(b));
   40|  50.8k|                                                 });
   41|   479k|                           });
_ZZZN6spdlog5level8from_strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENKUlRKN3fmt3v1217basic_string_viewIcEEE_clESF_ENKUlccE_clEcc:
   37|  99.2k|                                                 [](char a, char b) {
   38|  99.2k|                                                     return std::tolower(static_cast<unsigned char>(a)) ==
   39|  99.2k|                                                            std::tolower(static_cast<unsigned char>(b));
   40|  99.2k|                                                 });
_ZZN6spdlog5level8from_strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENKUlS9_S9_E_clES9_S9_:
   46|  95.6k|    auto iequals = [](const std::string &a, const std::string &b) {
   47|  95.6k|        return a.size() == b.size() &&
  ------------------
  |  Branch (47:16): [True: 24.8k, False: 70.8k]
  ------------------
   48|  24.8k|               std::equal(a.begin(), a.end(), b.begin(), [](char ac, char bc) {
  ------------------
  |  Branch (48:16): [True: 20.3k, False: 4.45k]
  ------------------
   49|  24.8k|                   return std::tolower(static_cast<unsigned char>(ac)) ==
   50|  24.8k|                          std::tolower(static_cast<unsigned char>(bc));
   51|  24.8k|               });
   52|  95.6k|    };
_ZZZN6spdlog5level8from_strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENKUlS9_S9_E_clES9_S9_ENKUlccE_clEcc:
   48|  67.0k|               std::equal(a.begin(), a.end(), b.begin(), [](char ac, char bc) {
   49|  67.0k|                   return std::tolower(static_cast<unsigned char>(ac)) ==
   50|  67.0k|                          std::tolower(static_cast<unsigned char>(bc));
   51|  67.0k|               });

_ZN6spdlog19file_event_handlersC2Ev:
  330|      1|        : before_open(nullptr),
  331|      1|          after_open(nullptr),
  332|      1|          before_close(nullptr),
  333|      1|          after_close(nullptr) {}
_ZNK6spdlog10source_loc5emptyEv:
  322|  1.13k|    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
_ZN6spdlog10source_locC2Ev:
  316|  2.71k|    SPDLOG_CONSTEXPR source_loc() = default;

_ZNK6spdlog7details10backtracer7enabledEv:
   41|  2.71k|SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }

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

_ZN6spdlog7details10circular_qINS0_14log_msg_bufferEEC2Ev:
   26|      2|    circular_q() = default;

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

_ZN6spdlog7details10fmt_helper18append_string_viewEN3fmt3v1217basic_string_viewIcEERNS3_19basic_memory_bufferIcLm250ENS3_6detail9allocatorIcEEEE:
   21|  4.54k|inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
   22|  4.54k|    auto *buf_ptr = view.data();
   23|  4.54k|    dest.append(buf_ptr, buf_ptr + view.size());
   24|  4.54k|}
_ZN6spdlog7details10fmt_helper10append_intIiEEvT_RN3fmt3v1219basic_memory_bufferIcLm250ENS5_6detail9allocatorIcEEEE:
   42|      3|inline void append_int(T n, memory_buf_t &dest) {
   43|      3|    fmt::format_int i(n);
   44|      3|    dest.append(i.data(), i.data() + i.size());
   45|      3|}
_ZN6spdlog7details10fmt_helper4pad2EiRN3fmt3v1219basic_memory_bufferIcLm250ENS3_6detail9allocatorIcEEEE:
   84|     15|inline void pad2(int n, memory_buf_t &dest) {
   85|     15|    if (n >= 0 && n < 100)  // 0-99
  ------------------
  |  Branch (85:9): [True: 15, False: 0]
  |  Branch (85:19): [True: 15, False: 0]
  ------------------
   86|     15|    {
   87|     15|        dest.push_back(static_cast<char>('0' + n / 10));
   88|     15|        dest.push_back(static_cast<char>('0' + n % 10));
   89|     15|    } 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)
  |  |  ------------------
  |  |  |  | 4251|      0|#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4226|      0|    [] {                                                                     \
  |  |  |  |  |  | 4227|      0|      /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
  |  |  |  |  |  | 4228|      0|      /* Use a macro-like name to avoid shadowing warnings. */               \
  |  |  |  |  |  | 4229|      0|      struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {            \
  |  |  |  |  |  | 4230|      0|        using char_type = fmt::remove_cvref_t<decltype(s[0])>;               \
  |  |  |  |  |  | 4231|      0|        constexpr explicit operator fmt::basic_string_view<char_type>()      \
  |  |  |  |  |  | 4232|      0|            const {                                                          \
  |  |  |  |  |  | 4233|      0|          return fmt::detail::compile_string_to_view<char_type>(s);          \
  |  |  |  |  |  | 4234|      0|        }                                                                    \
  |  |  |  |  |  | 4235|      0|      };                                                                     \
  |  |  |  |  |  | 4236|      0|      using FMT_STRING_VIEW =                                                \
  |  |  |  |  |  | 4237|      0|          fmt::basic_string_view<typename FMT_COMPILE_STRING::char_type>;    \
  |  |  |  |  |  | 4238|      0|      fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING()));     \
  |  |  |  |  |  | 4239|      0|      return FMT_COMPILE_STRING();                                           \
  |  |  |  |  |  | 4240|      0|    }()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   92|      0|    }
   93|     15|}
_ZN6spdlog7details10fmt_helper13time_fractionINSt3__16chrono8durationIxNS3_5ratioILl1ELl1000EEEEEEET_NS4_10time_pointINS4_12system_clockENS5_IxNS6_ILl1ELl1000000EEEEEEE:
  131|  1.13k|inline ToDuration time_fraction(log_clock::time_point tp) {
  132|  1.13k|    using std::chrono::duration_cast;
  133|  1.13k|    using std::chrono::seconds;
  134|  1.13k|    auto duration = tp.time_since_epoch();
  135|  1.13k|    auto secs = duration_cast<seconds>(duration);
  136|  1.13k|    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
  137|  1.13k|}
_ZN6spdlog7details10fmt_helper4pad3IjEEvT_RN3fmt3v1219basic_memory_bufferIcLm250ENS5_6detail9allocatorIcEEEE:
  105|  1.13k|inline void pad3(T n, memory_buf_t &dest) {
  106|  1.13k|    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
  107|  1.13k|    if (n < 1000) {
  ------------------
  |  Branch (107:9): [True: 1.13k, False: 0]
  ------------------
  108|  1.13k|        dest.push_back(static_cast<char>(n / 100 + '0'));
  109|  1.13k|        n = n % 100;
  110|  1.13k|        dest.push_back(static_cast<char>((n / 10) + '0'));
  111|  1.13k|        dest.push_back(static_cast<char>((n % 10) + '0'));
  112|  1.13k|    } else {
  113|      0|        append_int(n, dest);
  114|      0|    }
  115|  1.13k|}

_ZN6spdlog7details7log_msgC2ENS_10source_locEN3fmt3v1217basic_string_viewIcEENS_5level10level_enumES6_:
   36|  1.13k|    : log_msg(os::now(), loc, a_logger_name, lvl, msg) {}
_ZN6spdlog7details7log_msgC2ENSt3__16chrono10time_pointINS3_12system_clockENS3_8durationIxNS2_5ratioILl1ELl1000000EEEEEEENS_10source_locEN3fmt3v1217basic_string_viewIcEENS_5level10level_enumESF_:
   20|  1.13k|    : logger_name(a_logger_name),
   21|  1.13k|      level(lvl),
   22|  1.13k|      time(log_time)
   23|       |#ifndef SPDLOG_NO_THREAD_ID
   24|       |      ,
   25|  1.13k|      thread_id(os::thread_id())
   26|       |#endif
   27|       |      ,
   28|  1.13k|      source(loc),
   29|  1.13k|      payload(msg) {
   30|  1.13k|}

_ZN6spdlog7details2os11in_terminalEP8_IO_FILE:
  396|      1|SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
  397|       |#ifdef _WIN32
  398|       |    return ::_isatty(_fileno(file)) != 0;
  399|       |#else
  400|      1|    return ::isatty(fileno(file)) != 0;
  401|      1|#endif
  402|      1|}
_ZN6spdlog7details2os12fwrite_bytesEPKvmP8_IO_FILE:
  558|  1.13k|SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
  559|       |#if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
  560|       |    return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
  561|       |#elif defined(SPDLOG_FWRITE_UNLOCKED)
  562|       |    return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
  563|       |#else
  564|  1.13k|    return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;
  565|  1.13k|#endif
  566|  1.13k|}
_ZN6spdlog7details2os6getenvEPKc:
  533|  2.71k|std::string SPDLOG_INLINE getenv(const char *field) {
  534|       |#if defined(_MSC_VER) && defined(WINAPI_FAMILY) && defined(WINAPI_FAMILY_DESKTOP_APP) && \
  535|       |    (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
  536|       |    return std::string{};  // not supported under uwp
  537|       |#else
  538|  2.71k|    char *buf = std::getenv(field);
  539|  2.71k|    return buf ? buf : std::string{};
  ------------------
  |  Branch (539:12): [True: 0, False: 2.71k]
  ------------------
  540|  2.71k|#endif
  541|  2.71k|}
_ZN6spdlog7details2os9localtimeERKl:
   87|      3|SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
   88|       |#ifdef _WIN32
   89|       |    std::tm tm;
   90|       |    ::localtime_s(&tm, &time_tt);
   91|       |#else
   92|      3|    std::tm tm;
   93|      3|    ::localtime_r(&time_tt, &tm);
   94|      3|#endif
   95|      3|    return tm;
   96|      3|}
_ZN6spdlog7details2os10create_dirERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  482|      1|SPDLOG_INLINE bool create_dir(const filename_t &path) {
  483|      1|    if (path_exists(path)) {
  ------------------
  |  Branch (483:9): [True: 1, False: 0]
  ------------------
  484|      1|        return true;
  485|      1|    }
  486|       |
  487|      0|    if (path.empty()) {
  ------------------
  |  Branch (487:9): [True: 0, False: 0]
  ------------------
  488|      0|        return false;
  489|      0|    }
  490|       |
  491|      0|    size_t search_offset = 0;
  492|      0|    do {
  493|      0|        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
  494|       |        // treat the entire path as a folder if no folder separator not found
  495|      0|        if (token_pos == filename_t::npos) {
  ------------------
  |  Branch (495:13): [True: 0, False: 0]
  ------------------
  496|      0|            token_pos = path.size();
  497|      0|        }
  498|       |
  499|      0|        auto subdir = path.substr(0, token_pos);
  500|       |#ifdef _WIN32
  501|       |        // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
  502|       |        // otherwise path_exists(subdir) returns false (issue #3079)
  503|       |        const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
  504|       |        if (is_drive) {
  505|       |            subdir += '\\';
  506|       |            token_pos++;
  507|       |        }
  508|       |#endif
  509|       |
  510|      0|        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
  ------------------
  |  Branch (510:13): [True: 0, False: 0]
  |  Branch (510:32): [True: 0, False: 0]
  |  Branch (510:56): [True: 0, False: 0]
  ------------------
  511|      0|            return false;  // return error if failed creating dir
  512|      0|        }
  513|      0|        search_offset = token_pos + 1;
  514|      0|    } while (search_offset < path.size());
  ------------------
  |  Branch (514:14): [True: 0, False: 0]
  ------------------
  515|       |
  516|      0|    return true;
  517|      0|}
_ZN6spdlog7details2os11path_existsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  177|      1|SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
  178|       |#ifdef _WIN32
  179|       |    struct _stat buffer;
  180|       |#ifdef SPDLOG_WCHAR_FILENAMES
  181|       |    return (::_wstat(filename.c_str(), &buffer) == 0);
  182|       |#else
  183|       |    return (::_stat(filename.c_str(), &buffer) == 0);
  184|       |#endif
  185|       |#else  // common linux/unix all have the stat system call
  186|      1|    struct stat buffer;
  187|      1|    return (::stat(filename.c_str(), &buffer) == 0);
  188|      1|#endif
  189|      1|}
_ZN6spdlog7details2os8dir_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  524|      1|SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
  525|      1|    auto pos = path.find_last_of(folder_seps_filename);
  526|      1|    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
  ------------------
  |  Branch (526:12): [True: 1, False: 0]
  ------------------
  527|      1|}
_ZN6spdlog7details2os7fopen_sEPP8_IO_FILERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  120|      1|SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
  121|       |#ifdef _WIN32
  122|       |#ifdef SPDLOG_WCHAR_FILENAMES
  123|       |    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
  124|       |#else
  125|       |    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
  126|       |#endif
  127|       |#if defined(SPDLOG_PREVENT_CHILD_FD)
  128|       |    if (*fp != nullptr) {
  129|       |        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
  130|       |        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
  131|       |            ::fclose(*fp);
  132|       |            *fp = nullptr;
  133|       |        }
  134|       |    }
  135|       |#endif
  136|       |#else  // unix
  137|       |#if defined(SPDLOG_PREVENT_CHILD_FD)
  138|       |    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
  139|       |    const int fd =
  140|       |        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
  141|       |    if (fd == -1) {
  142|       |        return true;
  143|       |    }
  144|       |    *fp = ::fdopen(fd, mode.c_str());
  145|       |    if (*fp == nullptr) {
  146|       |        ::close(fd);
  147|       |    }
  148|       |#else
  149|      1|    *fp = ::fopen((filename.c_str()), mode.c_str());
  150|      1|#endif
  151|      1|#endif
  152|       |
  153|      1|    return *fp == nullptr;
  154|      1|}
_ZN6spdlog7details2os3nowEv:
   75|  1.13k|SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
   76|       |#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
   77|       |    timespec ts;
   78|       |    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
   79|       |    return std::chrono::time_point<log_clock, typename log_clock::duration>(
   80|       |        std::chrono::duration_cast<typename log_clock::duration>(
   81|       |            std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
   82|       |
   83|       |#else
   84|  1.13k|    return log_clock::now();
   85|  1.13k|#endif
   86|  1.13k|}
_ZN6spdlog7details2os9thread_idEv:
  325|  1.13k|SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
  326|       |#if defined(SPDLOG_NO_TLS)
  327|       |    return _thread_id();
  328|       |#else  // cache thread id in tls
  329|  1.13k|    static thread_local const size_t tid = _thread_id();
  330|  1.13k|    return tid;
  331|  1.13k|#endif
  332|  1.13k|}
_ZN6spdlog7details2os10_thread_idEv:
  274|      1|SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
  275|       |#ifdef _WIN32
  276|       |    return static_cast<size_t>(::GetCurrentThreadId());
  277|       |#elif defined(__linux__)
  278|       |#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
  279|       |#define SYS_gettid __NR_gettid
  280|       |#endif
  281|      1|    return static_cast<size_t>(::syscall(SYS_gettid));
  282|       |#elif defined(_AIX)
  283|       |    struct __pthrdsinfo buf;
  284|       |    int reg_size = 0;
  285|       |    pthread_t pt = pthread_self();
  286|       |    int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, &reg_size);
  287|       |    int tid = (!retval) ? buf.__pi_tid : 0;
  288|       |    return static_cast<size_t>(tid);
  289|       |#elif defined(__DragonFly__) || defined(__FreeBSD__)
  290|       |    return static_cast<size_t>(::pthread_getthreadid_np());
  291|       |#elif defined(__NetBSD__)
  292|       |    return static_cast<size_t>(::_lwp_self());
  293|       |#elif defined(__OpenBSD__)
  294|       |    return static_cast<size_t>(::getthrid());
  295|       |#elif defined(__sun)
  296|       |    return static_cast<size_t>(::thr_self());
  297|       |#elif __APPLE__
  298|       |    uint64_t tid;
  299|       |// There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
  300|       |// including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
  301|       |#ifdef MAC_OS_X_VERSION_MAX_ALLOWED
  302|       |    {
  303|       |#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
  304|       |        tid = pthread_mach_thread_np(pthread_self());
  305|       |#elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
  306|       |        if (&pthread_threadid_np) {
  307|       |            pthread_threadid_np(nullptr, &tid);
  308|       |        } else {
  309|       |            tid = pthread_mach_thread_np(pthread_self());
  310|       |        }
  311|       |#else
  312|       |        pthread_threadid_np(nullptr, &tid);
  313|       |#endif
  314|       |    }
  315|       |#else
  316|       |    pthread_threadid_np(nullptr, &tid);
  317|       |#endif
  318|       |    return static_cast<size_t>(tid);
  319|       |#else  // Default to standard C++11 (other Unix)
  320|       |    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
  321|       |#endif
  322|      1|}

_ZN6spdlog7details8registry8instanceEv:
  241|  10.8k|SPDLOG_INLINE registry &registry::instance() {
  242|  10.8k|    static registry s_instance;
  243|  10.8k|    return s_instance;
  244|  10.8k|}
_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:
  105|      1|SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
  106|      1|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
  107|      1|    if (new_default_logger != nullptr) {
  ------------------
  |  Branch (107:9): [True: 1, False: 0]
  ------------------
  108|      1|        loggers_[new_default_logger->name()] = new_default_logger;
  109|      1|    }
  110|      1|    default_logger_ = std::move(new_default_logger);
  111|      1|}
_ZN6spdlog7details8registry10set_levelsENSt3__113unordered_mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_5level10level_enumENS2_4hashIS9_EENS2_8equal_toIS9_EENS7_INS2_4pairIKS9_SB_EEEEEEPSB_:
  225|  8.12k|SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) {
  226|  8.12k|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
  227|  8.12k|    log_levels_ = std::move(levels);
  228|  8.12k|    auto global_level_requested = global_level != nullptr;
  229|  8.12k|    global_log_level_ = global_level_requested ? *global_level : global_log_level_;
  ------------------
  |  Branch (229:25): [True: 612, False: 7.51k]
  ------------------
  230|       |
  231|  16.2k|    for (auto &logger : loggers_) {
  ------------------
  |  Branch (231:23): [True: 16.2k, False: 8.12k]
  ------------------
  232|  16.2k|        auto logger_entry = log_levels_.find(logger.first);
  233|  16.2k|        if (logger_entry != log_levels_.end()) {
  ------------------
  |  Branch (233:13): [True: 0, False: 16.2k]
  ------------------
  234|      0|            logger.second->set_level(logger_entry->second);
  235|  16.2k|        } else if (global_level_requested) {
  ------------------
  |  Branch (235:20): [True: 1.22k, False: 15.0k]
  ------------------
  236|  1.22k|            logger.second->set_level(*global_level);
  237|  1.22k|        }
  238|  16.2k|    }
  239|  8.12k|}
_ZN6spdlog7details8registry17initialize_loggerENSt3__110shared_ptrINS_6loggerEEE:
   62|      1|SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {
   63|      1|    std::lock_guard<std::mutex> lock(logger_map_mutex_);
   64|      1|    new_logger->set_formatter(formatter_->clone());
   65|       |
   66|      1|    if (err_handler_) {
  ------------------
  |  Branch (66:9): [True: 0, False: 1]
  ------------------
   67|      0|        new_logger->set_error_handler(err_handler_);
   68|      0|    }
   69|       |
   70|       |    // set new level according to previously configured level or default level
   71|      1|    auto it = log_levels_.find(new_logger->name());
   72|      1|    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
  ------------------
  |  Branch (72:22): [True: 0, False: 1]
  ------------------
   73|      1|    new_logger->set_level(new_level);
   74|       |
   75|      1|    new_logger->flush_on(flush_level_);
   76|       |
   77|      1|    if (backtrace_n_messages_ > 0) {
  ------------------
  |  Branch (77:9): [True: 0, False: 1]
  ------------------
   78|      0|        new_logger->enable_backtrace(backtrace_n_messages_);
   79|      0|    }
   80|       |
   81|      1|    if (automatic_registration_) {
  ------------------
  |  Branch (81:9): [True: 1, False: 0]
  ------------------
   82|      1|        register_logger_(std::move(new_logger));
   83|      1|    }
   84|      1|}
_ZN6spdlog7details8registry16register_logger_ENSt3__110shared_ptrINS_6loggerEEE:
  259|      1|SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
  260|      1|    const auto &logger_name = new_logger->name();
  261|      1|    throw_if_exists_(logger_name);
  262|      1|    loggers_[logger_name] = std::move(new_logger);
  263|      1|}
_ZN6spdlog7details8registry16throw_if_exists_ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  253|      1|SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
  254|      1|    if (loggers_.find(logger_name) != loggers_.end()) {
  ------------------
  |  Branch (254:9): [True: 0, False: 1]
  ------------------
  255|      0|        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
  256|      0|    }
  257|      1|}
_ZN6spdlog7details8registry15get_default_rawEv:
  101|  2.71k|SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }

_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|    }

_ZN3fmt3v126detail13ignore_unusedIJbEEEvDpRKT_:
  361|    180|template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
_ZNK3fmt3v126detail6bufferIcE8capacityEv:
 1818|    271|  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
_ZN3fmt3v126detail6bufferIcE4dataEv:
 1821|  1.32k|  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
_ZNK3fmt3v126detail6bufferIcE4sizeEv:
 1815|  4.90k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v126detail6bufferIcEC2EPFvRS3_mEPcmm:
 1790|  1.14k|      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
_ZN3fmt3v126detail6bufferIcE3setEPcm:
 1796|  1.32k|  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
 1797|  1.32k|    ptr_ = buf_data;
 1798|  1.32k|    capacity_ = buf_capacity;
 1799|  1.32k|  }
_ZNK3fmt3v1217basic_string_viewIcE4dataEv:
  564|  4.55k|  constexpr auto data() const noexcept -> const Char* { return data_; }
_ZN3fmt3v126detail6bufferIcE6appendIcEEvPKT_S7_:
 1855|  5.68k|      append(const U* begin, const U* end) {
 1856|  10.3k|    while (begin != end) {
  ------------------
  |  Branch (1856:12): [True: 4.65k, False: 5.68k]
  ------------------
 1857|  4.65k|      auto size = size_;
 1858|  4.65k|      auto free_cap = capacity_ - size;
 1859|  4.65k|      auto count = to_unsigned(end - begin);
 1860|  4.65k|      if (free_cap < count) {
  ------------------
  |  Branch (1860:11): [True: 180, False: 4.47k]
  ------------------
 1861|    180|        grow_(*this, size + count);
 1862|    180|        size = size_;
 1863|    180|        free_cap = capacity_ - size;
 1864|    180|        count = count < free_cap ? count : free_cap;
  ------------------
  |  Branch (1864:17): [True: 91, False: 89]
  ------------------
 1865|    180|      }
 1866|       |      // A loop is faster than memcpy on small sizes.
 1867|  4.65k|      T* out = ptr_ + size;
 1868|  17.4M|      for (size_t i = 0; i < count; ++i) out[i] = begin[i];
  ------------------
  |  Branch (1868:26): [True: 17.4M, False: 4.65k]
  ------------------
 1869|  4.65k|      size_ += count;
 1870|  4.65k|      begin += count;
 1871|  4.65k|    }
 1872|  5.68k|  }
_ZN3fmt3v126detail11to_unsignedIlEENSt3__113make_unsignedIT_E4typeES5_:
  439|  4.66k|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  440|  4.66k|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  395|  9.32k|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (395:7): [Folded, False: 4.66k]
  |  |  |  Branch (395:7): [True: 4.66k, False: 0]
  |  |  ------------------
  |  |  396|  4.66k|         ? (void)0                                                          \
  |  |  397|  4.66k|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  441|  4.66k|  return static_cast<make_unsigned_t<Int>>(value);
  442|  4.66k|}
_ZNK3fmt3v1217basic_string_viewIcE4sizeEv:
  567|   485k|  constexpr auto size() const noexcept -> size_t { return size_; }
_ZN3fmt3v1217basic_string_viewIcEC2INSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnNS4_9enable_ifIXaasr6detail18is_std_string_likeIT_EE5valuesr3std7is_sameINSC_10value_typeEcEE5valueEiE4typeELi0EEERKSC_:
  561|  4.98k|      : data_(s.data()), size_(s.size()) {}
_ZN3fmt3v1217basic_string_viewIcEC2EPKc:
  543|     27|  FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {
  544|     27|#if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
  545|     27|    if (std::is_same<Char, char>::value && !detail::is_constant_evaluated()) {
  ------------------
  |  Branch (545:9): [True: 0, Folded]
  |  Branch (545:44): [True: 0, Folded]
  ------------------
  546|     27|      size_ = __builtin_strlen(detail::narrow(s));  // strlen is not constexpr.
  547|     27|      return;
  548|     27|    }
  549|      0|#endif
  550|      0|    size_t len = 0;
  551|      0|    while (*s++) ++len;
  ------------------
  |  Branch (551:12): [True: 0, False: 0]
  ------------------
  552|      0|    size_ = len;
  553|      0|  }
_ZN3fmt3v126detail6narrowEPKc:
  469|     27|constexpr FMT_ALWAYS_INLINE auto narrow(const char* s) -> const char* {
  470|     27|  return s;
  471|     27|}
_ZN3fmt3v126detail6bufferIcE5clearEv:
 1825|      3|  FMT_CONSTEXPR void clear() { size_ = 0; }
_ZN3fmt3v126detail6bufferIcE9push_backERKc:
 1842|  12.5k|  FMT_CONSTEXPR void push_back(const T& value) {
 1843|  12.5k|    try_reserve(size_ + 1);
 1844|  12.5k|    ptr_[size_++] = value;
 1845|  12.5k|  }
_ZN3fmt3v126detail6bufferIcE11try_reserveEm:
 1838|  12.5k|  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
 1839|  12.5k|    if (new_capacity > capacity_) grow_(*this, new_capacity);
  ------------------
  |  Branch (1839:9): [True: 0, False: 12.5k]
  ------------------
 1840|  12.5k|  }
_ZN3fmt3v126detail11to_unsignedIiEENSt3__113make_unsignedIT_E4typeES5_:
  439|      3|FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
  440|      3|  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  ------------------
  |  |  395|      6|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (395:7): [Folded, False: 3]
  |  |  |  Branch (395:7): [True: 3, False: 0]
  |  |  ------------------
  |  |  396|      3|         ? (void)0                                                          \
  |  |  397|      3|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  441|      3|  return static_cast<make_unsigned_t<Int>>(value);
  442|      3|}
_ZNK3fmt3v1217basic_string_viewIcE5beginEv:
  569|  50.8k|  constexpr auto begin() const noexcept -> iterator { return data_; }
_ZN3fmt3v126detail6bufferIcE5beginEv:
 1808|  1.13k|  auto begin() noexcept -> T* { return ptr_; }
_ZN3fmt3v126detail6bufferIcE3endEv:
 1809|  1.13k|  auto end() noexcept -> T* { return ptr_ + size_; }
_ZNK3fmt3v126detail6bufferIcE4dataEv:
 1822|  1.13k|  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }

_ZN3fmt3v1219basic_memory_bufferIcLm250ENS0_6detail9allocatorIcEEEC2ERKS4_:
  840|  1.14k|      : detail::buffer<T>(grow), alloc_(alloc) {
  841|  1.14k|    this->set(store_, SIZE);
  842|  1.14k|    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  ------------------
  |  Branch (842:9): [Folded, False: 1.14k]
  ------------------
  843|  1.14k|  }
_ZN3fmt3v1219basic_memory_bufferIcLm250ENS0_6detail9allocatorIcEEE4growERNS2_6bufferIcEEm:
  810|    180|  static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) {
  811|    180|    detail::abort_fuzzing_if(size > 5000);
  812|    180|    auto& self = static_cast<basic_memory_buffer&>(buf);
  813|    180|    const size_t max_size =
  814|    180|        std::allocator_traits<Allocator>::max_size(self.alloc_);
  815|    180|    size_t old_capacity = buf.capacity();
  816|    180|    size_t new_capacity = old_capacity + old_capacity / 2;
  817|    180|    if (size > new_capacity)
  ------------------
  |  Branch (817:9): [True: 89, False: 91]
  ------------------
  818|     89|      new_capacity = size;
  819|     91|    else if (new_capacity > max_size)
  ------------------
  |  Branch (819:14): [True: 0, False: 91]
  ------------------
  820|      0|      new_capacity = max_of(size, max_size);
  821|    180|    T* old_data = buf.data();
  822|    180|    T* new_data = self.alloc_.allocate(new_capacity);
  823|       |    // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
  824|    180|    detail::assume(buf.size() <= new_capacity);
  825|       |    // The following code doesn't throw, so the raw pointer above doesn't leak.
  826|    180|    memcpy(new_data, old_data, buf.size() * sizeof(T));
  827|    180|    self.set(new_data, new_capacity);
  828|       |    // deallocate must not throw according to the standard, but even if it does,
  829|       |    // the buffer already uses the new storage and will deallocate it in
  830|       |    // destructor.
  831|    180|    if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity);
  ------------------
  |  Branch (831:9): [True: 89, False: 91]
  ------------------
  832|    180|  }
_ZN3fmt3v126detail16abort_fuzzing_ifEb:
  252|    180|FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  253|    180|  ignore_unused(condition);
  254|       |#ifdef FMT_FUZZ
  255|       |  if (condition) throw std::runtime_error("fuzzing limit reached");
  256|       |#endif
  257|    180|}
_ZN3fmt3v126detail9allocatorIcE8allocateEm:
  749|    180|  auto allocate(size_t n) -> T* {
  750|    180|    FMT_ASSERT(n <= max_value<size_t>() / sizeof(T), "");
  ------------------
  |  |  395|    180|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (395:6): [True: 180, False: 0]
  |  |  ------------------
  |  |  396|    180|         ? (void)0                                                          \
  |  |  397|    180|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
  751|    180|    T* p = static_cast<T*>(malloc(n * sizeof(T)));
  752|    180|    if (!p) FMT_THROW(std::bad_alloc());
  ------------------
  |  |  175|      0|#  define FMT_THROW(x) throw x
  ------------------
  |  Branch (752:9): [True: 0, False: 180]
  ------------------
  753|    180|    return p;
  754|    180|  }
_ZN3fmt3v126detail9max_valueImEET_v:
  427|    180|template <typename T> constexpr auto max_value() -> T {
  428|    180|  return (std::numeric_limits<T>::max)();
  429|    180|}
_ZN3fmt3v126detail6assumeEb:
  479|    180|FMT_INLINE void assume(bool condition) {
  480|    180|  (void)condition;
  481|    180|#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
  482|    180|  __builtin_assume(condition);
  483|       |#elif FMT_GCC_VERSION
  484|       |  if (!condition) __builtin_unreachable();
  485|       |#endif
  486|    180|}
_ZN3fmt3v126detail9allocatorIcE10deallocateEPcm:
  756|    180|  void deallocate(T* p, size_t) { free(p); }
_ZN3fmt3v1219basic_memory_bufferIcLm250ENS0_6detail9allocatorIcEEED2Ev:
  844|  1.14k|  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
_ZN3fmt3v1219basic_memory_bufferIcLm250ENS0_6detail9allocatorIcEEE10deallocateEv:
  805|  1.14k|  FMT_CONSTEXPR20 void deallocate() {
  806|  1.14k|    T* data = this->data();
  807|  1.14k|    if (data != store_) alloc_.deallocate(data, this->capacity());
  ------------------
  |  Branch (807:9): [True: 91, False: 1.04k]
  ------------------
  808|  1.14k|  }
_ZN3fmt3v1210format_intC2Ei:
 4190|      3|  FMT_CONSTEXPR20 explicit format_int(int value) : str_(format_signed(value)) {}
_ZN3fmt3v1210format_int13format_signedIiEEPcT_:
 4180|      3|  FMT_CONSTEXPR20 auto format_signed(Int value) -> char* {
 4181|      3|    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
 4182|      3|    bool negative = value < 0;
 4183|      3|    if (negative) abs_value = 0 - abs_value;
  ------------------
  |  Branch (4183:9): [True: 0, False: 3]
  ------------------
 4184|      3|    auto begin = format_unsigned(abs_value);
 4185|      3|    if (negative) *--begin = '-';
  ------------------
  |  Branch (4185:9): [True: 0, False: 3]
  ------------------
 4186|      3|    return begin;
 4187|      3|  }
_ZN3fmt3v1210format_int15format_unsignedIjEEPcT_:
 4174|      3|  FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* {
 4175|      3|    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
 4176|      3|    return detail::do_format_decimal(buffer_, n, buffer_size - 1);
 4177|      3|  }
_ZN3fmt3v126detail17do_format_decimalIcjEEPT_S4_T0_i:
 1220|      3|    -> Char* {
 1221|      3|  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  ------------------
  |  |  395|      3|    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
  |  |  ------------------
  |  |  |  Branch (395:6): [True: 3, False: 0]
  |  |  ------------------
  |  |  396|      3|         ? (void)0                                                          \
  |  |  397|      3|         : ::fmt::assert_fail(__FILE__, __LINE__, (message)))
  ------------------
 1222|      3|  unsigned n = to_unsigned(size);
 1223|      6|  while (value >= 100) {
  ------------------
  |  Branch (1223:10): [True: 3, False: 3]
  ------------------
 1224|       |    // Integer division is slow so do it for a group of two digits instead
 1225|       |    // of for every digit. The idea comes from the talk by Alexandrescu
 1226|       |    // "Three Optimization Tips for C++". See speed-test for a comparison.
 1227|      3|    n -= 2;
 1228|      3|    write2digits(out + n, static_cast<unsigned>(value % 100));
 1229|      3|    value /= 100;
 1230|      3|  }
 1231|      3|  if (value >= 10) {
  ------------------
  |  Branch (1231:7): [True: 3, False: 0]
  ------------------
 1232|      3|    n -= 2;
 1233|      3|    write2digits(out + n, static_cast<unsigned>(value));
 1234|      3|  } else {
 1235|      0|    out[--n] = static_cast<Char>('0' + value);
 1236|      0|  }
 1237|      3|  return out + n;
 1238|      3|}
_ZN3fmt3v126detail12count_digitsEj:
 1146|      3|FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
 1147|      3|#ifdef FMT_BUILTIN_CLZ
 1148|      3|  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
  ------------------
  |  |  290|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1148:7): [True: 0, Folded]
  |  Branch (1148:35): [True: 0, Folded]
  ------------------
 1149|      0|#endif
 1150|      0|  return count_digits_fallback(n);
 1151|      3|}
_ZN3fmt3v126detail15do_count_digitsEj:
 1123|      3|FMT_INLINE auto do_count_digits(uint32_t n) -> int {
 1124|       |// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
 1125|       |// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
 1127|      3|  static constexpr uint64_t table[] = {
 1128|      3|      FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1129|      3|      FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1130|      3|      FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1131|      3|      FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1132|      3|      FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1133|      3|      FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1134|      3|      FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1135|      3|      FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1136|      3|      FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1137|      3|      FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1138|      3|      FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
                    FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
  ------------------
  |  | 1126|      3|#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  ------------------
 1139|      3|  };
 1140|      3|  auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];
  ------------------
  |  |  206|      3|#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
  ------------------
 1141|      3|  return static_cast<int>((n + inc) >> 32);
 1142|      3|}
_ZN3fmt3v126detail12write2digitsIcEEvPT_m:
 1206|      6|FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 1207|      6|  if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
  ------------------
  |  Branch (1207:7): [True: 0, Folded]
  |  Branch (1207:35): [True: 0, Folded]
  ------------------
 1208|      6|      !FMT_OPTIMIZE_SIZE) {
  ------------------
  |  |  290|      0|#  define FMT_OPTIMIZE_SIZE 0
  ------------------
  |  Branch (1208:7): [True: 0, Folded]
  ------------------
 1209|      6|    memcpy(out, digits2(value), 2);
 1210|      6|    return;
 1211|      6|  }
 1212|      0|  *out++ = static_cast<Char>('0' + value / 10);
 1213|      0|  *out = static_cast<Char>('0' + value % 10);
 1214|      0|}
_ZN3fmt3v126detail7digits2Em:
 1036|      6|inline auto digits2(size_t value) -> const char* {
 1037|       |  // Align data since unaligned access may be slower when crossing a
 1038|       |  // hardware-specific boundary.
 1039|      6|  alignas(2) static const char data[] =
 1040|      6|      "0001020304050607080910111213141516171819"
 1041|      6|      "2021222324252627282930313233343536373839"
 1042|      6|      "4041424344454647484950515253545556575859"
 1043|      6|      "6061626364656667686970717273747576777879"
 1044|      6|      "8081828384858687888990919293949596979899";
 1045|      6|  return &data[value * 2];
 1046|      6|}
_ZNK3fmt3v1210format_int4dataEv:
 4209|      6|  FMT_CONSTEXPR20 auto data() const -> const char* { return str_; }
_ZNK3fmt3v1210format_int4sizeEv:
 4203|      3|  FMT_CONSTEXPR20 auto size() const -> size_t {
 4204|      3|    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
 4205|      3|  }

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

_ZNK6spdlog6logger4nameEv:
   68|      3|SPDLOG_INLINE const std::string &logger::name() const { return name_; }
_ZN6spdlog6logger9set_levelENS_5level10level_enumE:
   62|  1.22k|SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }
_ZN6spdlog6logger8sink_it_ERKNS_7details7log_msgE:
  135|  1.13k|SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {
  136|  1.13k|    for (auto &sink : sinks_) {
  ------------------
  |  Branch (136:21): [True: 1.13k, False: 1.13k]
  ------------------
  137|  1.13k|        if (sink->should_log(msg.level)) {
  ------------------
  |  Branch (137:13): [True: 1.13k, False: 0]
  ------------------
  138|  1.13k|            SPDLOG_TRY { sink->log(msg); }
  ------------------
  |  |  116|  1.13k|#define SPDLOG_TRY try
  ------------------
  139|  1.13k|            SPDLOG_LOGGER_CATCH(msg.source)
  ------------------
  |  |   32|  1.13k|    catch (const std::exception &ex) {                                                \
  |  |   33|      0|        if (location.filename) {                                                      \
  |  |  ------------------
  |  |  |  Branch (33:13): [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)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4251|      0|#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4226|      0|    [] {                                                                     \
  |  |  |  |  |  |  |  | 4227|      0|      /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
  |  |  |  |  |  |  |  | 4228|      0|      /* Use a macro-like name to avoid shadowing warnings. */               \
  |  |  |  |  |  |  |  | 4229|      0|      struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {            \
  |  |  |  |  |  |  |  | 4230|      0|        using char_type = fmt::remove_cvref_t<decltype(s[0])>;               \
  |  |  |  |  |  |  |  | 4231|      0|        constexpr explicit operator fmt::basic_string_view<char_type>()      \
  |  |  |  |  |  |  |  | 4232|      0|            const {                                                          \
  |  |  |  |  |  |  |  | 4233|      0|          return fmt::detail::compile_string_to_view<char_type>(s);          \
  |  |  |  |  |  |  |  | 4234|      0|        }                                                                    \
  |  |  |  |  |  |  |  | 4235|      0|      };                                                                     \
  |  |  |  |  |  |  |  | 4236|      0|      using FMT_STRING_VIEW =                                                \
  |  |  |  |  |  |  |  | 4237|      0|          fmt::basic_string_view<typename FMT_COMPILE_STRING::char_type>;    \
  |  |  |  |  |  |  |  | 4238|      0|      fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING()));     \
  |  |  |  |  |  |  |  | 4239|      0|      return FMT_COMPILE_STRING();                                           \
  |  |  |  |  |  |  |  | 4240|      0|    }()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|                                         location.filename, location.line));          \
  |  |   36|      0|        } else {                                                                      \
  |  |   37|      0|            err_handler_(ex.what());                                                  \
  |  |   38|      0|        }                                                                             \
  |  |   39|      0|    }                                                                                 \
  |  |   40|  1.13k|    catch (...) {                                                                     \
  |  |   41|      0|        err_handler_("Rethrowing unknown exception in logger");                       \
  |  |   42|      0|        throw;                                                                        \
  |  |   43|      0|    }
  ------------------
  140|  1.13k|        }
  141|  1.13k|    }
  142|       |
  143|  1.13k|    if (should_flush_(msg)) {
  ------------------
  |  Branch (143:9): [True: 0, False: 1.13k]
  ------------------
  144|      0|        flush_();
  145|      0|    }
  146|  1.13k|}
_ZNK6spdlog6logger13should_flush_ERKNS_7details7log_msgE:
  166|  1.13k|SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) const {
  167|  1.13k|    return (msg.level >= flush_level()) && (msg.level != level::off);
  ------------------
  |  Branch (167:12): [True: 0, False: 1.13k]
  |  Branch (167:44): [True: 0, False: 0]
  ------------------
  168|  1.13k|}
_ZNK6spdlog6logger11flush_levelEv:
  102|  1.13k|SPDLOG_INLINE level::level_enum logger::flush_level() const {
  103|  1.13k|    return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
  104|  1.13k|}
_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|}
_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|  1.13k|                                   bool traceback_enabled) {
  127|  1.13k|    if (log_enabled) {
  ------------------
  |  Branch (127:9): [True: 1.13k, False: 0]
  ------------------
  128|  1.13k|        sink_it_(log_msg);
  129|  1.13k|    }
  130|  1.13k|    if (traceback_enabled) {
  ------------------
  |  Branch (130:9): [True: 0, False: 1.13k]
  ------------------
  131|      0|        tracer_.push_back(log_msg);
  132|      0|    }
  133|  1.13k|}

_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_:
   60|      2|        : name_(std::move(name)),
   61|      2|          sinks_(begin, end) {}
_ZN6spdlog6loggerD2Ev:
   71|      2|    virtual ~logger() = default;
_ZN6spdlog6logger4infoINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRKT_:
  250|  2.71k|    void info(const T &msg) {
  251|  2.71k|        log(level::info, msg);
  252|  2.71k|    }
_ZN6spdlog6logger3logINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvNS_5level10level_enumERKT_:
   93|  2.71k|    void log(level::level_enum lvl, const T &msg) {
   94|  2.71k|        log(source_loc{}, lvl, msg);
   95|  2.71k|    }
_ZN6spdlog6logger3logENS_10source_locENS_5level10level_enumEN3fmt3v1217basic_string_viewIcEE:
  119|  2.71k|    void log(source_loc loc, level::level_enum lvl, string_view_t msg) {
  120|  2.71k|        bool log_enabled = should_log(lvl);
  121|  2.71k|        bool traceback_enabled = tracer_.enabled();
  122|  2.71k|        if (!log_enabled && !traceback_enabled) {
  ------------------
  |  Branch (122:13): [True: 1.57k, False: 1.13k]
  |  Branch (122:29): [True: 1.57k, False: 0]
  ------------------
  123|  1.57k|            return;
  124|  1.57k|        }
  125|       |
  126|  1.13k|        details::log_msg log_msg(loc, name_, lvl, msg);
  127|  1.13k|        log_it_(log_msg, log_enabled, traceback_enabled);
  128|  1.13k|    }
_ZNK6spdlog6logger10should_logENS_5level10level_enumE:
  270|  2.71k|    bool should_log(level::level_enum msg_level) const {
  271|  2.71k|        return msg_level >= level_.load(std::memory_order_relaxed);
  272|  2.71k|    }

_ZN6spdlog3mdc11get_contextEv:
   46|  1.13k|    static mdc_map_t &get_context() {
   47|  1.13k|        static thread_local mdc_map_t context;
   48|  1.13k|        return context;
   49|  1.13k|    }

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

_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:
  134|      1|    : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEEC2EP8_IO_FILENS_10color_modeE:
   18|      1|    : target_file_(target_file),
   19|      1|      mutex_(ConsoleMutex::mutex()),
   20|      1|      formatter_(details::make_unique<spdlog::pattern_formatter>())
   21|       |
   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_mutexEE15set_color_mode_ENS_10color_modeE:
   96|      1|SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode) {
   97|      1|    switch (mode) {
   98|      0|        case color_mode::always:
  ------------------
  |  Branch (98:9): [True: 0, False: 1]
  ------------------
   99|      0|            should_do_colors_ = true;
  100|      0|            return;
  101|      1|        case color_mode::automatic:
  ------------------
  |  Branch (101:9): [True: 1, False: 0]
  ------------------
  102|      1|            should_do_colors_ =
  103|      1|                details::os::in_terminal(target_file_) && details::os::is_color_terminal();
  ------------------
  |  Branch (103:17): [True: 0, False: 1]
  |  Branch (103:59): [True: 0, False: 0]
  ------------------
  104|      1|            return;
  105|      0|        case color_mode::never:
  ------------------
  |  Branch (105:9): [True: 0, False: 1]
  ------------------
  106|      0|            should_do_colors_ = false;
  107|      0|            return;
  108|      0|        default:
  ------------------
  |  Branch (108:9): [True: 0, False: 1]
  ------------------
  109|      0|            should_do_colors_ = false;
  110|      1|    }
  111|      1|}
_ZN6spdlog5sinks14ansicolor_sinkINS_7details13console_mutexEE10to_string_ERKN3fmt3v1217basic_string_viewIcEE:
  127|      7|SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
  128|      7|    return std::string(sv.data(), sv.size());
  129|      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|  1.13k|void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) {
   27|  1.13k|    std::lock_guard<Mutex> lock(mutex_);
   28|  1.13k|    sink_it_(msg);
   29|  1.13k|}
_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:
   36|  1.13k|SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
   37|  1.13k|    memory_buf_t formatted;
   38|  1.13k|    base_sink<Mutex>::formatter_->format(msg, formatted);
   39|  1.13k|    file_helper_.write(formatted);
   40|  1.13k|}

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

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

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

_ZN6spdlog18set_default_loggerENSt3__110shared_ptrINS_6loggerEEE:
   88|      1|SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) {
   89|      1|    details::registry::instance().set_default_logger(std::move(default_logger));
   90|      1|}
_ZN6spdlog18default_logger_rawEv:
   84|  2.71k|SPDLOG_INLINE spdlog::logger *default_logger_raw() {
   85|  2.71k|    return details::registry::instance().get_default_raw();
   86|  2.71k|}

_ZN6spdlog4infoINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRKT_:
  257|  2.71k|inline void info(const T &msg) {
  258|  2.71k|    default_logger_raw()->info(msg);
  259|  2.71k|}