_ZN5Botan8high_bitITkNSt3__117unsigned_integralEjEEmT_:
   73|  2.28k|BOTAN_FORCE_INLINE constexpr size_t high_bit(T n) {
   74|  2.28k|   size_t hb = 0;
   75|       |
   76|  13.7k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (76:38): [True: 11.4k, False: 2.28k]
  ------------------
   77|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   78|  11.4k|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
   79|  11.4k|      hb += z;
   80|  11.4k|      n >>= z;
   81|  11.4k|   }
   82|       |
   83|  2.28k|   hb += n;
   84|       |
   85|  2.28k|   return hb;
   86|  2.28k|}
_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEjEEmT_m:
   45|  11.4k|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|  11.4k|   const T a = ~x & (x - 1);
   51|  11.4k|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|  11.4k|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|  11.4k|   return mask & s;
   54|  11.4k|}
_ZN5Botan17significant_bytesITkNSt3__117unsigned_integralEmEEmT_:
   94|    987|BOTAN_FORCE_INLINE constexpr size_t significant_bytes(T n) {
   95|    987|   size_t b = 0;
   96|       |
   97|  3.94k|   for(size_t s = 8 * sizeof(T) / 2; s >= 8; s /= 2) {
  ------------------
  |  Branch (97:38): [True: 2.96k, False: 987]
  ------------------
   98|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   99|  2.96k|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
  100|  2.96k|      b += z / 8;
  101|  2.96k|      n >>= z;
  102|  2.96k|   }
  103|       |
  104|    987|   b += (n != 0);
  105|       |
  106|    987|   return b;
  107|    987|}
_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEmEEmT_m:
   45|  2.96k|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|  2.96k|   const T a = ~x & (x - 1);
   51|  2.96k|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|  2.96k|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|  2.96k|   return mask & s;
   54|  2.96k|}
_ZN5Botan17ct_expand_top_bitITkNSt3__117unsigned_integralEmEET_S2_:
   28|  8.41k|BOTAN_FORCE_INLINE constexpr T ct_expand_top_bit(T a) {
   29|  8.41k|   const T top = CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1));
   30|  8.41k|   return static_cast<T>(0) - top;
   31|  8.41k|}
_ZN5Botan10ct_is_zeroITkNSt3__117unsigned_integralEmEET_S2_:
   37|  8.41k|BOTAN_FORCE_INLINE constexpr T ct_is_zero(T x) {
   38|  8.41k|   return ct_expand_top_bit<T>(~x & (x - 1));
   39|  8.41k|}

_ZN5Botan13reverse_bytesITkNSt3__117unsigned_integralEmQooooooeqstT_Li1EeqstS2_Li2EeqstS2_Li4EeqstS2_Li8EEES2_S2_:
   27|  7.18k|inline constexpr T reverse_bytes(T x) {
   28|       |   if constexpr(sizeof(T) == 1) {
   29|       |      return x;
   30|       |   } else if constexpr(sizeof(T) == 2) {
   31|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   32|       |      return static_cast<T>(__builtin_bswap16(x));
   33|       |#else
   34|       |      return static_cast<T>((x << 8) | (x >> 8));
   35|       |#endif
   36|       |   } else if constexpr(sizeof(T) == 4) {
   37|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   38|       |      return static_cast<T>(__builtin_bswap32(x));
   39|       |#else
   40|       |      // MSVC at least recognizes this as a bswap
   41|       |      return static_cast<T>(((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) |
   42|       |                            ((x & 0xFF000000) >> 24));
   43|       |#endif
   44|  7.18k|   } else if constexpr(sizeof(T) == 8) {
   45|  7.18k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   46|  7.18k|      return static_cast<T>(__builtin_bswap64(x));
   47|       |#else
   48|       |      uint32_t hi = static_cast<uint32_t>(x >> 32);
   49|       |      uint32_t lo = static_cast<uint32_t>(x);
   50|       |
   51|       |      hi = reverse_bytes(hi);
   52|       |      lo = reverse_bytes(lo);
   53|       |
   54|       |      return (static_cast<T>(lo) << 32) | hi;
   55|       |#endif
   56|  7.18k|   }
   57|  7.18k|}
_ZN5Botan13reverse_bytesITkNSt3__117unsigned_integralEtQooooooeqstT_Li1EeqstS2_Li2EeqstS2_Li4EeqstS2_Li8EEES2_S2_:
   27|  7.87k|inline constexpr T reverse_bytes(T x) {
   28|       |   if constexpr(sizeof(T) == 1) {
   29|       |      return x;
   30|  7.87k|   } else if constexpr(sizeof(T) == 2) {
   31|  7.87k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   32|  7.87k|      return static_cast<T>(__builtin_bswap16(x));
   33|       |#else
   34|       |      return static_cast<T>((x << 8) | (x >> 8));
   35|       |#endif
   36|       |   } else if constexpr(sizeof(T) == 4) {
   37|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   38|       |      return static_cast<T>(__builtin_bswap32(x));
   39|       |#else
   40|       |      // MSVC at least recognizes this as a bswap
   41|       |      return static_cast<T>(((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) |
   42|       |                            ((x & 0xFF000000) >> 24));
   43|       |#endif
   44|       |   } else if constexpr(sizeof(T) == 8) {
   45|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   46|       |      return static_cast<T>(__builtin_bswap64(x));
   47|       |#else
   48|       |      uint32_t hi = static_cast<uint32_t>(x >> 32);
   49|       |      uint32_t lo = static_cast<uint32_t>(x);
   50|       |
   51|       |      hi = reverse_bytes(hi);
   52|       |      lo = reverse_bytes(lo);
   53|       |
   54|       |      return (static_cast<T>(lo) << 32) | hi;
   55|       |#endif
   56|       |   }
   57|  7.87k|}
_ZN5Botan13reverse_bytesITkNSt3__117unsigned_integralEjQooooooeqstT_Li1EeqstS2_Li2EeqstS2_Li4EeqstS2_Li8EEES2_S2_:
   27|  1.42k|inline constexpr T reverse_bytes(T x) {
   28|       |   if constexpr(sizeof(T) == 1) {
   29|       |      return x;
   30|       |   } else if constexpr(sizeof(T) == 2) {
   31|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   32|       |      return static_cast<T>(__builtin_bswap16(x));
   33|       |#else
   34|       |      return static_cast<T>((x << 8) | (x >> 8));
   35|       |#endif
   36|  1.42k|   } else if constexpr(sizeof(T) == 4) {
   37|  1.42k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   38|  1.42k|      return static_cast<T>(__builtin_bswap32(x));
   39|       |#else
   40|       |      // MSVC at least recognizes this as a bswap
   41|       |      return static_cast<T>(((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) |
   42|       |                            ((x & 0xFF000000) >> 24));
   43|       |#endif
   44|       |   } else if constexpr(sizeof(T) == 8) {
   45|       |#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   46|       |      return static_cast<T>(__builtin_bswap64(x));
   47|       |#else
   48|       |      uint32_t hi = static_cast<uint32_t>(x >> 32);
   49|       |      uint32_t lo = static_cast<uint32_t>(x);
   50|       |
   51|       |      hi = reverse_bytes(hi);
   52|       |      lo = reverse_bytes(lo);
   53|       |
   54|       |      return (static_cast<T>(lo) << 32) | hi;
   55|       |#endif
   56|       |   }
   57|  1.42k|}

_ZN5Botan12BufferSlicerC2ENSt3__14spanIKhLm18446744073709551615EEE:
   25|   115k|      explicit BufferSlicer(std::span<const uint8_t> buffer) : m_remaining(buffer) {}
_ZNK5Botan12BufferSlicer5emptyEv:
   68|  1.28M|      bool empty() const { return m_remaining.empty(); }
_ZN5Botan12BufferSlicer9take_byteEv:
   57|   624k|      uint8_t take_byte() { return take(1)[0]; }
_ZN5Botan12BufferSlicer4takeEm:
   37|   624k|      std::span<const uint8_t> take(const size_t count) {
   38|   624k|         BOTAN_STATE_CHECK(remaining() >= count);
  ------------------
  |  |   51|   624k|   do {                                                         \
  |  |   52|   624k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|   624k|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 624k]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|   624k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 624k]
  |  |  ------------------
  ------------------
   39|   624k|         auto result = m_remaining.first(count);
   40|   624k|         m_remaining = m_remaining.subspan(count);
   41|   624k|         return result;
   42|   624k|      }
_ZNK5Botan12BufferSlicer9remainingEv:
   66|   624k|      size_t remaining() const { return m_remaining.size(); }

_ZN5Botan2CT8unpoisonITkNSt3__18integralEmEEvRKT_:
  112|    739|constexpr void unpoison(const T& p) {
  113|    739|   unpoison(&p, 1);
  114|    739|}
_ZN5Botan2CT8unpoisonImEEvPKT_m:
   67|  3.87k|constexpr inline void unpoison(const T* p, size_t n) {
   68|       |#if defined(BOTAN_HAS_VALGRIND)
   69|       |   if(!std::is_constant_evaluated()) {
   70|       |      VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
   71|       |   }
   72|       |#endif
   73|       |
   74|  3.87k|   BOTAN_UNUSED(p, n);
  ------------------
  |  |  144|  3.87k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   75|  3.87k|}

_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|  42.8k|std::string fmt(std::string_view format, const T&... args) {
   54|  42.8k|   std::ostringstream oss;
   55|  42.8k|   oss.imbue(std::locale::classic());
   56|  42.8k|   fmt_detail::do_fmt(oss, format, args...);
   57|  42.8k|   return oss.str();
   58|  42.8k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJS8_EEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|  42.8k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  42.8k|   size_t i = 0;
   27|       |
   28|  42.8k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 42.8k, False: 0]
  ------------------
   29|  42.8k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 42.8k, False: 0]
  |  Branch (29:30): [True: 42.8k, False: 0]
  |  Branch (29:59): [True: 42.8k, False: 0]
  ------------------
   30|  42.8k|         oss << val;
   31|  42.8k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  42.8k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  42.8k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|  45.0k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  45.0k|   size_t i = 0;
   27|       |
   28|   176k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 176k, False: 0]
  ------------------
   29|   176k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 45.0k, False: 131k]
  |  Branch (29:30): [True: 45.0k, False: 0]
  |  Branch (29:59): [True: 45.0k, False: 0]
  ------------------
   30|  45.0k|         oss << val;
   31|  45.0k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|   131k|      } else {
   33|   131k|         oss << format[i];
   34|   131k|      }
   35|       |
   36|   131k|      i += 1;
   37|   131k|   }
   38|  45.0k|}
_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  71.5k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  71.5k|   oss << format;
   22|  71.5k|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|  2.16k|std::string fmt(std::string_view format, const T&... args) {
   54|  2.16k|   std::ostringstream oss;
   55|  2.16k|   oss.imbue(std::locale::classic());
   56|  2.16k|   fmt_detail::do_fmt(oss, format, args...);
   57|  2.16k|   return oss.str();
   58|  2.16k|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|  3.90k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.90k|   size_t i = 0;
   27|       |
   28|  11.7k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 11.7k, False: 0]
  ------------------
   29|  11.7k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.90k, False: 7.80k]
  |  Branch (29:30): [True: 3.90k, False: 0]
  |  Branch (29:59): [True: 3.90k, False: 0]
  ------------------
   30|  3.90k|         oss << val;
   31|  3.90k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  7.80k|      } else {
   33|  7.80k|         oss << format[i];
   34|  7.80k|      }
   35|       |
   36|  7.80k|      i += 1;
   37|  7.80k|   }
   38|  3.90k|}
_ZN5Botan3fmtIJPKcEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|  3.58k|std::string fmt(std::string_view format, const T&... args) {
   54|  3.58k|   std::ostringstream oss;
   55|  3.58k|   oss.imbue(std::locale::classic());
   56|  3.58k|   fmt_detail::do_fmt(oss, format, args...);
   57|  3.58k|   return oss.str();
   58|  3.58k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  4.58k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.58k|   size_t i = 0;
   27|       |
   28|   105k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 105k, False: 0]
  ------------------
   29|   105k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.58k, False: 101k]
  |  Branch (29:30): [True: 4.58k, False: 0]
  |  Branch (29:59): [True: 4.58k, False: 0]
  ------------------
   30|  4.58k|         oss << val;
   31|  4.58k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|   101k|      } else {
   33|   101k|         oss << format[i];
   34|   101k|      }
   35|       |
   36|   101k|      i += 1;
   37|   101k|   }
   38|  4.58k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  18.1k|std::string fmt(std::string_view format, const T&... args) {
   54|  18.1k|   std::ostringstream oss;
   55|  18.1k|   oss.imbue(std::locale::classic());
   56|  18.1k|   fmt_detail::do_fmt(oss, format, args...);
   57|  18.1k|   return oss.str();
   58|  18.1k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  18.1k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  18.1k|   size_t i = 0;
   27|       |
   28|   135k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 135k, False: 0]
  ------------------
   29|   135k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 18.1k, False: 117k]
  |  Branch (29:30): [True: 18.1k, False: 0]
  |  Branch (29:59): [True: 18.1k, False: 0]
  ------------------
   30|  18.1k|         oss << val;
   31|  18.1k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|   117k|      } else {
   33|   117k|         oss << format[i];
   34|   117k|      }
   35|       |
   36|   117k|      i += 1;
   37|   117k|   }
   38|  18.1k|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|  1.00k|std::string fmt(std::string_view format, const T&... args) {
   54|  1.00k|   std::ostringstream oss;
   55|  1.00k|   oss.imbue(std::locale::classic());
   56|  1.00k|   fmt_detail::do_fmt(oss, format, args...);
   57|  1.00k|   return oss.str();
   58|  1.00k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  1.00k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.00k|   size_t i = 0;
   27|       |
   28|  1.00k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.00k, False: 0]
  ------------------
   29|  1.00k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.00k, False: 0]
  |  Branch (29:30): [True: 1.00k, False: 0]
  |  Branch (29:59): [True: 1.00k, False: 0]
  ------------------
   30|  1.00k|         oss << val;
   31|  1.00k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  1.00k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  1.00k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  1.00k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.00k|   size_t i = 0;
   27|       |
   28|  5.00k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 5.00k, False: 0]
  ------------------
   29|  5.00k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.00k, False: 4.00k]
  |  Branch (29:30): [True: 1.00k, False: 0]
  |  Branch (29:59): [True: 1.00k, False: 0]
  ------------------
   30|  1.00k|         oss << val;
   31|  1.00k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  4.00k|      } else {
   33|  4.00k|         oss << format[i];
   34|  4.00k|      }
   35|       |
   36|  4.00k|      i += 1;
   37|  4.00k|   }
   38|  1.00k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  3.90k|std::string fmt(std::string_view format, const T&... args) {
   54|  3.90k|   std::ostringstream oss;
   55|  3.90k|   oss.imbue(std::locale::classic());
   56|  3.90k|   fmt_detail::do_fmt(oss, format, args...);
   57|  3.90k|   return oss.str();
   58|  3.90k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  3.90k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.90k|   size_t i = 0;
   27|       |
   28|  3.90k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.90k, False: 0]
  ------------------
   29|  3.90k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.90k, False: 0]
  |  Branch (29:30): [True: 3.90k, False: 0]
  |  Branch (29:59): [True: 3.90k, False: 0]
  ------------------
   30|  3.90k|         oss << val;
   31|  3.90k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.90k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  3.90k|}

_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|  36.5k|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|  36.5k|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 36.5k, False: 0]
  ------------------
   39|  36.5k|      return checked_add(r.value(), rest...);
   40|  36.5k|   } else {
   41|      0|      return {};
   42|      0|   }
   43|  36.5k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   19|   109k|constexpr inline std::optional<T> checked_add(T a, T b) {
   20|   109k|   const T r = a + b;
   21|   109k|   if(r < a || r < b) {
  ------------------
  |  Branch (21:7): [True: 0, False: 109k]
  |  Branch (21:16): [True: 0, False: 109k]
  ------------------
   22|      0|      return {};
   23|      0|   }
   24|   109k|   return r;
   25|   109k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|  36.5k|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|  36.5k|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 36.5k, False: 0]
  ------------------
   39|  36.5k|      return checked_add(r.value(), rest...);
   40|  36.5k|   } else {
   41|      0|      return {};
   42|      0|   }
   43|  36.5k|}
_ZN5Botan11checked_mulITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   46|   200k|constexpr inline std::optional<T> checked_mul(T a, T b) {
   47|       |   // Multiplication by 1U is a hack to work around C's insane
   48|       |   // integer promotion rules.
   49|       |   // https://stackoverflow.com/questions/24795651
   50|   200k|   const T r = (1U * a) * b;
   51|       |   // If a == 0 then the multiply certainly did not overflow
   52|       |   // Otherwise r / a == b unless overflow occurred
   53|   200k|   if(a != 0 && r / a != b) {
  ------------------
  |  Branch (53:7): [True: 200k, False: 0]
  |  Branch (53:17): [True: 0, False: 200k]
  ------------------
   54|      0|      return {};
   55|      0|   }
   56|   200k|   return r;
   57|   200k|}

_ZN5Botan8get_byteILm0EmEEhT0_QltT_stS1_:
   81|  3.49k|{
   82|  3.49k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   83|  3.49k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   84|  3.49k|}
_ZN5Botan12get_byte_varImEEhmT_:
   69|  1.26k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   70|  1.26k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   71|  1.26k|}
_ZN5Botan7load_beImJNSt3__14spanIKhLm8EEEEEEDaDpOT0_:
  504|  5.16k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  5.16k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  5.16k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  5.16k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  5.16k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  5.16k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  5.16k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  5.16k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  5.16k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  5.16k|      } else {
  289|  5.16k|         const std::span in{in_range};
  290|  5.16k|         if constexpr(sizeof(OutT) == 1) {
  291|  5.16k|            return static_cast<OutT>(in[0]);
  292|  5.16k|         } else if constexpr(endianness == std::endian::native) {
  293|  5.16k|            return typecast_copy<OutT>(in);
  294|  5.16k|         } else {
  295|  5.16k|            static_assert(opposite(endianness) == std::endian::native);
  296|  5.16k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  5.16k|         }
  298|  5.16k|      }
  299|  5.16k|   }());
  300|  5.16k|}
_ZN5Botan6detail24wrap_strong_type_or_enumITkNS0_20unsigned_integralishEmTkNSt3__117unsigned_integralEmEEDaT0_:
  200|  7.18k|constexpr auto wrap_strong_type_or_enum(T t) {
  201|       |   if constexpr(std::is_enum_v<OutT>) {
  202|       |      return static_cast<OutT>(t);
  203|  7.18k|   } else {
  204|  7.18k|      return Botan::wrap_strong_type<OutT>(t);
  205|  7.18k|   }
  206|  7.18k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  5.16k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  5.16k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 5.16k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  5.16k|      } else {
  289|  5.16k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  5.16k|         } else {
  295|  5.16k|            static_assert(opposite(endianness) == std::endian::native);
  296|  5.16k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  5.16k|         }
  298|  5.16k|      }
  299|  5.16k|   }());
_ZN5Botan7load_beImJRNSt3__15arrayIhLm8EEEEEEDaDpOT0_:
  504|  2.02k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  2.02k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  2.02k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  2.02k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  2.02k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  2.02k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  2.02k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  2.02k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  2.02k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  2.02k|      } else {
  289|  2.02k|         const std::span in{in_range};
  290|  2.02k|         if constexpr(sizeof(OutT) == 1) {
  291|  2.02k|            return static_cast<OutT>(in[0]);
  292|  2.02k|         } else if constexpr(endianness == std::endian::native) {
  293|  2.02k|            return typecast_copy<OutT>(in);
  294|  2.02k|         } else {
  295|  2.02k|            static_assert(opposite(endianness) == std::endian::native);
  296|  2.02k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  2.02k|         }
  298|  2.02k|      }
  299|  2.02k|   }());
  300|  2.02k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  2.02k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  2.02k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 2.02k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  2.02k|      } else {
  289|  2.02k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  2.02k|         } else {
  295|  2.02k|            static_assert(opposite(endianness) == std::endian::native);
  296|  2.02k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  2.02k|         }
  298|  2.02k|      }
  299|  2.02k|   }());
_ZN5Botan7load_beItJPKhRmEEEDaDpOT0_:
  504|  7.87k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  7.87k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  7.87k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEtEET0_PKhm:
  454|  7.87k|inline constexpr OutT load_any(const uint8_t in[], size_t off) {
  455|       |   // asserts that *in points to enough bytes to read at offset off
  456|  7.87k|   constexpr size_t out_size = sizeof(OutT);
  457|  7.87k|   return load_any<endianness, OutT>(std::span<const uint8_t, out_size>(in + off * out_size, out_size));
  458|  7.87k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEtTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm2EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  7.87k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  7.87k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  7.87k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  7.87k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  7.87k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  7.87k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  7.87k|      } else {
  289|  7.87k|         const std::span in{in_range};
  290|  7.87k|         if constexpr(sizeof(OutT) == 1) {
  291|  7.87k|            return static_cast<OutT>(in[0]);
  292|  7.87k|         } else if constexpr(endianness == std::endian::native) {
  293|  7.87k|            return typecast_copy<OutT>(in);
  294|  7.87k|         } else {
  295|  7.87k|            static_assert(opposite(endianness) == std::endian::native);
  296|  7.87k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  7.87k|         }
  298|  7.87k|      }
  299|  7.87k|   }());
  300|  7.87k|}
_ZN5Botan6detail24wrap_strong_type_or_enumITkNS0_20unsigned_integralishEtTkNSt3__117unsigned_integralEtEEDaT0_:
  200|  7.87k|constexpr auto wrap_strong_type_or_enum(T t) {
  201|       |   if constexpr(std::is_enum_v<OutT>) {
  202|       |      return static_cast<OutT>(t);
  203|  7.87k|   } else {
  204|  7.87k|      return Botan::wrap_strong_type<OutT>(t);
  205|  7.87k|   }
  206|  7.87k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEtTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm2EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  7.87k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  7.87k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 7.87k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  7.87k|      } else {
  289|  7.87k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  7.87k|         } else {
  295|  7.87k|            static_assert(opposite(endianness) == std::endian::native);
  296|  7.87k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  7.87k|         }
  298|  7.87k|      }
  299|  7.87k|   }());
_ZN5Botan7load_beIjJPKhRmEEEDaDpOT0_:
  504|  1.42k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  1.42k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  1.42k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEjEET0_PKhm:
  454|  1.42k|inline constexpr OutT load_any(const uint8_t in[], size_t off) {
  455|       |   // asserts that *in points to enough bytes to read at offset off
  456|  1.42k|   constexpr size_t out_size = sizeof(OutT);
  457|  1.42k|   return load_any<endianness, OutT>(std::span<const uint8_t, out_size>(in + off * out_size, out_size));
  458|  1.42k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEjTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm4EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  1.42k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  1.42k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  1.42k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  1.42k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  1.42k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  1.42k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  1.42k|      } else {
  289|  1.42k|         const std::span in{in_range};
  290|  1.42k|         if constexpr(sizeof(OutT) == 1) {
  291|  1.42k|            return static_cast<OutT>(in[0]);
  292|  1.42k|         } else if constexpr(endianness == std::endian::native) {
  293|  1.42k|            return typecast_copy<OutT>(in);
  294|  1.42k|         } else {
  295|  1.42k|            static_assert(opposite(endianness) == std::endian::native);
  296|  1.42k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  1.42k|         }
  298|  1.42k|      }
  299|  1.42k|   }());
  300|  1.42k|}
_ZN5Botan6detail24wrap_strong_type_or_enumITkNS0_20unsigned_integralishEjTkNSt3__117unsigned_integralEjEEDaT0_:
  200|  1.42k|constexpr auto wrap_strong_type_or_enum(T t) {
  201|       |   if constexpr(std::is_enum_v<OutT>) {
  202|       |      return static_cast<OutT>(t);
  203|  1.42k|   } else {
  204|  1.42k|      return Botan::wrap_strong_type<OutT>(t);
  205|  1.42k|   }
  206|  1.42k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEjTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm4EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  1.42k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  1.42k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 1.42k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  1.42k|      } else {
  289|  1.42k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  1.42k|         } else {
  295|  1.42k|            static_assert(opposite(endianness) == std::endian::native);
  296|  1.42k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  1.42k|         }
  298|  1.42k|      }
  299|  1.42k|   }());

_ZN5Botan15bytes_to_stringENSt3__14spanIKhLm18446744073709551615EEE:
   76|  9.96k|inline std::string bytes_to_string(std::span<const uint8_t> bytes) {
   77|  9.96k|   return std::string(reinterpret_cast<const char*>(bytes.data()), bytes.size());
   78|  9.96k|}

_ZN5Botan8round_upEmm:
   26|  2.27k|constexpr inline size_t round_up(size_t n, size_t align_to) {
   27|       |   // Arguably returning n in this case would also be sensible
   28|  2.27k|   BOTAN_ARG_CHECK(align_to != 0, "align_to must not be 0");
  ------------------
  |  |   35|  2.27k|   do {                                                          \
  |  |   36|  2.27k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  2.27k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 2.27k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  2.27k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 2.27k]
  |  |  ------------------
  ------------------
   29|       |
   30|  2.27k|   if(n % align_to > 0) {
  ------------------
  |  Branch (30:7): [True: 2.06k, False: 202]
  ------------------
   31|  2.06k|      const size_t adj = align_to - (n % align_to);
   32|  2.06k|      BOTAN_ARG_CHECK(n + adj >= n, "Integer overflow during rounding");
  ------------------
  |  |   35|  2.06k|   do {                                                          \
  |  |   36|  2.06k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  2.06k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 2.06k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  2.06k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 2.06k]
  |  |  ------------------
  ------------------
   33|  2.06k|      n += adj;
   34|  2.06k|   }
   35|  2.27k|   return n;
   36|  2.27k|}

_ZN5Botan2CT13value_barrierITkNSt3__117unsigned_integralEjQntsr3stdE7same_asIbT_EEES3_S3_:
   43|  11.4k|constexpr inline T value_barrier(T x) {
   44|  11.4k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (44:7): [Folded, False: 11.4k]
  ------------------
   45|      0|      return x;
   46|  11.4k|   } else {
   47|  11.4k|#if defined(BOTAN_CT_VALUE_BARRIER_USE_ASM)
   48|       |      /*
   49|       |      * We may want a "stronger" statement such as
   50|       |      *     asm volatile("" : "+r,m"(x) : : "memory);
   51|       |      * (see https://theunixzoo.co.uk/blog/2021-10-14-preventing-optimisations.html)
   52|       |      * however the current approach seems sufficient with current compilers,
   53|       |      * and is minimally damaging with regards to degrading code generation.
   54|       |      */
   55|  11.4k|      asm("" : "+r"(x) : /* no input */);  // NOLINT(*-no-assembler)
   56|  11.4k|      return x;
   57|       |#elif defined(BOTAN_CT_VALUE_BARRIER_USE_VOLATILE)
   58|       |      volatile T vx = x;
   59|       |      return vx;
   60|       |#else
   61|       |      return x;
   62|       |#endif
   63|  11.4k|   }
   64|  11.4k|}
_ZN5Botan2CT13value_barrierITkNSt3__117unsigned_integralEmQntsr3stdE7same_asIbT_EEES3_S3_:
   43|  11.3k|constexpr inline T value_barrier(T x) {
   44|  11.3k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (44:7): [Folded, False: 11.3k]
  ------------------
   45|      0|      return x;
   46|  11.3k|   } else {
   47|  11.3k|#if defined(BOTAN_CT_VALUE_BARRIER_USE_ASM)
   48|       |      /*
   49|       |      * We may want a "stronger" statement such as
   50|       |      *     asm volatile("" : "+r,m"(x) : : "memory);
   51|       |      * (see https://theunixzoo.co.uk/blog/2021-10-14-preventing-optimisations.html)
   52|       |      * however the current approach seems sufficient with current compilers,
   53|       |      * and is minimally damaging with regards to degrading code generation.
   54|       |      */
   55|  11.3k|      asm("" : "+r"(x) : /* no input */);  // NOLINT(*-no-assembler)
   56|  11.3k|      return x;
   57|       |#elif defined(BOTAN_CT_VALUE_BARRIER_USE_VOLATILE)
   58|       |      volatile T vx = x;
   59|       |      return vx;
   60|       |#else
   61|       |      return x;
   62|       |#endif
   63|  11.3k|   }
   64|  11.3k|}

_ZNK5Botan10BER_Object6is_setEv:
  138|   883k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|   446k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|   446k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|   446k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|   195k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|   181k|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|   226k|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|   518k|      size_t length() const { return m_value.size(); }
_ZNK5Botan10BER_Object4dataEv:
  154|   133k|      std::span<const uint8_t> data() const { return std::span{m_value}; }
_ZN5Botan10BER_Object12mutable_bitsEm:
  171|   330k|      uint8_t* mutable_bits(size_t length) {
  172|   330k|         m_value.resize(length);
  173|   330k|         return m_value.data();
  174|   330k|      }
_ZNK5Botan3OIDeqERKS0_:
  301|    413|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan11ASN1_String5valueEv:
  365|  4.76k|      const std::string& value() const { return m_utf8_str; }
_ZN5Botan10intersectsENS_10ASN1_ClassES0_:
   70|   490k|inline bool intersects(ASN1_Class x, ASN1_Class y) {
   71|   490k|   return (static_cast<uint32_t>(x) & static_cast<uint32_t>(y)) != 0;
   72|   490k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|   446k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|   446k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|   446k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|   116k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|   116k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|   116k|}
_ZNKSt3__14hashIN5Botan3OIDEEclERKS2_:
  441|  72.4k|      size_t operator()(const Botan::OID& oid) const noexcept { return static_cast<size_t>(oid.hash_code()); }
_ZN5Botan3OIDC2Ev:
  220|   116k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectC2Ev:
  117|   128k|      ASN1_Object() = default;
_ZN5Botan11ASN1_ObjectD2Ev:
  122|   124k|      virtual ~ASN1_Object() = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  135|   156k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectC2Ev:
  130|   549k|      BER_Object() = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|     22|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan11ASN1_ObjectC2EOS0_:
  120|     22|      ASN1_Object(ASN1_Object&&) = default;

_ZN5Botan14ASN1_FormatterC2Ebmb:
   34|  9.31k|            m_print_context_specific(print_context_specific), m_max_depth(max_depth), m_require_der(require_der) {}

_ZN5Botan9ASN1_TimeC2Ev:
   39|  4.54k|      ASN1_Time() = default;

_ZN5Botan13ignore_paramsIJNS_9ASN1_TypeENS_10ASN1_ClassEmmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEEvDpRKT_:
  142|   156k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJNS_9ASN1_TypeENS_10ASN1_ClassENSt3__16vectorIhNS3_9allocatorIhEEEEEEEvDpRKT_:
  142|  21.8k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJNS_6BigIntEEEEvDpRKT_:
  142|  3.13k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJPKmmEEEvDpRKT_:
  142|  3.87k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJjEEEvDpRKT_:
  142|  6.94k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}

_ZN5Botan11BER_Decoder6LimitsC2Ebm:
   54|  9.31k|                  m_allow_ber(allow_ber), m_max_nested_indef(max_nested_indef) {}
_ZN5Botan11BER_Decoder6Limits3BEREm:
   42|  9.31k|            static Limits BER(size_t max_nested_indef = 16) { return Limits(true, max_nested_indef); }
_ZNK5Botan11BER_Decoder6limitsEv:
   98|   193k|      Limits limits() const { return m_limits; }
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectENS0_6LimitsE:
   81|  6.25k|            BER_Decoder(obj.data(), limits) {}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  230|  2.40k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeERb:
  220|    998|      BER_Decoder& decode(bool& out) { return decode(out, ASN1_Type::Boolean, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  242|  24.6k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  243|  24.6k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  244|  24.6k|      }
_ZNK5Botan11BER_Decoder6Limits18allow_ber_encodingEv:
   44|   709k|            bool allow_ber_encoding() const { return m_allow_ber; }
_ZNK5Botan11BER_Decoder6Limits20require_der_encodingEv:
   46|   371k|            bool require_der_encoding() const { return !allow_ber_encoding(); }
_ZNK5Botan11BER_Decoder6Limits28max_nested_indefinite_lengthEv:
   48|   338k|            size_t max_nested_indefinite_length() const { return m_max_nested_indef; }

_ZN5Botan6BigIntC2Ev:
   45|  3.13k|      BigInt() = default;
_ZN5Botan6BigIntD2Ev:
  185|  3.13k|      ~BigInt() { _const_time_unpoison(); }
_ZN5Botan6BigInt5clearEv:
  415|  3.13k|      void clear() {
  416|  3.13k|         m_data.set_to_zero();
  417|  3.13k|         m_signedness = Positive;
  418|  3.13k|      }
_ZNK5Botan6BigInt7is_zeroEv:
  484|    739|      bool is_zero() const { return sig_words() == 0; }
_ZNK5Botan6BigInt4signEv:
  604|    739|      Sign sign() const { return (m_signedness); }
_ZNK5Botan6BigInt12reverse_signEv:
  609|    739|      Sign reverse_sign() const {
  610|    739|         if(sign() == Positive) {
  ------------------
  |  Branch (610:13): [True: 739, False: 0]
  ------------------
  611|    739|            return Negative;
  612|    739|         }
  613|      0|         return Positive;
  614|    739|      }
_ZN5Botan6BigInt9flip_signEv:
  619|    739|      BOTAN_DEPRECATED("Deprecated no replacement") void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  625|    739|      void set_sign(Sign sign) {
  626|    739|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (626:13): [True: 739, False: 0]
  |  Branch (626:33): [True: 0, False: 739]
  ------------------
  627|      0|            sign = Positive;
  628|      0|         }
  629|       |
  630|    739|         m_signedness = sign;
  631|    739|      }
_ZNK5Botan6BigInt9sig_wordsEv:
  648|    739|      size_t sig_words() const { return m_data.sig_words(); }
_ZN5Botan6BigInt18_assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  983|  2.27k|      void _assign_from_bytes(std::span<const uint8_t> bytes) { assign_from_bytes(bytes); }
_ZNK5Botan6BigInt4Data10const_dataEv:
 1027|  3.13k|            const word* const_data() const { return m_reg.data(); }
_ZNK5Botan6BigInt4Data4sizeEv:
 1075|  3.13k|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
 1095|  2.27k|            void swap(secure_vector<word>& reg) noexcept {
 1096|  2.27k|               m_reg.swap(reg);
 1097|  2.27k|               invalidate_sig_words();
 1098|  2.27k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
 1100|  2.27k|            void invalidate_sig_words() const noexcept { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
 1102|    739|            size_t sig_words() const {
 1103|    739|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (1103:19): [True: 739, False: 0]
  ------------------
 1104|    739|                  m_sig_words = calc_sig_words();
 1105|    739|               }
 1106|    739|               return m_sig_words;
 1107|    739|            }

_ZN5Botan10DataSourceC2Ev:
  100|   202k|      DataSource() = default;
_ZN5Botan10DataSourceD2Ev:
  101|   202k|      virtual ~DataSource() = default;
_ZN5Botan17DataSource_MemoryC2ENSt3__14spanIKhLm18446744073709551615EEE:
  141|   202k|      explicit DataSource_Memory(std::span<const uint8_t> in) : m_source(in.begin(), in.end()), m_offset(0) {}

_ZNK5Botan9Exception4whatEv:
   94|  3.58k|      const char* what() const noexcept override { return m_msg.c_str(); }

_ZN5Botan8copy_memIhQsr3stdE12is_trivial_vIu7__decayIT_EEEEvPS1_PKS1_m:
  144|  1.13M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  145|  1.13M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |  103|  1.13M|   do {                                                                                          \
  |  |  104|  1.13M|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                              \
  |  |  105|  2.16M|      if((expr1) && !(expr2)) {                                                                  \
  |  |  ------------------
  |  |  |  Branch (105:10): [True: 1.08M, False: 47.2k]
  |  |  |  Branch (105:23): [True: 1.08M, False: 0]
  |  |  |  Branch (105:23): [True: 1.08M, False: 0]
  |  |  ------------------
  |  |  106|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                     \
  |  |  107|      0|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |  108|      0|      }                                                                                          \
  |  |  109|  1.13M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (109:12): [Folded, False: 1.13M]
  |  |  ------------------
  ------------------
  146|       |
  147|  1.13M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (147:7): [True: 1.12M, False: 4.68k]
  |  Branch (147:24): [True: 1.09M, False: 29.8k]
  |  Branch (147:42): [True: 1.08M, False: 12.6k]
  ------------------
  148|  1.08M|      std::memmove(out, in, sizeof(T) * n);
  149|  1.08M|   }
  150|  1.13M|}
_ZN5Botan11clear_bytesEPvm:
  101|  3.13k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  102|  3.13k|   if(bytes > 0) {
  ------------------
  |  Branch (102:7): [True: 0, False: 3.13k]
  ------------------
  103|      0|      std::memset(ptr, 0, bytes);
  104|      0|   }
  105|  3.13k|}
_ZN5Botan9clear_memImEEvPT_m:
  118|  3.13k|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|  3.13k|   clear_bytes(ptr, sizeof(T) * n);
  120|  3.13k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  5.16k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  5.16k|   ToT dst;  // NOLINT(*-member-init)
  212|  5.16k|   typecast_copy(dst, src);
  213|  5.16k|   return dst;
  214|  5.16k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  5.16k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  5.16k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  5.16k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IKhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  5.16k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  5.16k|   ranges::assert_equal_byte_lengths(out, in);
  178|  5.16k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  5.16k|}
_ZN5Botan8copy_memITkNS_6ranges23contiguous_output_rangeENSt3__14spanIhLm18446744073709551615EEETkNS1_16contiguous_rangeENS3_IKhLm18446744073709551615EEEQaasr3stdE9is_same_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeENS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIST_EEEvOSB_RKSL_:
  160|  2.02k|inline constexpr void copy_mem(OutR&& out /* NOLINT(*-std-forward) */, const InR& in) {
  161|  2.02k|   ranges::assert_equal_byte_lengths(out, in);
  162|  2.02k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (162:7): [Folded, False: 2.02k]
  ------------------
  163|      0|      std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
  164|  2.02k|   } else if(ranges::size_bytes(out) > 0) {
  ------------------
  |  Branch (164:14): [True: 2.02k, False: 0]
  ------------------
  165|  2.02k|      std::memmove(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  166|  2.02k|   }
  167|  2.02k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS5_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEEES5_RKSA_:
  210|  2.02k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  2.02k|   ToT dst;  // NOLINT(*-member-init)
  212|  2.02k|   typecast_copy(dst, src);
  213|  2.02k|   return dst;
  214|  2.02k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISC_EESD_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISJ_EEEvRSJ_RKS9_:
  188|  2.02k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  2.02k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  2.02k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS6_IXsr21__is_primary_templateINS7_Iu14__remove_cvrefIDTclL_ZNS9_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSF_ISN_EESO_E4type10value_typeEEEEvOSK_RKSA_:
  176|  2.02k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  2.02k|   ranges::assert_equal_byte_lengths(out, in);
  178|  2.02k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  2.02k|}
_ZN5Botan13typecast_copyItTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm2EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  7.87k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  7.87k|   ToT dst;  // NOLINT(*-member-init)
  212|  7.87k|   typecast_copy(dst, src);
  213|  7.87k|   return dst;
  214|  7.87k|}
_ZN5Botan13typecast_copyItTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm2EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  7.87k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  7.87k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  7.87k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanItLm1EEETkNS1_16contiguous_rangeENS3_IKhLm2EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  7.87k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  7.87k|   ranges::assert_equal_byte_lengths(out, in);
  178|  7.87k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  7.87k|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm4EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  1.42k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  1.42k|   ToT dst;  // NOLINT(*-member-init)
  212|  1.42k|   typecast_copy(dst, src);
  213|  1.42k|   return dst;
  214|  1.42k|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm4EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  1.42k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  1.42k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.42k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanIjLm1EEETkNS1_16contiguous_rangeENS3_IKhLm4EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  1.42k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  1.42k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.42k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.42k|}
_ZN5Botan19secure_scrub_memoryITkNS_6ranges23contiguous_output_rangeERNSt3__16vectorIhNS2_9allocatorIhEEEEEEvOT_:
   59|   549k|void secure_scrub_memory(ranges::contiguous_output_range auto&& data) {
   60|   549k|   secure_scrub_memory(std::ranges::data(data), ranges::size_bytes(data));
   61|   549k|}

_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJNS3_IKhLm18446744073709551615EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  2.02k|{
  101|  2.02k|   const std::span s0{r0};
  102|       |
  103|       |   if constexpr(statically_spanable_range<R0>) {
  104|       |      constexpr size_t expected_size = s0.size_bytes();
  105|       |      (assert_exact_byte_length<expected_size>(rs), ...);
  106|  2.02k|   } else {
  107|  2.02k|      const size_t expected_size = s0.size_bytes();
  108|  2.02k|      const bool correct_size =
  109|  2.02k|         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|  2.02k|      if(!correct_size) {
  ------------------
  |  Branch (111:10): [True: 0, False: 2.02k]
  ------------------
  112|      0|         memory_region_size_violation();
  113|      0|      }
  114|  2.02k|   }
  115|  2.02k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEvRKT0_:
   77|  2.02k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.02k|   const std::span s{r};
   79|  2.02k|   if constexpr(statically_spanable_range<R>) {
   80|  2.02k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.02k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKhLm8EEEEEvRKT0_:
   77|  10.3k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  10.3k|   const std::span s{r};
   79|  10.3k|   if constexpr(statically_spanable_range<R>) {
   80|  10.3k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  10.3k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  5.16k|{
  101|  5.16k|   const std::span s0{r0};
  102|       |
  103|  5.16k|   if constexpr(statically_spanable_range<R0>) {
  104|  5.16k|      constexpr size_t expected_size = s0.size_bytes();
  105|  5.16k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  5.16k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanImLm1EEEEEmRKT_:
   59|  7.18k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  7.18k|   return std::span{r}.size_bytes();
   61|  7.18k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEEEEmRKT_:
   59|  4.05k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  4.05k|   return std::span{r}.size_bytes();
   61|  4.05k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEvRKT0_:
   77|  2.02k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.02k|   const std::span s{r};
   79|  2.02k|   if constexpr(statically_spanable_range<R>) {
   80|  2.02k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.02k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  2.02k|{
  101|  2.02k|   const std::span s0{r0};
  102|       |
  103|  2.02k|   if constexpr(statically_spanable_range<R0>) {
  104|  2.02k|      constexpr size_t expected_size = s0.size_bytes();
  105|  2.02k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  2.02k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm2ETkNS0_14spanable_rangeENSt3__14spanIKhLm2EEEEEvRKT0_:
   77|  15.7k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  15.7k|   const std::span s{r};
   79|  15.7k|   if constexpr(statically_spanable_range<R>) {
   80|  15.7k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  15.7k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanItLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm2EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  7.87k|{
  101|  7.87k|   const std::span s0{r0};
  102|       |
  103|  7.87k|   if constexpr(statically_spanable_range<R0>) {
  104|  7.87k|      constexpr size_t expected_size = s0.size_bytes();
  105|  7.87k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  7.87k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanItLm1EEEEEmRKT_:
   59|  7.87k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  7.87k|   return std::span{r}.size_bytes();
   61|  7.87k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeENSt3__14spanIKhLm4EEEEEvRKT0_:
   77|  2.84k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.84k|   const std::span s{r};
   79|  2.84k|   if constexpr(statically_spanable_range<R>) {
   80|  2.84k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.84k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIjLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm4EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  1.42k|{
  101|  1.42k|   const std::span s0{r0};
  102|       |
  103|  1.42k|   if constexpr(statically_spanable_range<R0>) {
  104|  1.42k|      constexpr size_t expected_size = s0.size_bytes();
  105|  1.42k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  1.42k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIjLm1EEEEEmRKT_:
   59|  1.42k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  1.42k|   return std::span{r}.size_bytes();
   61|  1.42k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__16vectorIhNS2_9allocatorIhEEEEEEmRKT_:
   59|   549k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|   549k|   return std::span{r}.size_bytes();
   61|   549k|}

_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
   54|   198k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIhE8allocateEm:
   52|   198k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorImE10deallocateEPmm:
   54|  2.27k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE8allocateEm:
   52|  2.27k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }

_ZN5Botan16wrap_strong_typeImRmQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  268|  7.18k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  269|  7.18k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  270|       |      // Noop, if the parameter type already is the desired return type.
  271|  7.18k|      return std::forward<ParamT>(t);
  272|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  273|       |      // Implicit conversion from the parameter type to the return type.
  274|       |      return T{std::forward<ParamT>(t)};
  275|       |   } else {
  276|       |      // Explicitly calling the wrapped type's constructor to support
  277|       |      // implicit conversions on types that mark their constructors as explicit.
  278|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  279|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  280|       |   }
  281|  7.18k|}
_ZN5Botan16wrap_strong_typeItRtQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  268|  7.87k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  269|  7.87k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  270|       |      // Noop, if the parameter type already is the desired return type.
  271|  7.87k|      return std::forward<ParamT>(t);
  272|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  273|       |      // Implicit conversion from the parameter type to the return type.
  274|       |      return T{std::forward<ParamT>(t)};
  275|       |   } else {
  276|       |      // Explicitly calling the wrapped type's constructor to support
  277|       |      // implicit conversions on types that mark their constructors as explicit.
  278|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  279|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  280|       |   }
  281|  7.87k|}
_ZN5Botan16wrap_strong_typeIjRjQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  268|  1.42k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  269|  1.42k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  270|       |      // Noop, if the parameter type already is the desired return type.
  271|  1.42k|      return std::forward<ParamT>(t);
  272|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  273|       |      // Implicit conversion from the parameter type to the return type.
  274|       |      return T{std::forward<ParamT>(t)};
  275|       |   } else {
  276|       |      // Explicitly calling the wrapped type's constructor to support
  277|       |      // implicit conversions on types that mark their constructors as explicit.
  278|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  279|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  280|       |   }
  281|  1.42k|}

_Z4fuzzNSt3__14spanIKhLm18446744073709551615EEE:
   40|  9.31k|void fuzz(std::span<const uint8_t> in) {
   41|  9.31k|   try {
   42|       |      /*
   43|       |      * Here we use an uninitialized ofstream so the fuzzer doesn't spend time
   44|       |      * on actual output formatting, no memory is allocated, etc.
   45|       |      */
   46|  9.31k|      std::ofstream out;
   47|  9.31k|      const ASN1_Parser printer;
   48|  9.31k|      printer.print_to_stream(out, in.data(), in.size());
   49|  9.31k|   } catch(const Botan::Exception& e) {}
   50|  9.31k|}
_ZN11ASN1_ParserC2Ev:
   15|  9.31k|      ASN1_Parser() : Botan::ASN1_Formatter(true, 64) {}
_ZNK11ASN1_Parser6formatEN5Botan9ASN1_TypeENS0_10ASN1_ClassEmmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   22|   156k|                         std::string_view value) const override {
   23|   156k|         BOTAN_UNUSED(type, klass, level, length, value);
  ------------------
  |  |  144|   156k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   24|   156k|         return "";
   25|   156k|      }
_ZNK11ASN1_Parser10format_binEN5Botan9ASN1_TypeENS0_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
   29|  21.8k|                             const std::vector<uint8_t>& value) const override {
   30|  21.8k|         BOTAN_UNUSED(type, klass, value);
  ------------------
  |  |  144|  21.8k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   31|  21.8k|         return "";
   32|  21.8k|      }
_ZNK11ASN1_Parser9format_bnERKN5Botan6BigIntE:
   34|  3.13k|      std::string format_bn(const Botan::BigInt& bn) const override {
   35|  3.13k|         BOTAN_UNUSED(bn);
  ------------------
  |  |  144|  3.13k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   36|  3.13k|         return "";
   37|  3.13k|      }

LLVMFuzzerInitialize:
   28|      2|extern "C" int LLVMFuzzerInitialize(int* /*argc*/, char*** /*argv*/) {
   29|       |   /*
   30|       |   * This disables the mlock pool, as overwrites within the pool are
   31|       |   * opaque to ASan or other instrumentation.
   32|       |   */
   33|      2|   ::setenv("BOTAN_MLOCK_POOL_SIZE", "0", 1);
   34|      2|   return 0;
   35|      2|}
LLVMFuzzerTestOneInput:
   39|  9.32k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t in[], size_t len) {
   40|  9.32k|   if(len <= max_fuzzer_input_size) {
  ------------------
  |  Branch (40:7): [True: 9.31k, False: 8]
  ------------------
   41|  9.31k|      try {
   42|  9.31k|         fuzz(std::span<const uint8_t>(in, len));
   43|  9.31k|      } catch(const std::exception& e) {
   44|      0|         std::cerr << "Uncaught exception from fuzzer driver " << e.what() << "\n";
   45|      0|         abort();
   46|      0|      } catch(...) {
   47|      0|         std::cerr << "Uncaught exception from fuzzer driver (unknown type)\n";
   48|      0|         abort();
   49|      0|      }
   50|  9.31k|   }
   51|  9.32k|   return 0;
   52|  9.32k|}

_ZN5Botan10BER_ObjectD2Ev:
   27|   549k|BER_Object::~BER_Object() {
   28|   549k|   secure_scrub_memory(m_value);
   29|   549k|}
_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   34|  24.8k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   35|  24.8k|   if(!this->is_a(expected_type_tag, expected_class_tag)) {
  ------------------
  |  Branch (35:7): [True: 1.45k, False: 23.4k]
  ------------------
   36|  1.45k|      std::stringstream msg;
   37|       |
   38|  1.45k|      msg << "Tag mismatch when decoding " << descr << " got ";
   39|       |
   40|  1.45k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (40:10): [True: 0, False: 1.45k]
  |  Branch (40:49): [True: 0, False: 0]
  ------------------
   41|      0|         msg << "EOF";
   42|  1.45k|      } else {
   43|  1.45k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (43:13): [True: 0, False: 1.45k]
  |  Branch (43:53): [True: 0, False: 1.45k]
  ------------------
   44|      0|            msg << asn1_tag_to_string(m_type_tag);
   45|  1.45k|         } else {
   46|  1.45k|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   47|  1.45k|         }
   48|       |
   49|  1.45k|         msg << "/" << asn1_class_to_string(m_class_tag);
   50|  1.45k|      }
   51|       |
   52|  1.45k|      msg << " expected ";
   53|       |
   54|  1.45k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (54:10): [True: 1.45k, False: 0]
  |  Branch (54:57): [True: 0, False: 0]
  ------------------
   55|  1.45k|         msg << asn1_tag_to_string(expected_type_tag);
   56|  1.45k|      } else {
   57|      0|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   58|      0|      }
   59|       |
   60|  1.45k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   61|       |
   62|  1.45k|      throw BER_Decoding_Error(msg.str());
   63|  1.45k|   }
   64|  24.8k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   66|  24.8k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   67|  24.8k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (67:12): [True: 24.8k, False: 0]
  |  Branch (67:47): [True: 23.4k, False: 1.45k]
  ------------------
   68|  24.8k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   74|   353k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   75|   353k|   m_type_tag = type_tag;
   76|   353k|   m_class_tag = class_tag;
   77|   353k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   79|  2.91k|std::string asn1_class_to_string(ASN1_Class type) {
   80|  2.91k|   switch(type) {
   81|  1.45k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (81:7): [True: 1.45k, False: 1.45k]
  ------------------
   82|  1.45k|         return "UNIVERSAL";
   83|      0|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (83:7): [True: 0, False: 2.91k]
  ------------------
   84|      0|         return "CONSTRUCTED";
   85|    380|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (85:7): [True: 380, False: 2.53k]
  ------------------
   86|    380|         return "CONTEXT_SPECIFIC";
   87|    556|      case ASN1_Class::Application:
  ------------------
  |  Branch (87:7): [True: 556, False: 2.35k]
  ------------------
   88|    556|         return "APPLICATION";
   89|    521|      case ASN1_Class::Private:
  ------------------
  |  Branch (89:7): [True: 521, False: 2.39k]
  ------------------
   90|    521|         return "PRIVATE";
   91|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (91:7): [True: 0, False: 2.91k]
  ------------------
   92|      0|         return "NO_OBJECT";
   93|      0|      default:
  ------------------
  |  Branch (93:7): [True: 0, False: 2.91k]
  ------------------
   94|      0|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   95|  2.91k|   }
   96|  2.91k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   98|  3.62k|std::string asn1_tag_to_string(ASN1_Type type) {
   99|  3.62k|   switch(type) {
  100|      0|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (100:7): [True: 0, False: 3.62k]
  ------------------
  101|      0|         return "SEQUENCE";
  102|       |
  103|      0|      case ASN1_Type::Set:
  ------------------
  |  Branch (103:7): [True: 0, False: 3.62k]
  ------------------
  104|      0|         return "SET";
  105|       |
  106|    197|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (106:7): [True: 197, False: 3.42k]
  ------------------
  107|    197|         return "PRINTABLE STRING";
  108|       |
  109|    261|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (109:7): [True: 261, False: 3.36k]
  ------------------
  110|    261|         return "NUMERIC STRING";
  111|       |
  112|    215|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (112:7): [True: 215, False: 3.41k]
  ------------------
  113|    215|         return "IA5 STRING";
  114|       |
  115|      0|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (115:7): [True: 0, False: 3.62k]
  ------------------
  116|      0|         return "T61 STRING";
  117|       |
  118|  1.29k|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (118:7): [True: 1.29k, False: 2.33k]
  ------------------
  119|  1.29k|         return "UTF8 STRING";
  120|       |
  121|    200|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (121:7): [True: 200, False: 3.42k]
  ------------------
  122|    200|         return "VISIBLE STRING";
  123|       |
  124|      0|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (124:7): [True: 0, False: 3.62k]
  ------------------
  125|      0|         return "BMP STRING";
  126|       |
  127|      0|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (127:7): [True: 0, False: 3.62k]
  ------------------
  128|      0|         return "UNIVERSAL STRING";
  129|       |
  130|      0|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (130:7): [True: 0, False: 3.62k]
  ------------------
  131|      0|         return "UTC TIME";
  132|       |
  133|      0|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (133:7): [True: 0, False: 3.62k]
  ------------------
  134|      0|         return "GENERALIZED TIME";
  135|       |
  136|    612|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (136:7): [True: 612, False: 3.01k]
  ------------------
  137|    612|         return "OCTET STRING";
  138|       |
  139|    845|      case ASN1_Type::BitString:
  ------------------
  |  Branch (139:7): [True: 845, False: 2.78k]
  ------------------
  140|    845|         return "BIT STRING";
  141|       |
  142|      0|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (142:7): [True: 0, False: 3.62k]
  ------------------
  143|      0|         return "ENUMERATED";
  144|       |
  145|      0|      case ASN1_Type::Integer:
  ------------------
  |  Branch (145:7): [True: 0, False: 3.62k]
  ------------------
  146|      0|         return "INTEGER";
  147|       |
  148|      0|      case ASN1_Type::Null:
  ------------------
  |  Branch (148:7): [True: 0, False: 3.62k]
  ------------------
  149|      0|         return "NULL";
  150|       |
  151|      0|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (151:7): [True: 0, False: 3.62k]
  ------------------
  152|      0|         return "OBJECT";
  153|       |
  154|      0|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (154:7): [True: 0, False: 3.62k]
  ------------------
  155|      0|         return "BOOLEAN";
  156|       |
  157|      0|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (157:7): [True: 0, False: 3.62k]
  ------------------
  158|      0|         return "NO_OBJECT";
  159|       |
  160|      0|      default:
  ------------------
  |  Branch (160:7): [True: 0, False: 3.62k]
  ------------------
  161|      0|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  162|  3.62k|   }
  163|  3.62k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  168|  16.0k|BER_Decoding_Error::BER_Decoding_Error(std::string_view err) : Decoding_Error(fmt("BER: {}", err)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  170|  3.90k|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  190|  9.38k|std::string to_string(const BER_Object& obj) {
  191|  9.38k|   return bytes_to_string(obj.data());
  192|  9.38k|}

_ZN5Botan3OIDC2ESt16initializer_listIjE:
  104|     22|OID::OID(std::initializer_list<uint32_t> init) : m_id(init) {
  105|     22|   oid_valid_check(m_id);
  106|     22|}
_ZNK5Botan3OID9to_stringEv:
  125|   115k|std::string OID::to_string() const {
  126|   115k|   std::ostringstream out;
  127|       |
  128|   771k|   for(size_t i = 0; i != m_id.size(); ++i) {
  ------------------
  |  Branch (128:22): [True: 656k, False: 115k]
  ------------------
  129|       |      // avoid locale issues with integer formatting
  130|   656k|      out << std::to_string(m_id[i]);
  131|   656k|      if(i != m_id.size() - 1) {
  ------------------
  |  Branch (131:10): [True: 541k, False: 115k]
  ------------------
  132|   541k|         out << ".";
  133|   541k|      }
  134|   656k|   }
  135|       |
  136|   115k|   return out.str();
  137|   115k|}
_ZNK5Botan3OID19human_name_or_emptyEv:
  147|   115k|std::string OID::human_name_or_empty() const {
  148|   115k|   return OID_Map::global_registry().oid2str(*this);
  149|   115k|}
_ZNK5Botan3OID7matchesESt16initializer_listIjE:
  155|   107k|bool OID::matches(std::initializer_list<uint32_t> other) const {
  156|       |   // TODO: once all target compilers support it, use std::ranges::equal
  157|   107k|   return std::equal(m_id.begin(), m_id.end(), other.begin(), other.end());
  158|   107k|}
_ZNK5Botan3OID9hash_codeEv:
  160|   187k|uint64_t OID::hash_code() const {
  161|       |   // If this is changed also update gen_oids.py to match
  162|   187k|   uint64_t hash = 0x621F302327D9A49A;
  163|  1.00M|   for(auto id : m_id) {
  ------------------
  |  Branch (163:16): [True: 1.00M, False: 187k]
  ------------------
  164|  1.00M|      hash *= 193;
  165|  1.00M|      hash += id;
  166|  1.00M|   }
  167|   187k|   return hash;
  168|   187k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  223|   116k|void OID::decode_from(BER_Decoder& decoder) {
  224|   116k|   const BER_Object obj = decoder.get_next_object();
  225|   116k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (225:7): [True: 0, False: 116k]
  ------------------
  226|      0|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  227|      0|   }
  228|       |
  229|   116k|   if(obj.length() == 0) {
  ------------------
  |  Branch (229:7): [True: 227, False: 115k]
  ------------------
  230|    227|      throw BER_Decoding_Error("OID encoding is too short");
  231|    227|   }
  232|       |
  233|   115k|   auto consume = [](BufferSlicer& data) -> uint32_t {
  234|   115k|      BOTAN_ASSERT_NOMSG(!data.empty());
  235|   115k|      uint32_t b = data.take_byte();
  236|       |
  237|   115k|      if(b > 0x7F) {
  238|   115k|         b &= 0x7F;
  239|       |
  240|       |         // Even BER requires that the OID have minimal length, ie that
  241|       |         // the first byte of a multibyte encoding cannot be zero
  242|       |         // See X.690 section 8.19.2
  243|   115k|         if(b == 0) {
  244|   115k|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  245|   115k|         }
  246|       |
  247|   115k|         while(true) {
  248|   115k|            if(data.empty()) {
  249|   115k|               throw Decoding_Error("Truncated OID value");
  250|   115k|            }
  251|       |
  252|   115k|            const uint8_t next = data.take_byte();
  253|   115k|            const bool more = (next & 0x80) == 0x80;
  254|   115k|            const uint8_t value = next & 0x7F;
  255|       |
  256|   115k|            if((b >> (32 - 7)) != 0) {
  257|   115k|               throw Decoding_Error("OID component overflow");
  258|   115k|            }
  259|       |
  260|   115k|            b = (b << 7) | value;
  261|       |
  262|   115k|            if(!more) {
  263|   115k|               break;
  264|   115k|            }
  265|   115k|         }
  266|   115k|      }
  267|       |
  268|   115k|      return b;
  269|   115k|   };
  270|       |
  271|   115k|   BufferSlicer data(obj.data());
  272|   115k|   std::vector<uint32_t> parts;
  273|   660k|   while(!data.empty()) {
  ------------------
  |  Branch (273:10): [True: 544k, False: 115k]
  ------------------
  274|   544k|      const uint32_t comp = consume(data);
  275|       |
  276|   544k|      if(parts.empty()) {
  ------------------
  |  Branch (276:10): [True: 115k, False: 429k]
  ------------------
  277|       |         // divide into root and second arc
  278|       |
  279|   115k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  280|   115k|            if(b0 < 40) {
  281|   115k|               return 0;
  282|   115k|            } else if(b0 < 80) {
  283|   115k|               return 1;
  284|   115k|            } else {
  285|   115k|               return 2;
  286|   115k|            }
  287|   115k|         }(comp);
  288|       |
  289|   115k|         parts.push_back(root_arc);
  290|   115k|         BOTAN_ASSERT_NOMSG(comp >= 40 * root_arc);
  ------------------
  |  |   77|   115k|   do {                                                                     \
  |  |   78|   115k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|   115k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 115k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|   115k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 115k]
  |  |  ------------------
  ------------------
  291|   115k|         parts.push_back(comp - 40 * root_arc);
  292|   429k|      } else {
  293|   429k|         parts.push_back(comp);
  294|   429k|      }
  295|   544k|   }
  296|       |
  297|   115k|   m_id = parts;
  298|   115k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_115oid_valid_checkENSt3__14spanIKjLm18446744073709551615EEE:
   26|     22|void oid_valid_check(std::span<const uint32_t> oid) {
   27|     22|   BOTAN_ARG_CHECK(oid.size() >= 2, "OID too short to be valid");
  ------------------
  |  |   35|     22|   do {                                                          \
  |  |   36|     22|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|     22|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 22]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|     22|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
   28|     22|   BOTAN_ARG_CHECK(oid[0] <= 2, "OID root out of range");
  ------------------
  |  |   35|     22|   do {                                                          \
  |  |   36|     22|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|     22|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 22]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|     22|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
   29|     22|   BOTAN_ARG_CHECK(oid[1] <= 39 || oid[0] == 2, "OID second arc too large");
  ------------------
  |  |   35|     22|   do {                                                          \
  |  |   36|     22|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|     22|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 22, False: 0]
  |  |  |  Branch (37:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|     22|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
   30|       |   // This last is a limitation of using 32 bit integers when decoding
   31|       |   // not a limitation of ASN.1 object identifiers in general
   32|     22|   BOTAN_ARG_CHECK(oid[1] <= 0xFFFFFFAF, "OID second arc too large");
  ------------------
  |  |   35|     22|   do {                                                          \
  |  |   36|     22|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|     22|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 22]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|     22|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
   33|     22|}
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_0clERNS_12BufferSlicerE:
  233|   544k|   auto consume = [](BufferSlicer& data) -> uint32_t {
  234|   544k|      BOTAN_ASSERT_NOMSG(!data.empty());
  ------------------
  |  |   77|   544k|   do {                                                                     \
  |  |   78|   544k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|   544k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 544k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|   544k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 544k]
  |  |  ------------------
  ------------------
  235|   544k|      uint32_t b = data.take_byte();
  236|       |
  237|   544k|      if(b > 0x7F) {
  ------------------
  |  Branch (237:10): [True: 66.0k, False: 478k]
  ------------------
  238|  66.0k|         b &= 0x7F;
  239|       |
  240|       |         // Even BER requires that the OID have minimal length, ie that
  241|       |         // the first byte of a multibyte encoding cannot be zero
  242|       |         // See X.690 section 8.19.2
  243|  66.0k|         if(b == 0) {
  ------------------
  |  Branch (243:13): [True: 263, False: 65.8k]
  ------------------
  244|    263|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  245|    263|         }
  246|       |
  247|  80.6k|         while(true) {
  ------------------
  |  Branch (247:16): [True: 80.6k, Folded]
  ------------------
  248|  80.6k|            if(data.empty()) {
  ------------------
  |  Branch (248:16): [True: 253, False: 80.4k]
  ------------------
  249|    253|               throw Decoding_Error("Truncated OID value");
  250|    253|            }
  251|       |
  252|  80.4k|            const uint8_t next = data.take_byte();
  253|  80.4k|            const bool more = (next & 0x80) == 0x80;
  254|  80.4k|            const uint8_t value = next & 0x7F;
  255|       |
  256|  80.4k|            if((b >> (32 - 7)) != 0) {
  ------------------
  |  Branch (256:16): [True: 256, False: 80.1k]
  ------------------
  257|    256|               throw Decoding_Error("OID component overflow");
  258|    256|            }
  259|       |
  260|  80.1k|            b = (b << 7) | value;
  261|       |
  262|  80.1k|            if(!more) {
  ------------------
  |  Branch (262:16): [True: 65.3k, False: 14.8k]
  ------------------
  263|  65.3k|               break;
  264|  65.3k|            }
  265|  80.1k|         }
  266|  65.8k|      }
  267|       |
  268|   543k|      return b;
  269|   544k|   };
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_1clEj:
  279|   115k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  280|   115k|            if(b0 < 40) {
  ------------------
  |  Branch (280:16): [True: 18.1k, False: 96.9k]
  ------------------
  281|  18.1k|               return 0;
  282|  96.9k|            } else if(b0 < 80) {
  ------------------
  |  Branch (282:23): [True: 36.4k, False: 60.5k]
  ------------------
  283|  36.4k|               return 1;
  284|  60.5k|            } else {
  285|  60.5k|               return 2;
  286|  60.5k|            }
  287|   115k|         }(comp);

_ZNK5Botan14ASN1_Formatter15print_to_streamERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKhm:
   84|  9.31k|void ASN1_Formatter::print_to_stream(std::ostream& output, const uint8_t in[], size_t len) const {
   85|  9.31k|   const auto decoder_limits = m_require_der ? BER_Decoder::Limits::DER() : BER_Decoder::Limits::BER();
  ------------------
  |  Branch (85:32): [True: 0, False: 9.31k]
  ------------------
   86|  9.31k|   BER_Decoder dec(std::span<const uint8_t>{in, len}, decoder_limits);
   87|  9.31k|   decode(output, dec, 0);
   88|  9.31k|}
_ZNK5Botan14ASN1_Formatter6decodeERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERNS_11BER_DecoderEm:
   90|  34.2k|void ASN1_Formatter::decode(std::ostream& output, BER_Decoder& decoder, size_t level) const {
   91|  34.2k|   BER_Object obj = decoder.get_next_object();
   92|       |
   93|  34.2k|   const bool recurse_deeper = (m_max_depth == 0 || level < m_max_depth);
  ------------------
  |  Branch (93:33): [True: 7.24k, False: 26.9k]
  |  Branch (93:53): [True: 26.9k, False: 0]
  ------------------
   94|       |
   95|   202k|   while(obj.is_set()) {
  ------------------
  |  Branch (95:10): [True: 168k, False: 34.2k]
  ------------------
   96|   168k|      const ASN1_Type type_tag = obj.type();
   97|   168k|      const ASN1_Class class_tag = obj.get_class();
   98|   168k|      const size_t length = obj.length();
   99|       |
  100|       |      /* hack to insert the tag+length back in front of the stuff now
  101|       |         that we've gotten the type info */
  102|   168k|      std::vector<uint8_t> bits;
  103|   168k|      DER_Encoder(bits).add_object(type_tag, class_tag, obj.bits(), obj.length());
  104|       |
  105|   168k|      BER_Decoder data(bits, decoder.limits());
  106|       |
  107|   168k|      if(intersects(class_tag, ASN1_Class::Constructed)) {
  ------------------
  |  Branch (107:10): [True: 6.25k, False: 162k]
  ------------------
  108|  6.25k|         BER_Decoder cons_info(obj, decoder.limits());
  109|       |
  110|  6.25k|         if(recurse_deeper) {
  ------------------
  |  Branch (110:13): [True: 6.25k, False: 0]
  ------------------
  111|  6.25k|            output << format(type_tag, class_tag, level, length, "");
  112|  6.25k|            decode(output, cons_info, level + 1);  // recurse
  113|  6.25k|         } else {
  114|      0|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, bits));
  115|      0|         }
  116|   162k|      } else if(intersects(class_tag, ASN1_Class::Application) || intersects(class_tag, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (116:17): [True: 2.67k, False: 159k]
  |  Branch (116:67): [True: 3.25k, False: 156k]
  ------------------
  117|  5.93k|         bool success_parsing_cs = false;
  118|       |
  119|  5.93k|         if(m_print_context_specific) {
  ------------------
  |  Branch (119:13): [True: 5.93k, False: 0]
  ------------------
  120|  5.93k|            try {
  121|  5.93k|               if(possibly_a_general_name(bits.data(), bits.size())) {
  ------------------
  |  Branch (121:19): [True: 573, False: 5.35k]
  ------------------
  122|    573|                  output << format(type_tag, class_tag, level, level, bytes_to_string(std::span{bits}.subspan(2)));
  123|    573|                  success_parsing_cs = true;
  124|  5.35k|               } else if(recurse_deeper) {
  ------------------
  |  Branch (124:26): [True: 5.35k, False: 0]
  ------------------
  125|  5.35k|                  std::vector<uint8_t> inner_bits;
  126|  5.35k|                  data.decode(inner_bits, type_tag);
  127|       |
  128|  5.35k|                  BER_Decoder inner(inner_bits, decoder.limits());
  129|  5.35k|                  std::ostringstream inner_data;
  130|  5.35k|                  decode(inner_data, inner, level + 1);  // recurse
  131|  5.35k|                  output << inner_data.str();
  132|  5.35k|                  success_parsing_cs = true;
  133|  5.35k|               }
  134|  5.93k|            } catch(...) {}
  135|  5.93k|         }
  136|       |
  137|  5.93k|         if(!success_parsing_cs) {
  ------------------
  |  Branch (137:13): [True: 5.35k, False: 573]
  ------------------
  138|  5.35k|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, bits));
  139|  5.35k|         }
  140|   156k|      } else if(type_tag == ASN1_Type::ObjectId) {
  ------------------
  |  Branch (140:17): [True: 116k, False: 40.1k]
  ------------------
  141|   116k|         OID oid;
  142|   116k|         data.decode(oid);
  143|       |
  144|   116k|         const std::string name = oid.human_name_or_empty();
  145|   116k|         const std::string oid_str = oid.to_string();
  146|       |
  147|   116k|         if(name.empty()) {
  ------------------
  |  Branch (147:13): [True: 72.2k, False: 43.8k]
  ------------------
  148|  72.2k|            output << format(type_tag, class_tag, level, length, oid_str);
  149|  72.2k|         } else {
  150|  43.8k|            output << format(type_tag, class_tag, level, length, fmt("{} [{}]", name, oid_str));
  151|  43.8k|         }
  152|   116k|      } else if(type_tag == ASN1_Type::Integer || type_tag == ASN1_Type::Enumerated) {
  ------------------
  |  Branch (152:17): [True: 2.40k, False: 37.7k]
  |  Branch (152:51): [True: 731, False: 36.9k]
  ------------------
  153|  3.13k|         BigInt number;
  154|       |
  155|  3.13k|         if(type_tag == ASN1_Type::Integer) {
  ------------------
  |  Branch (155:13): [True: 2.40k, False: 731]
  ------------------
  156|  2.40k|            data.decode(number);
  157|  2.40k|         } else if(type_tag == ASN1_Type::Enumerated) {
  ------------------
  |  Branch (157:20): [True: 731, False: 0]
  ------------------
  158|    731|            data.decode(number, ASN1_Type::Enumerated, class_tag);
  159|    731|         }
  160|       |
  161|  3.13k|         output << format(type_tag, class_tag, level, length, format_bn(number));
  162|  36.9k|      } else if(type_tag == ASN1_Type::Boolean) {
  ------------------
  |  Branch (162:17): [True: 998, False: 35.9k]
  ------------------
  163|    998|         bool boolean = false;
  164|    998|         data.decode(boolean);
  165|    998|         output << format(type_tag, class_tag, level, length, (boolean ? "true" : "false"));
  ------------------
  |  Branch (165:64): [True: 717, False: 281]
  ------------------
  166|  35.9k|      } else if(type_tag == ASN1_Type::Null) {
  ------------------
  |  Branch (166:17): [True: 730, False: 35.2k]
  ------------------
  167|    730|         output << format(type_tag, class_tag, level, length, "");
  168|  35.2k|      } else if(type_tag == ASN1_Type::OctetString || type_tag == ASN1_Type::BitString) {
  ------------------
  |  Branch (168:17): [True: 16.3k, False: 18.9k]
  |  Branch (168:55): [True: 2.99k, False: 15.9k]
  ------------------
  169|  19.2k|         std::vector<uint8_t> decoded_bits;
  170|  19.2k|         data.decode(decoded_bits, type_tag);
  171|  19.2k|         bool printing_octet_string_worked = false;
  172|       |
  173|  19.2k|         if(recurse_deeper) {
  ------------------
  |  Branch (173:13): [True: 18.6k, False: 659]
  ------------------
  174|  18.6k|            try {
  175|  18.6k|               BER_Decoder inner(decoded_bits, decoder.limits());
  176|       |
  177|  18.6k|               std::ostringstream inner_data;
  178|  18.6k|               decode(inner_data, inner, level + 1);  // recurse
  179|       |
  180|  18.6k|               output << format(type_tag, class_tag, level, length, "");
  181|  18.6k|               output << inner_data.str();
  182|  18.6k|               printing_octet_string_worked = true;
  183|  18.6k|            } catch(...) {}
  184|  18.6k|         }
  185|       |
  186|  19.2k|         if(!printing_octet_string_worked) {
  ------------------
  |  Branch (186:13): [True: 16.4k, False: 2.80k]
  ------------------
  187|  16.4k|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, decoded_bits));
  188|  16.4k|         }
  189|  19.2k|      } else if(ASN1_String::is_string_type(type_tag)) {
  ------------------
  |  Branch (189:17): [True: 8.19k, False: 7.77k]
  ------------------
  190|  8.19k|         ASN1_String str;
  191|  8.19k|         data.decode(str);
  192|  8.19k|         output << format(type_tag, class_tag, level, length, str.value());
  193|  8.19k|      } else if(type_tag == ASN1_Type::UtcTime || type_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (193:17): [True: 3.37k, False: 4.40k]
  |  Branch (193:51): [True: 1.16k, False: 3.23k]
  ------------------
  194|  4.54k|         ASN1_Time time;
  195|  4.54k|         data.decode(time);
  196|  4.54k|         output << format(type_tag, class_tag, level, length, time.readable_string());
  197|  4.54k|      } else {
  198|  3.23k|         output << "Unknown ASN.1 tag class=" << static_cast<int>(class_tag) << " type=" << static_cast<int>(type_tag)
  199|  3.23k|                << "\n";
  200|  3.23k|      }
  201|       |
  202|   168k|      obj = decoder.get_next_object();
  203|   168k|   }
  204|  34.2k|}
asn1_print.cpp:_ZN5Botan12_GLOBAL__N_123possibly_a_general_nameEPKhm:
   56|  5.93k|bool possibly_a_general_name(const uint8_t bits[], size_t bits_len) {
   57|  5.93k|   if(bits_len <= 2) {
  ------------------
  |  Branch (57:7): [True: 2.40k, False: 3.52k]
  ------------------
   58|  2.40k|      return false;
   59|  2.40k|   }
   60|       |
   61|  3.52k|   if(bits[0] != 0x82 && bits[0] != 0x86) {
  ------------------
  |  Branch (61:7): [True: 2.89k, False: 631]
  |  Branch (61:26): [True: 2.25k, False: 646]
  ------------------
   62|  2.25k|      return false;
   63|  2.25k|   }
   64|       |
   65|  1.27k|   if(bits[1] != bits_len - 2) {
  ------------------
  |  Branch (65:7): [True: 70, False: 1.20k]
  ------------------
   66|     70|      return false;
   67|     70|   }
   68|       |
   69|  1.20k|   if(!all_printable_chars(bits + 2, bits_len - 2)) {
  ------------------
  |  Branch (69:7): [True: 634, False: 573]
  ------------------
   70|    634|      return false;
   71|    634|   }
   72|       |
   73|    573|   return true;
   74|  1.20k|}
asn1_print.cpp:_ZN5Botan12_GLOBAL__N_119all_printable_charsEPKhm:
   44|  1.20k|bool all_printable_chars(const uint8_t bits[], size_t bits_len) {
   45|  9.61k|   for(size_t i = 0; i != bits_len; ++i) {
  ------------------
  |  Branch (45:22): [True: 9.04k, False: 573]
  ------------------
   46|  9.04k|      if(!is_printable_char(bits[i])) {
  ------------------
  |  Branch (46:10): [True: 634, False: 8.41k]
  ------------------
   47|    634|         return false;
   48|    634|      }
   49|  9.04k|   }
   50|    573|   return true;
   51|  1.20k|}
asn1_print.cpp:_ZN5Botan12_GLOBAL__N_117is_printable_charEc:
   24|  9.04k|bool is_printable_char(char c) {
   25|  9.04k|   if(c >= 'a' && c <= 'z') {
  ------------------
  |  Branch (25:7): [True: 2.10k, False: 6.93k]
  |  Branch (25:19): [True: 1.91k, False: 195]
  ------------------
   26|  1.91k|      return true;
   27|  1.91k|   }
   28|       |
   29|  7.13k|   if(c >= 'A' && c <= 'Z') {
  ------------------
  |  Branch (29:7): [True: 1.02k, False: 6.10k]
  |  Branch (29:19): [True: 762, False: 263]
  ------------------
   30|    762|      return true;
   31|    762|   }
   32|       |
   33|  6.37k|   if(c >= '0' && c <= '9') {
  ------------------
  |  Branch (33:7): [True: 1.48k, False: 4.88k]
  |  Branch (33:19): [True: 871, False: 611]
  ------------------
   34|    871|      return true;
   35|    871|   }
   36|       |
   37|  5.50k|   if(c == '.' || c == ':' || c == '/' || c == '-') {
  ------------------
  |  Branch (37:7): [True: 410, False: 5.09k]
  |  Branch (37:19): [True: 344, False: 4.74k]
  |  Branch (37:31): [True: 3.75k, False: 994]
  |  Branch (37:43): [True: 360, False: 634]
  ------------------
   38|  4.86k|      return true;
   39|  4.86k|   }
   40|       |
   41|    634|   return false;
   42|  5.50k|}

_ZN5Botan11ASN1_String14is_string_typeENS_9ASN1_TypeE:
  131|  15.9k|bool ASN1_String::is_string_type(ASN1_Type tag) {
  132|  15.9k|   return is_asn1_string_type(tag);
  133|  15.9k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  135|  8.19k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
  136|  8.19k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (136:7): [True: 0, False: 8.19k]
  ------------------
  137|      0|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
  138|      0|   }
  139|       |
  140|  8.19k|   if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (140:7): [True: 0, False: 8.19k]
  ------------------
  141|      0|      throw Invalid_Argument(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  142|      0|   }
  143|  8.19k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  145|  8.19k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
  162|  8.19k|void ASN1_String::decode_from(BER_Decoder& source) {
  163|  8.19k|   const BER_Object obj = source.get_next_object();
  164|       |
  165|  8.19k|   if(obj.get_class() != ASN1_Class::Universal || !is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (165:7): [True: 0, False: 8.19k]
  |  Branch (165:51): [True: 0, False: 8.19k]
  ------------------
  166|      0|      auto typ = static_cast<uint32_t>(obj.type());
  167|      0|      auto cls = static_cast<uint32_t>(obj.get_class());
  168|      0|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}/{}", typ, cls));
  169|      0|   }
  170|       |
  171|  8.19k|   m_tag = obj.type();
  172|  8.19k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
  173|       |
  174|  8.19k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (174:7): [True: 1.40k, False: 6.78k]
  ------------------
  175|  1.40k|      m_utf8_str = ucs2_to_utf8(m_data);
  176|  6.78k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (176:14): [True: 1.09k, False: 5.69k]
  ------------------
  177|  1.09k|      m_utf8_str = ucs4_to_utf8(m_data);
  178|  5.69k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (178:14): [True: 845, False: 4.84k]
  ------------------
  179|       |      /*
  180|       |      TeletexString is nominally ITU T.61 not ISO-8859-1 but it seems
  181|       |      the majority of implementations actually used that charset here.
  182|       |      */
  183|    845|      m_utf8_str = latin1_to_utf8(m_data);
  184|  4.84k|   } else {
  185|       |      // All other supported string types are UTF-8 or some subset thereof
  186|  4.84k|      m_utf8_str = ASN1::to_string(obj);
  187|       |
  188|  4.84k|      if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (188:10): [True: 2.16k, False: 2.67k]
  ------------------
  189|  2.16k|         throw Decoding_Error(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  190|  2.16k|      }
  191|  4.84k|   }
  192|  8.19k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   99|  24.1k|bool is_asn1_string_type(ASN1_Type tag) {
  100|  24.1k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (100:12): [True: 9.69k, False: 14.4k]
  |  Branch (100:47): [True: 1.69k, False: 12.7k]
  |  Branch (100:82): [True: 2.81k, False: 9.95k]
  ------------------
  101|  9.95k|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (101:12): [True: 2.18k, False: 7.77k]
  ------------------
  102|  24.1k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   94|  45.3k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   95|  45.3k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (95:12): [True: 1.57k, False: 43.8k]
  |  Branch (95:47): [True: 18.1k, False: 25.6k]
  |  Branch (95:84): [True: 1.95k, False: 23.6k]
  ------------------
   96|  23.6k|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (96:12): [True: 2.44k, False: 21.2k]
  |  Branch (96:43): [True: 6.76k, False: 14.4k]
  ------------------
   97|  45.3k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_128is_valid_asn1_string_contentERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_9ASN1_TypeE:
  104|  13.0k|bool is_valid_asn1_string_content(const std::string& str, ASN1_Type tag) {
  105|  13.0k|   BOTAN_ASSERT_NOMSG(is_utf8_subset_string_type(tag));
  ------------------
  |  |   77|  13.0k|   do {                                                                     \
  |  |   78|  13.0k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  13.0k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 13.0k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  13.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 13.0k]
  |  |  ------------------
  ------------------
  106|       |
  107|  13.0k|   switch(tag) {
  108|  2.25k|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (108:7): [True: 2.25k, False: 10.7k]
  ------------------
  109|  2.25k|         return is_valid_utf8(str);
  110|    526|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (110:7): [True: 526, False: 12.5k]
  ------------------
  111|  9.31k|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (111:7): [True: 8.79k, False: 4.24k]
  ------------------
  112|  10.1k|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (112:7): [True: 815, False: 12.2k]
  ------------------
  113|  10.7k|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (113:7): [True: 653, False: 12.3k]
  ------------------
  114|  10.7k|         return g_char_validator.valid_encoding(str, tag);
  115|      0|      default:
  ------------------
  |  Branch (115:7): [True: 0, False: 13.0k]
  ------------------
  116|      0|         return false;
  117|  13.0k|   }
  118|  13.0k|}
asn1_str.cpp:_ZNK5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator14valid_encodingENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_9ASN1_TypeE:
   25|  18.9k|      constexpr bool valid_encoding(std::string_view str, ASN1_Type tag) const {
   26|  18.9k|         const uint8_t mask = mask_for(tag);
   27|  18.9k|         for(const char c : str) {
  ------------------
  |  Branch (27:27): [True: 4.60k, False: 18.1k]
  ------------------
   28|  4.60k|            const uint8_t codepoint = static_cast<uint8_t>(c);
   29|  4.60k|            const bool is_valid = (m_table[codepoint] & mask) != 0;
   30|       |
   31|  4.60k|            if(!is_valid) {
  ------------------
  |  Branch (31:16): [True: 873, False: 3.73k]
  ------------------
   32|    873|               return false;
   33|    873|            }
   34|  4.60k|         }
   35|       |
   36|  18.1k|         return true;
   37|  18.9k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator8mask_forENS_9ASN1_TypeE:
   45|  18.9k|      static constexpr uint8_t mask_for(ASN1_Type tag) {
   46|  18.9k|         switch(tag) {
   47|    526|            case ASN1_Type::NumericString:
  ------------------
  |  Branch (47:13): [True: 526, False: 18.4k]
  ------------------
   48|    526|               return Numeric_String;
   49|  16.9k|            case ASN1_Type::PrintableString:
  ------------------
  |  Branch (49:13): [True: 16.9k, False: 1.99k]
  ------------------
   50|  16.9k|               return Printable_String;
   51|    815|            case ASN1_Type::Ia5String:
  ------------------
  |  Branch (51:13): [True: 815, False: 18.1k]
  ------------------
   52|    815|               return IA5_String;
   53|    653|            case ASN1_Type::VisibleString:
  ------------------
  |  Branch (53:13): [True: 653, False: 18.3k]
  ------------------
   54|    653|               return Visible_String;
   55|      0|            default:
  ------------------
  |  Branch (55:13): [True: 0, False: 18.9k]
  ------------------
   56|      0|               return 0;
   57|  18.9k|         }
   58|  18.9k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  120|  8.19k|ASN1_Type choose_encoding(std::string_view str) {
  121|  8.19k|   if(g_char_validator.valid_encoding(str, ASN1_Type::PrintableString)) {
  ------------------
  |  Branch (121:7): [True: 8.19k, False: 0]
  ------------------
  122|  8.19k|      return ASN1_Type::PrintableString;
  123|  8.19k|   } else {
  124|      0|      return ASN1_Type::Utf8String;
  125|      0|   }
  126|  8.19k|}

_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   59|  4.54k|void ASN1_Time::decode_from(BER_Decoder& source) {
   60|  4.54k|   const BER_Object ber_time = source.get_next_object();
   61|       |
   62|  4.54k|   if(ber_time.get_class() != ASN1_Class::Universal ||
  ------------------
  |  Branch (62:7): [True: 0, False: 4.54k]
  ------------------
   63|  4.54k|      (ber_time.type() != ASN1_Type::UtcTime && ber_time.type() != ASN1_Type::GeneralizedTime)) {
  ------------------
  |  Branch (63:8): [True: 1.16k, False: 3.37k]
  |  Branch (63:49): [True: 0, False: 1.16k]
  ------------------
   64|      0|      throw Decoding_Error(fmt("ASN1_Time: Unexpected tag {}/{}",
   65|      0|                               static_cast<uint32_t>(ber_time.type()),
   66|      0|                               static_cast<uint32_t>(ber_time.get_class())));
   67|      0|   }
   68|       |
   69|  4.54k|   try {
   70|  4.54k|      set_to(ASN1::to_string(ber_time), ber_time.type());
   71|  4.54k|   } catch(Invalid_Argument& e) {
   72|  3.58k|      throw Decoding_Error(fmt("Invalid ASN1_Time encoding: {}", e.what()));
   73|  3.58k|   }
   74|  4.54k|}
_ZNK5Botan9ASN1_Time15readable_stringEv:
  109|    958|std::string ASN1_Time::readable_string() const {
  110|    958|   if(!time_is_set()) {
  ------------------
  |  Branch (110:7): [True: 0, False: 958]
  ------------------
  111|      0|      throw Invalid_State("ASN1_Time::readable_string: No time set");
  112|      0|   }
  113|       |
  114|       |   // desired format: "%04d/%02d/%02d %02d:%02d:%02d UTC"
  115|    958|   std::stringstream output;
  116|    958|   output << std::setfill('0') << std::setw(4) << m_year << "/" << std::setw(2) << m_month << "/" << std::setw(2)
  117|    958|          << m_day << " " << std::setw(2) << m_hour << ":" << std::setw(2) << m_minute << ":" << std::setw(2)
  118|    958|          << m_second << " UTC";
  119|       |
  120|    958|   return output.str();
  121|    958|}
_ZNK5Botan9ASN1_Time11time_is_setEv:
  123|    958|bool ASN1_Time::time_is_set() const {
  124|    958|   return (m_year != 0);
  125|    958|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  176|  4.54k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  177|  4.54k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   35|  4.54k|   do {                                                          \
  |  |   36|  4.54k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  5.71k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 3.37k, False: 1.16k]
  |  |  |  Branch (37:12): [True: 1.16k, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  4.54k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 4.54k]
  |  |  ------------------
  ------------------
  178|  4.54k|                   "Invalid tag for ASN1_Time");
  179|       |
  180|  4.54k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (180:7): [True: 1.16k, False: 3.37k]
  ------------------
  181|  1.16k|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   35|  1.16k|   do {                                                          \
  |  |   36|  1.16k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  1.16k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 234, False: 935]
  |  |  ------------------
  |  |   38|    234|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|    234|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|    234|      }                                                          \
  |  |   41|  1.16k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 1.16k]
  |  |  ------------------
  ------------------
  182|  3.37k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (182:14): [True: 3.37k, False: 0]
  ------------------
  183|  3.37k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   35|  3.37k|   do {                                                          \
  |  |   36|  3.37k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  3.37k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 555, False: 2.81k]
  |  |  ------------------
  |  |   38|    555|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|    555|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|    555|      }                                                          \
  |  |   41|  3.37k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 3.37k]
  |  |  ------------------
  ------------------
  184|  3.37k|   }
  185|       |
  186|  4.54k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   35|  4.54k|   do {                                                          \
  |  |   36|  4.54k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  4.54k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 211, False: 4.33k]
  |  |  ------------------
  |  |   38|    211|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|    211|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|    211|      }                                                          \
  |  |   41|  4.54k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 4.54k]
  |  |  ------------------
  ------------------
  187|       |
  188|  4.54k|   const size_t field_len = 2;
  189|       |
  190|  4.54k|   const size_t year_start = 0;
  191|  4.54k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (191:28): [True: 2.60k, False: 1.93k]
  ------------------
  192|  4.54k|   const size_t month_start = year_start + year_len;
  193|  4.54k|   const size_t day_start = month_start + field_len;
  194|  4.54k|   const size_t hour_start = day_start + field_len;
  195|  4.54k|   const size_t min_start = hour_start + field_len;
  196|  4.54k|   const size_t sec_start = min_start + field_len;
  197|       |
  198|  4.54k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  199|  4.54k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  200|  4.54k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  201|  4.54k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  202|  4.54k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  203|  4.54k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  204|  4.54k|   m_tag = spec_tag;
  205|       |
  206|  4.54k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (206:7): [True: 2.31k, False: 2.22k]
  ------------------
  207|  2.31k|      if(m_year >= 50) {
  ------------------
  |  Branch (207:10): [True: 560, False: 1.75k]
  ------------------
  208|    560|         m_year += 1900;
  209|  1.75k|      } else {
  210|  1.75k|         m_year += 2000;
  211|  1.75k|      }
  212|  2.31k|   }
  213|       |
  214|  4.54k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (214:7): [True: 2.04k, False: 2.49k]
  ------------------
  215|  2.04k|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  216|  2.04k|   }
  217|  4.54k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  222|  3.00k|bool ASN1_Time::passes_sanity_check() const {
  223|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  224|  3.00k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (224:7): [True: 343, False: 2.65k]
  |  Branch (224:24): [True: 71, False: 2.58k]
  ------------------
  225|    414|      return false;
  226|    414|   }
  227|  2.58k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (227:7): [True: 195, False: 2.39k]
  |  Branch (227:23): [True: 90, False: 2.30k]
  ------------------
  228|    285|      return false;
  229|    285|   }
  230|       |
  231|  2.30k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  232|       |
  233|  2.30k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (233:7): [True: 198, False: 2.10k]
  |  Branch (233:21): [True: 209, False: 1.89k]
  ------------------
  234|    407|      return false;
  235|    407|   }
  236|       |
  237|  1.89k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (237:7): [True: 1.11k, False: 785]
  |  Branch (237:23): [True: 664, False: 446]
  ------------------
  238|    664|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (238:10): [True: 66, False: 598]
  ------------------
  239|     66|         return false;  // not a leap year
  240|     66|      }
  241|       |
  242|    598|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (242:10): [True: 328, False: 270]
  |  Branch (242:31): [True: 194, False: 134]
  ------------------
  243|    194|         return false;
  244|    194|      }
  245|    598|   }
  246|       |
  247|  1.63k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (247:7): [True: 203, False: 1.43k]
  |  Branch (247:23): [True: 68, False: 1.36k]
  |  Branch (247:41): [True: 197, False: 1.16k]
  ------------------
  248|    468|      return false;
  249|    468|   }
  250|       |
  251|  1.16k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (251:7): [True: 1.09k, False: 71]
  ------------------
  252|       |      /*
  253|       |      UTCTime limits the value of components such that leap seconds
  254|       |      are not covered. See "UNIVERSAL 23" in "Information technology
  255|       |      Abstract Syntax Notation One (ASN.1): Specification of basic notation"
  256|       |
  257|       |      http://www.itu.int/ITU-T/studygroups/com17/languages/
  258|       |      */
  259|  1.09k|      if(m_second > 59) {
  ------------------
  |  Branch (259:10): [True: 209, False: 887]
  ------------------
  260|    209|         return false;
  261|    209|      }
  262|  1.09k|   }
  263|       |
  264|    958|   return true;
  265|  1.16k|}

_ZN5Botan11BER_DecoderD2Ev:
  366|   202k|BER_Decoder::~BER_Decoder() = default;
_ZN5Botan11BER_Decoder15get_next_objectEv:
  426|   346k|BER_Object BER_Decoder::get_next_object() {
  427|   346k|   BER_Object next;
  428|       |
  429|   346k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (429:7): [True: 0, False: 346k]
  ------------------
  430|      0|      std::swap(next, m_pushed);
  431|      0|      return next;
  432|      0|   }
  433|       |
  434|   354k|   for(;;) {
  435|   354k|      ASN1_Type type_tag = ASN1_Type::NoObject;
  436|   354k|      ASN1_Class class_tag = ASN1_Class::NoObject;
  437|   354k|      decode_tag(m_source, type_tag, class_tag);
  438|   354k|      next.set_tagging(type_tag, class_tag);
  439|   354k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (439:10): [True: 14.9k, False: 339k]
  ------------------
  440|  14.9k|         return next;
  441|  14.9k|      }
  442|       |
  443|   339k|      const size_t allow_indef = m_limits.allow_ber_encoding() ? m_limits.max_nested_indefinite_length() : 0;
  ------------------
  |  Branch (443:34): [True: 338k, False: 1.23k]
  ------------------
  444|   339k|      const bool der_mode = m_limits.require_der_encoding();
  445|   339k|      const auto dl = decode_length(m_source, allow_indef, der_mode, is_constructed(class_tag));
  446|       |
  447|       |      // Per X.690 8.1.5 the only valid EOC encoding is the two-octet
  448|       |      // sequence 0x00 0x00. Reject any other length encoding on a tag of
  449|       |      // (Eoc, Universal) before we consume the "content" bytes.
  450|   339k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal &&
  ------------------
  |  Branch (450:10): [True: 9.60k, False: 330k]
  |  Branch (450:40): [True: 8.56k, False: 1.03k]
  ------------------
  451|  8.56k|         (dl.content_length() != 0 || dl.indefinite_length())) {
  ------------------
  |  Branch (451:11): [True: 415, False: 8.14k]
  |  Branch (451:39): [True: 0, False: 8.14k]
  ------------------
  452|    415|         throw BER_Decoding_Error("EOC marker with non-zero length");
  453|    415|      }
  454|       |
  455|   339k|      if(!m_source->check_available(dl.total_length())) {
  ------------------
  |  Branch (455:10): [True: 2.28k, False: 337k]
  ------------------
  456|  2.28k|         throw BER_Decoding_Error("Value truncated");
  457|  2.28k|      }
  458|       |
  459|   337k|      uint8_t* out = next.mutable_bits(dl.content_length());
  460|   337k|      if(m_source->read(out, dl.content_length()) != dl.content_length()) {
  ------------------
  |  Branch (460:10): [True: 0, False: 337k]
  ------------------
  461|      0|         throw BER_Decoding_Error("Value truncated");
  462|      0|      }
  463|       |
  464|   337k|      if(dl.indefinite_length()) {
  ------------------
  |  Branch (464:10): [True: 2.04k, False: 335k]
  ------------------
  465|       |         // After reading the data consume the 2-byte EOC
  466|  2.04k|         uint8_t eoc[2] = {0xFF, 0xFF};
  467|  2.04k|         if(m_source->read(eoc, 2) != 2 || eoc[0] != 0x00 || eoc[1] != 0x00) {
  ------------------
  |  Branch (467:13): [True: 0, False: 2.04k]
  |  Branch (467:44): [True: 0, False: 2.04k]
  |  Branch (467:62): [True: 0, False: 2.04k]
  ------------------
  468|      0|            throw BER_Decoding_Error("Missing or malformed EOC marker");
  469|      0|         }
  470|  2.04k|      }
  471|       |
  472|   337k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (472:10): [True: 8.14k, False: 328k]
  ------------------
  473|  8.14k|         if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (473:13): [True: 0, False: 8.14k]
  ------------------
  474|      0|            throw BER_Decoding_Error("Detected EOC marker in DER structure");
  475|      0|         }
  476|  8.14k|         continue;
  477|   328k|      } else {
  478|   328k|         break;
  479|   328k|      }
  480|   337k|   }
  481|       |
  482|   328k|   return next;
  483|   346k|}
_ZN5Botan11BER_DecoderC2ENSt3__14spanIKhLm18446744073709551615EEENS0_6LimitsE:
  548|   202k|BER_Decoder::BER_Decoder(std::span<const uint8_t> buf, Limits limits) : m_limits(limits) {
  549|   202k|   m_data_src = std::make_unique<DataSource_Memory>(buf);
  550|   202k|   m_source = m_data_src.get();
  551|   202k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  560|   128k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  561|   128k|   obj.decode_from(*this);
  562|   128k|   return (*this);
  563|   128k|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  587|    998|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  588|    998|   const BER_Object obj = get_next_object();
  589|    998|   obj.assert_is_a(type_tag, class_tag);
  590|       |
  591|    998|   if(obj.length() != 1) {
  ------------------
  |  Branch (591:7): [True: 274, False: 724]
  ------------------
  592|    274|      throw BER_Decoding_Error("BER boolean value had invalid size");
  593|    274|   }
  594|       |
  595|    724|   const uint8_t val = obj.bits()[0];
  596|       |
  597|       |   // DER requires boolean values to be exactly 0x00 or 0xFF
  598|    724|   if(m_limits.require_der_encoding() && val != 0x00 && val != 0xFF) {
  ------------------
  |  Branch (598:7): [True: 0, False: 724]
  |  Branch (598:42): [True: 0, False: 0]
  |  Branch (598:57): [True: 0, False: 0]
  ------------------
  599|      0|      throw BER_Decoding_Error("Detected non-canonical boolean encoding in DER structure");
  600|      0|   }
  601|       |
  602|    724|   out = (val != 0) ? true : false;
  ------------------
  |  Branch (602:10): [True: 717, False: 7]
  ------------------
  603|       |
  604|    724|   return (*this);
  605|    724|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  660|  3.13k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  661|  3.13k|   const BER_Object obj = get_next_object();
  662|  3.13k|   obj.assert_is_a(type_tag, class_tag);
  663|       |
  664|       |   // DER requires minimal INTEGER encoding (X.690 section 8.3.2)
  665|  3.13k|   if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (665:7): [True: 0, False: 3.13k]
  ------------------
  666|      0|      if(obj.length() == 0) {
  ------------------
  |  Branch (666:10): [True: 0, False: 0]
  ------------------
  667|      0|         throw BER_Decoding_Error("Detected empty INTEGER encoding in DER structure");
  668|      0|      }
  669|      0|      if(obj.length() > 1) {
  ------------------
  |  Branch (669:10): [True: 0, False: 0]
  ------------------
  670|      0|         if(obj.bits()[0] == 0x00 && (obj.bits()[1] & 0x80) == 0) {
  ------------------
  |  Branch (670:13): [True: 0, False: 0]
  |  Branch (670:38): [True: 0, False: 0]
  ------------------
  671|      0|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  672|      0|         }
  673|      0|         if(obj.bits()[0] == 0xFF && (obj.bits()[1] & 0x80) != 0) {
  ------------------
  |  Branch (673:13): [True: 0, False: 0]
  |  Branch (673:38): [True: 0, False: 0]
  ------------------
  674|      0|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  675|      0|         }
  676|      0|      }
  677|      0|   }
  678|       |
  679|  3.13k|   if(obj.length() == 0) {
  ------------------
  |  Branch (679:7): [True: 868, False: 2.27k]
  ------------------
  680|    868|      out.clear();
  681|  2.27k|   } else {
  682|  2.27k|      const uint8_t first = obj.bits()[0];
  683|  2.27k|      const bool negative = (first & 0x80) == 0x80;
  684|       |
  685|  2.27k|      if(negative) {
  ------------------
  |  Branch (685:10): [True: 739, False: 1.53k]
  ------------------
  686|    739|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  687|  1.12k|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (687:39): [True: 1.12k, False: 0]
  ------------------
  688|  1.12k|            const bool gt0 = (vec[i - 1] > 0);
  689|  1.12k|            vec[i - 1] -= 1;
  690|  1.12k|            if(gt0) {
  ------------------
  |  Branch (690:16): [True: 739, False: 382]
  ------------------
  691|    739|               break;
  692|    739|            }
  693|  1.12k|         }
  694|  23.9k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (694:28): [True: 23.1k, False: 739]
  ------------------
  695|  23.1k|            vec[i] = ~vec[i];
  696|  23.1k|         }
  697|    739|         out._assign_from_bytes(vec);
  698|    739|         out.flip_sign();
  699|  1.53k|      } else {
  700|  1.53k|         out._assign_from_bytes(obj.data());
  701|  1.53k|      }
  702|  2.27k|   }
  703|       |
  704|  3.13k|   return (*this);
  705|  3.13k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  782|  24.6k|                                 ASN1_Class class_tag) {
  783|  24.6k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (783:7): [True: 7.74k, False: 16.9k]
  |  Branch (783:46): [True: 3.90k, False: 3.84k]
  ------------------
  784|  3.90k|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  785|  3.90k|   }
  786|       |
  787|  20.7k|   asn1_decode_binary_string(
  788|  20.7k|      buffer, get_next_object(), real_type, type_tag, class_tag, m_limits.require_der_encoding());
  789|  20.7k|   return (*this);
  790|  24.6k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   27|   354k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   28|   354k|   auto b = ber->read_byte();
   29|       |
   30|   354k|   if(!b) {
  ------------------
  |  Branch (30:7): [True: 14.9k, False: 339k]
  ------------------
   31|  14.9k|      type_tag = ASN1_Type::NoObject;
   32|  14.9k|      class_tag = ASN1_Class::NoObject;
   33|  14.9k|      return 0;
   34|  14.9k|   }
   35|       |
   36|   339k|   if((*b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (36:7): [True: 335k, False: 4.05k]
  ------------------
   37|   335k|      type_tag = ASN1_Type(*b & 0x1F);
   38|   335k|      class_tag = ASN1_Class(*b & 0xE0);
   39|   335k|      return 1;
   40|   335k|   }
   41|       |
   42|  4.05k|   size_t tag_bytes = 1;
   43|  4.05k|   class_tag = ASN1_Class(*b & 0xE0);
   44|       |
   45|  4.05k|   uint32_t tag_buf = 0;
   46|  8.79k|   while(true) {
  ------------------
  |  Branch (46:10): [True: 8.79k, Folded]
  ------------------
   47|  8.79k|      b = ber->read_byte();
   48|  8.79k|      if(!b) {
  ------------------
  |  Branch (48:10): [True: 424, False: 8.37k]
  ------------------
   49|    424|         throw BER_Decoding_Error("Long-form tag truncated");
   50|    424|      }
   51|  8.37k|      if((tag_buf >> 24) != 0) {
  ------------------
  |  Branch (51:10): [True: 205, False: 8.16k]
  ------------------
   52|    205|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|    205|      }
   54|       |      // This is required even by BER (see X.690 section 8.1.2.4.2 sentence c).
   55|       |      // Bits 7-1 of the first subsequent octet must not be all zero; this rules
   56|       |      // out both 0x80 (continuation with no data) and 0x00 (a long-form encoding
   57|       |      // of tag value 0, which collides with the EOC marker).
   58|  8.16k|      if(tag_bytes == 1 && (*b & 0x7F) == 0) {
  ------------------
  |  Branch (58:10): [True: 3.71k, False: 4.45k]
  |  Branch (58:28): [True: 226, False: 3.49k]
  ------------------
   59|    226|         throw BER_Decoding_Error("Long form tag with leading zero");
   60|    226|      }
   61|  7.94k|      ++tag_bytes;
   62|  7.94k|      tag_buf = (tag_buf << 7) | (*b & 0x7F);
   63|  7.94k|      if((*b & 0x80) == 0) {
  ------------------
  |  Branch (63:10): [True: 3.19k, False: 4.74k]
  ------------------
   64|  3.19k|         break;
   65|  3.19k|      }
   66|  7.94k|   }
   67|       |   // Per X.690 8.1.2.2, tag values 0-30 shall be encoded in the short form.
   68|       |   // Long-form encoding is reserved for tag values >= 31 (X.690 8.1.2.3).
   69|       |   // This is unconditional and applies to BER as well as DER.
   70|  3.19k|   if(tag_buf <= 30) {
  ------------------
  |  Branch (70:7): [True: 319, False: 2.88k]
  ------------------
   71|    319|      throw BER_Decoding_Error("Long-form tag encoding used for small tag value");
   72|    319|   }
   73|       |
   74|  2.88k|   if(tag_buf == static_cast<uint32_t>(ASN1_Type::NoObject)) {
  ------------------
  |  Branch (74:7): [True: 63, False: 2.81k]
  ------------------
   75|     63|      throw BER_Decoding_Error("Tag value collides with internal sentinel");
   76|     63|   }
   77|       |
   78|       |   // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
   79|  2.81k|   type_tag = ASN1_Type(tag_buf);
   80|  2.81k|   return tag_bytes;
   81|  2.88k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceEmbb:
  126|   338k|BerDecodedLength decode_length(DataSource* ber, size_t allow_indef, bool der_mode, bool constructed) {
  127|   338k|   uint8_t b = 0;
  128|   338k|   if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (128:7): [True: 1.79k, False: 336k]
  ------------------
  129|  1.79k|      throw BER_Decoding_Error("Length field not found");
  130|  1.79k|   }
  131|   336k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (131:7): [True: 330k, False: 6.68k]
  ------------------
  132|   330k|      return BerDecodedLength(b, 1);
  133|   330k|   }
  134|       |
  135|  6.68k|   const size_t num_length_bytes = (b & 0x7F);
  136|  6.68k|   if(num_length_bytes > 4) {
  ------------------
  |  Branch (136:7): [True: 446, False: 6.23k]
  ------------------
  137|    446|      throw BER_Decoding_Error("Length field is too large");
  138|    446|   }
  139|       |
  140|  6.23k|   const size_t field_size = 1 + num_length_bytes;
  141|       |
  142|  6.23k|   if(num_length_bytes == 0) {
  ------------------
  |  Branch (142:7): [True: 5.20k, False: 1.03k]
  ------------------
  143|  5.20k|      if(der_mode) {
  ------------------
  |  Branch (143:10): [True: 0, False: 5.20k]
  ------------------
  144|      0|         throw BER_Decoding_Error("Detected indefinite-length encoding in DER structure");
  145|  5.20k|      } else if(!constructed) {
  ------------------
  |  Branch (145:17): [True: 247, False: 4.95k]
  ------------------
  146|       |         // Indefinite length is only valid for constructed types (X.690 8.1.3.2)
  147|    247|         throw BER_Decoding_Error("Indefinite-length encoding used with non-constructed type");
  148|  4.95k|      } else if(allow_indef == 0) {
  ------------------
  |  Branch (148:17): [True: 0, False: 4.95k]
  ------------------
  149|      0|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
  150|  4.95k|      } else {
  151|       |         // find_eoc returns bytes up to and including the EOC marker.
  152|       |         // Return the content length; the caller consumes the EOC separately.
  153|  4.95k|         const size_t eoc_len = find_eoc(ber, /*base_offset=*/0, allow_indef - 1);
  154|  4.95k|         if(eoc_len < 2) {
  ------------------
  |  Branch (154:13): [True: 0, False: 4.95k]
  ------------------
  155|      0|            throw BER_Decoding_Error("Invalid EOC encoding");
  156|      0|         }
  157|  4.95k|         return BerDecodedLength::indefinite(eoc_len - 2, field_size);
  158|  4.95k|      }
  159|  5.20k|   }
  160|       |
  161|  1.03k|   size_t length = 0;
  162|       |
  163|  3.25k|   for(size_t i = 0; i != num_length_bytes; ++i) {
  ------------------
  |  Branch (163:22): [True: 2.43k, False: 823]
  ------------------
  164|  2.43k|      if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (164:10): [True: 211, False: 2.22k]
  ------------------
  165|    211|         throw BER_Decoding_Error("Corrupted length field");
  166|    211|      }
  167|       |      // Can't overflow since we already checked that num_length_bytes <= 4
  168|  2.22k|      length = (length << 8) | b;
  169|  2.22k|   }
  170|       |
  171|       |   // DER requires shortest possible length encoding
  172|    823|   if(der_mode) {
  ------------------
  |  Branch (172:7): [True: 0, False: 823]
  ------------------
  173|      0|      if(length < 128) {
  ------------------
  |  Branch (173:10): [True: 0, False: 0]
  ------------------
  174|      0|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  175|      0|      }
  176|      0|      if(num_length_bytes > 1 && length < (size_t(1) << ((num_length_bytes - 1) * 8))) {
  ------------------
  |  Branch (176:10): [True: 0, False: 0]
  |  Branch (176:34): [True: 0, False: 0]
  ------------------
  177|      0|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  178|      0|      }
  179|      0|   }
  180|       |
  181|    823|   return BerDecodedLength(length, field_size);
  182|    823|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emm:
   99|   330k|            BerDecodedLength(content_length, field_length, false) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emmb:
  116|   332k|            m_content_length(content_length), m_field_length(field_length), m_indefinite(indefinite) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEmm:
  293|  14.9k|size_t find_eoc(DataSource* src, size_t base_offset, size_t allow_indef) {
  294|  14.9k|   size_t offset = base_offset;
  295|       |
  296|  39.3k|   while(true) {
  ------------------
  |  Branch (296:10): [True: 39.3k, Folded]
  ------------------
  297|  39.3k|      ASN1_Type type_tag = ASN1_Type::NoObject;
  298|  39.3k|      ASN1_Class class_tag = ASN1_Class::NoObject;
  299|  39.3k|      const size_t tag_size = peek_tag(src, offset, type_tag, class_tag);
  300|  39.3k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (300:10): [True: 378, False: 38.9k]
  ------------------
  301|    378|         throw BER_Decoding_Error("Missing EOC marker in indefinite-length encoding");
  302|    378|      }
  303|       |
  304|  38.9k|      size_t length_size = 0;
  305|  38.9k|      const size_t item_size = peek_length(src, offset + tag_size, length_size, allow_indef, is_constructed(class_tag));
  306|       |
  307|  38.9k|      if(auto new_offset = checked_add(offset, tag_size, length_size, item_size)) {
  ------------------
  |  Branch (307:15): [True: 36.5k, False: 2.44k]
  ------------------
  308|  36.5k|         offset = new_offset.value();
  309|  36.5k|      } else {
  310|  2.44k|         throw Decoding_Error("Integer overflow while scanning for EOC");
  311|  2.44k|      }
  312|       |
  313|  36.5k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (313:10): [True: 13.0k, False: 23.4k]
  |  Branch (313:40): [True: 12.1k, False: 912]
  ------------------
  314|       |         // Per X.690 8.1.5 the EOC marker is exactly two zero octets
  315|  12.1k|         if(length_size != 1 || item_size != 0) {
  ------------------
  |  Branch (315:13): [True: 85, False: 12.0k]
  |  Branch (315:33): [True: 262, False: 11.7k]
  ------------------
  316|    347|            throw BER_Decoding_Error("EOC marker with non-zero length");
  317|    347|         }
  318|  11.7k|         break;
  319|  12.1k|      }
  320|  36.5k|   }
  321|       |
  322|  11.7k|   return offset - base_offset;
  323|  14.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18peek_tagEPNS_10DataSourceEmRNS_9ASN1_TypeERNS_10ASN1_ClassE:
  188|  39.3k|size_t peek_tag(DataSource* src, size_t offset, ASN1_Type& type_tag, ASN1_Class& class_tag) {
  189|  39.3k|   uint8_t b = 0;
  190|  39.3k|   if(src->peek(&b, 1, offset) == 0) {
  ------------------
  |  Branch (190:7): [True: 378, False: 38.9k]
  ------------------
  191|    378|      type_tag = ASN1_Type::NoObject;
  192|    378|      class_tag = ASN1_Class::NoObject;
  193|    378|      return 0;
  194|    378|   }
  195|       |
  196|  38.9k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (196:7): [True: 32.7k, False: 6.24k]
  ------------------
  197|  32.7k|      type_tag = ASN1_Type(b & 0x1F);
  198|  32.7k|      class_tag = ASN1_Class(b & 0xE0);
  199|  32.7k|      return 1;
  200|  32.7k|   }
  201|       |
  202|  6.24k|   class_tag = ASN1_Class(b & 0xE0);
  203|  6.24k|   size_t tag_bytes = 1;
  204|  6.24k|   uint32_t tag_buf = 0;
  205|       |
  206|  12.8k|   while(true) {
  ------------------
  |  Branch (206:10): [True: 12.8k, Folded]
  ------------------
  207|  12.8k|      if(src->peek(&b, 1, offset + tag_bytes) == 0) {
  ------------------
  |  Branch (207:10): [True: 366, False: 12.4k]
  ------------------
  208|    366|         throw BER_Decoding_Error("Long-form tag truncated");
  209|    366|      }
  210|  12.4k|      if((tag_buf >> 24) != 0) {
  ------------------
  |  Branch (210:10): [True: 214, False: 12.2k]
  ------------------
  211|    214|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
  212|    214|      }
  213|       |      // Required even by BER (X.690 section 8.1.2.4.2 sentence c).
  214|       |      // Bits 7-1 of the first subsequent octet must not be all zero; this rules
  215|       |      // out both 0x80 (continuation with no data) and 0x00 (a long-form encoding
  216|       |      // of tag value 0, which collides with the EOC marker).
  217|  12.2k|      if(tag_bytes == 1 && (b & 0x7F) == 0) {
  ------------------
  |  Branch (217:10): [True: 5.94k, False: 6.30k]
  |  Branch (217:28): [True: 204, False: 5.73k]
  ------------------
  218|    204|         throw BER_Decoding_Error("Long form tag with leading zero");
  219|    204|      }
  220|  12.0k|      ++tag_bytes;
  221|  12.0k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
  222|  12.0k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (222:10): [True: 5.46k, False: 6.57k]
  ------------------
  223|  5.46k|         break;
  224|  5.46k|      }
  225|  12.0k|   }
  226|       |
  227|       |   // Per X.690 8.1.2.2, tag values 0-30 shall be encoded in the short form.
  228|       |   // Long-form encoding is reserved for tag values >= 31 (X.690 8.1.2.3).
  229|       |   // This is unconditional and applies to BER as well as DER.
  230|  5.46k|   if(tag_buf <= 30) {
  ------------------
  |  Branch (230:7): [True: 199, False: 5.26k]
  ------------------
  231|    199|      throw BER_Decoding_Error("Long-form tag encoding used for small tag value");
  232|    199|   }
  233|       |
  234|  5.26k|   if(tag_buf == static_cast<uint32_t>(ASN1_Type::NoObject)) {
  ------------------
  |  Branch (234:7): [True: 220, False: 5.04k]
  ------------------
  235|    220|      throw BER_Decoding_Error("Tag value collides with internal sentinel");
  236|    220|   }
  237|       |
  238|       |   // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
  239|  5.04k|   type_tag = ASN1_Type(tag_buf);
  240|  5.04k|   return tag_bytes;
  241|  5.26k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_111peek_lengthEPNS_10DataSourceEmRmmb:
  248|  37.7k|size_t peek_length(DataSource* src, size_t offset, size_t& field_size, size_t allow_indef, bool constructed) {
  249|  37.7k|   uint8_t b = 0;
  250|  37.7k|   if(src->peek(&b, 1, offset) == 0) {
  ------------------
  |  Branch (250:7): [True: 294, False: 37.4k]
  ------------------
  251|    294|      throw BER_Decoding_Error("Length field not found");
  252|    294|   }
  253|       |
  254|  37.4k|   field_size = 1;
  255|  37.4k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (255:7): [True: 25.0k, False: 12.4k]
  ------------------
  256|  25.0k|      return b;
  257|  25.0k|   }
  258|       |
  259|  12.4k|   const size_t num_length_bytes = (b & 0x7F);
  260|  12.4k|   field_size += num_length_bytes;
  261|  12.4k|   if(field_size > 5) {
  ------------------
  |  Branch (261:7): [True: 281, False: 12.1k]
  ------------------
  262|    281|      throw BER_Decoding_Error("Length field is too large");
  263|    281|   }
  264|       |
  265|  12.1k|   if(num_length_bytes == 0) {
  ------------------
  |  Branch (265:7): [True: 10.1k, False: 1.98k]
  ------------------
  266|       |      // Indefinite length is only valid for constructed types (X.690 8.1.3.2)
  267|  10.1k|      if(!constructed) {
  ------------------
  |  Branch (267:10): [True: 194, False: 9.98k]
  ------------------
  268|    194|         throw BER_Decoding_Error("Indefinite-length encoding used with non-constructed type");
  269|    194|      }
  270|  9.98k|      if(allow_indef == 0) {
  ------------------
  |  Branch (270:10): [True: 10, False: 9.97k]
  ------------------
  271|     10|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
  272|     10|      }
  273|  9.97k|      return find_eoc(src, offset + 1, allow_indef - 1);
  274|  9.98k|   }
  275|       |
  276|  1.98k|   size_t length = 0;
  277|  5.48k|   for(size_t i = 0; i < num_length_bytes; ++i) {
  ------------------
  |  Branch (277:22): [True: 3.69k, False: 1.78k]
  ------------------
  278|  3.69k|      if(src->peek(&b, 1, offset + 1 + i) == 0) {
  ------------------
  |  Branch (278:10): [True: 202, False: 3.49k]
  ------------------
  279|    202|         throw BER_Decoding_Error("Corrupted length field");
  280|    202|      }
  281|  3.49k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (281:10): [True: 0, False: 3.49k]
  ------------------
  282|      0|         throw BER_Decoding_Error("Field length overflow");
  283|      0|      }
  284|  3.49k|      length = (length << 8) | b;
  285|  3.49k|   }
  286|  1.78k|   return length;
  287|  1.98k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLength10indefiniteEmm:
  101|  2.04k|      static BerDecodedLength indefinite(size_t content_length, size_t field_length) {
  102|  2.04k|         return BerDecodedLength(content_length, field_length, true);
  103|  2.04k|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_114is_constructedENS_10ASN1_ClassE:
   20|   376k|bool is_constructed(ASN1_Class class_tag) {
   21|   376k|   return (static_cast<uint32_t>(class_tag) & static_cast<uint32_t>(ASN1_Class::Constructed)) != 0;
   22|   376k|}
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength14content_lengthEv:
  105|   999k|      size_t content_length() const { return m_content_length; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength17indefinite_lengthEv:
  112|   338k|      bool indefinite_length() const { return m_indefinite; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength12total_lengthEv:
  108|   332k|      size_t total_length() const { return m_indefinite ? m_content_length + 2 : m_content_length; }
  ------------------
  |  Branch (108:44): [True: 2.04k, False: 330k]
  ------------------
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassEb:
  719|  20.7k|                               bool require_der) {
  720|  20.7k|   obj.assert_is_a(type_tag, class_tag);
  721|       |
  722|       |   // DER requires BIT STRING and OCTET STRING to use primitive encoding
  723|  20.7k|   if(require_der && is_constructed(obj)) {
  ------------------
  |  Branch (723:7): [True: 0, False: 20.7k]
  |  Branch (723:22): [True: 0, False: 0]
  ------------------
  724|      0|      throw BER_Decoding_Error("Detected constructed string encoding in DER structure");
  725|      0|   }
  726|       |
  727|  20.7k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (727:7): [True: 16.3k, False: 4.45k]
  ------------------
  728|  16.3k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  729|  16.3k|   } else {
  730|  4.45k|      if(obj.length() == 0) {
  ------------------
  |  Branch (730:10): [True: 236, False: 4.21k]
  ------------------
  731|    236|         throw BER_Decoding_Error("Invalid BIT STRING");
  732|    236|      }
  733|       |
  734|  4.21k|      const uint8_t unused_bits = obj.bits()[0];
  735|       |
  736|  4.21k|      if(unused_bits >= 8) {
  ------------------
  |  Branch (736:10): [True: 226, False: 3.99k]
  ------------------
  737|    226|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  738|    226|      }
  739|       |
  740|       |      // Empty BIT STRING with unused bits > 0 ...
  741|  3.99k|      if(unused_bits > 0 && obj.length() < 2) {
  ------------------
  |  Branch (741:10): [True: 1.83k, False: 2.15k]
  |  Branch (741:29): [True: 197, False: 1.63k]
  ------------------
  742|    197|         throw BER_Decoding_Error("Invalid BIT STRING");
  743|    197|      }
  744|       |
  745|       |      // DER requires unused bits in BIT STRING to be zero (X.690 section 11.2.2)
  746|  3.79k|      if(require_der && unused_bits > 0) {
  ------------------
  |  Branch (746:10): [True: 0, False: 3.79k]
  |  Branch (746:25): [True: 0, False: 0]
  ------------------
  747|      0|         const uint8_t last_byte = obj.bits()[obj.length() - 1];
  748|      0|         if((last_byte & ((1 << unused_bits) - 1)) != 0) {
  ------------------
  |  Branch (748:13): [True: 0, False: 0]
  ------------------
  749|      0|            throw BER_Decoding_Error("Detected non-zero padding bits in BIT STRING in DER structure");
  750|      0|         }
  751|      0|      }
  752|       |
  753|  3.79k|      buffer.resize(obj.length() - 1);
  754|       |
  755|  3.79k|      if(obj.length() > 1) {
  ------------------
  |  Branch (755:10): [True: 2.18k, False: 1.61k]
  ------------------
  756|  2.18k|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  757|  2.18k|      }
  758|  3.79k|   }
  759|  20.7k|}

_ZN5Botan11DER_EncoderC2ERNSt3__16vectorIhNS1_9allocatorIhEEEE:
   72|   168k|DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   73|   168k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
   74|   168k|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEPKhm:
  244|   168k|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
  245|   168k|   std::vector<uint8_t> hdr;
  246|   168k|   encode_tag(hdr, type_tag, class_tag);
  247|   168k|   encode_length(hdr, length);
  248|       |
  249|   168k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (249:7): [True: 0, False: 168k]
  ------------------
  250|      0|      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
  251|   168k|   } else if(m_append_output) {
  ------------------
  |  Branch (251:14): [True: 168k, False: 0]
  ------------------
  252|   168k|      m_append_output(hdr.data(), hdr.size());
  253|   168k|      m_append_output(rep, length);
  254|   168k|   } else {
  255|      0|      m_default_outbuf += hdr;
  256|      0|      m_default_outbuf += std::make_pair(rep, length);
  257|      0|   }
  258|       |
  259|   168k|   return (*this);
  260|   168k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_110encode_tagERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeENS_10ASN1_ClassE:
   25|   168k|void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   26|   168k|   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   27|   168k|   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
   28|       |
   29|   168k|   if((class_tag | 0xE0) != 0xE0) {
  ------------------
  |  Branch (29:7): [True: 0, False: 168k]
  ------------------
   30|      0|      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   31|      0|   }
   32|       |
   33|   168k|   if(type_tag <= 30) {
  ------------------
  |  Branch (33:7): [True: 166k, False: 2.28k]
  ------------------
   34|   166k|      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   35|   166k|   } else {
   36|  2.28k|      size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
   37|  2.28k|      blocks = (blocks - (blocks % 7)) / 7;
   38|       |
   39|  2.28k|      BOTAN_ASSERT_NOMSG(blocks > 0);
  ------------------
  |  |   77|  2.28k|   do {                                                                     \
  |  |   78|  2.28k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  2.28k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 2.28k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  2.28k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 2.28k]
  |  |  ------------------
  ------------------
   40|       |
   41|  2.28k|      encoded_tag.push_back(static_cast<uint8_t>(class_tag | 0x1F));
   42|  5.65k|      for(size_t i = 0; i != blocks - 1; ++i) {
  ------------------
  |  Branch (42:25): [True: 3.37k, False: 2.28k]
  ------------------
   43|  3.37k|         encoded_tag.push_back(0x80 | ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
   44|  3.37k|      }
   45|  2.28k|      encoded_tag.push_back(type_tag & 0x7F);
   46|  2.28k|   }
   47|   168k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_113encode_lengthERNSt3__16vectorIhNS1_9allocatorIhEEEEm:
   52|   168k|void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   53|   168k|   if(length <= 127) {
  ------------------
  |  Branch (53:7): [True: 167k, False: 987]
  ------------------
   54|   167k|      encoded_length.push_back(static_cast<uint8_t>(length));
   55|   167k|   } else {
   56|    987|      const size_t bytes_needed = significant_bytes(length);
   57|       |
   58|    987|      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));
   59|       |
   60|  2.25k|      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
  ------------------
  |  Branch (60:53): [True: 1.26k, False: 987]
  ------------------
   61|  1.26k|         encoded_length.push_back(get_byte_var(i, length));
   62|  1.26k|      }
   63|    987|   }
   64|   168k|}
der_enc.cpp:_ZZN5Botan11DER_EncoderC1ERNSt3__16vectorIhNS1_9allocatorIhEEEEENK3$_0clEPKhm:
   73|   336k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };

_ZN5Botan7OID_MapC2Ev:
   11|      1|OID_Map::OID_Map() {
   12|      1|   m_str2oid = OID_Map::load_str2oid_map();
   13|      1|   m_oid2str = OID_Map::load_oid2str_map();
   14|      1|}
_ZN5Botan7OID_Map15global_registryEv:
   16|   115k|OID_Map& OID_Map::global_registry() {
   17|   115k|   static OID_Map g_map;
   18|   115k|   return g_map;
   19|   115k|}
_ZN5Botan7OID_Map7oid2strERKNS_3OIDE:
   69|   115k|std::string OID_Map::oid2str(const OID& oid) {
   70|   115k|   if(auto name = lookup_static_oid(oid)) {
  ------------------
  |  Branch (70:12): [True: 42.6k, False: 72.4k]
  ------------------
   71|  42.6k|      return std::string(*name);
   72|  42.6k|   }
   73|       |
   74|  72.4k|   const lock_guard_type<mutex_type> lock(m_mutex);
   75|       |
   76|  72.4k|   auto i = m_oid2str.find(oid);
   77|  72.4k|   if(i != m_oid2str.end()) {
  ------------------
  |  Branch (77:7): [True: 217, False: 72.2k]
  ------------------
   78|    217|      return i->second;
   79|    217|   }
   80|       |
   81|  72.2k|   return "";
   82|  72.4k|}

_ZN5Botan7OID_Map17lookup_static_oidERKNS_3OIDE:
   48|   115k|std::optional<std::string_view> OID_Map::lookup_static_oid(const OID& oid) {
   49|   115k|   const uint32_t hc = static_cast<uint32_t>(oid.hash_code() % 858701);
   50|       |
   51|   115k|   switch(hc) {
   52|    261|      case 0x01506:
  ------------------
  |  Branch (52:7): [True: 261, False: 114k]
  ------------------
   53|    261|         return if_match(oid, {1, 2, 840, 10045, 4, 3, 1}, "ECDSA/SHA-224");
   54|    388|      case 0x01507:
  ------------------
  |  Branch (54:7): [True: 388, False: 114k]
  ------------------
   55|    388|         return if_match(oid, {1, 2, 840, 10045, 4, 3, 2}, "ECDSA/SHA-256");
   56|    262|      case 0x01508:
  ------------------
  |  Branch (56:7): [True: 262, False: 114k]
  ------------------
   57|    262|         return if_match(oid, {1, 2, 840, 10045, 4, 3, 3}, "ECDSA/SHA-384");
   58|    260|      case 0x01509:
  ------------------
  |  Branch (58:7): [True: 260, False: 114k]
  ------------------
   59|    260|         return if_match(oid, {1, 2, 840, 10045, 4, 3, 4}, "ECDSA/SHA-512");
   60|     67|      case 0x04C1E:
  ------------------
  |  Branch (60:7): [True: 67, False: 115k]
  ------------------
   61|     67|         return if_match(oid, {1, 3, 6, 1, 4, 1, 3029, 1, 2, 1}, "ElGamal");
   62|    196|      case 0x04E61:
  ------------------
  |  Branch (62:7): [True: 196, False: 114k]
  ------------------
   63|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 3029, 1, 5, 1}, "OpenPGP.Curve25519");
   64|    263|      case 0x0779B:
  ------------------
  |  Branch (64:7): [True: 263, False: 114k]
  ------------------
   65|    263|         return if_match(oid, {1, 2, 840, 113549, 2, 5}, "MD5");
   66|    261|      case 0x0779D:
  ------------------
  |  Branch (66:7): [True: 261, False: 114k]
  ------------------
   67|    261|         return if_match(oid, {1, 2, 840, 113549, 2, 7}, "HMAC(SHA-1)");
   68|    388|      case 0x0779E:
  ------------------
  |  Branch (68:7): [True: 388, False: 114k]
  ------------------
   69|    388|         return if_match(oid, {1, 2, 840, 113549, 2, 8}, "HMAC(SHA-224)");
   70|    389|      case 0x0779F:
  ------------------
  |  Branch (70:7): [True: 389, False: 114k]
  ------------------
   71|    389|         return if_match(oid, {1, 2, 840, 113549, 2, 9}, "HMAC(SHA-256)");
   72|    261|      case 0x077A0:
  ------------------
  |  Branch (72:7): [True: 261, False: 114k]
  ------------------
   73|    261|         return if_match(oid, {1, 2, 840, 113549, 2, 10}, "HMAC(SHA-384)");
   74|    262|      case 0x077A1:
  ------------------
  |  Branch (74:7): [True: 262, False: 114k]
  ------------------
   75|    262|         return if_match(oid, {1, 2, 840, 113549, 2, 11}, "HMAC(SHA-512)");
   76|    467|      case 0x077A3:
  ------------------
  |  Branch (76:7): [True: 467, False: 114k]
  ------------------
   77|    467|         return if_match(oid, {1, 2, 840, 113549, 2, 13}, "HMAC(SHA-512-256)");
   78|    389|      case 0x0785E:
  ------------------
  |  Branch (78:7): [True: 389, False: 114k]
  ------------------
   79|    389|         return if_match(oid, {1, 2, 840, 113549, 3, 7}, "TripleDES/CBC");
   80|    194|      case 0x0C904:
  ------------------
  |  Branch (80:7): [True: 194, False: 114k]
  ------------------
   81|    194|         return if_match(oid, {1, 0, 14888, 3, 0, 5}, "ECKCDSA");
   82|    196|      case 0x11547:
  ------------------
  |  Branch (82:7): [True: 196, False: 114k]
  ------------------
   83|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 1}, "SphincsPlus-shake-128s-r3.1");
   84|    178|      case 0x11548:
  ------------------
  |  Branch (84:7): [True: 178, False: 114k]
  ------------------
   85|    178|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 2}, "SphincsPlus-shake-128f-r3.1");
   86|     67|      case 0x11549:
  ------------------
  |  Branch (86:7): [True: 67, False: 115k]
  ------------------
   87|     67|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 3}, "SphincsPlus-shake-192s-r3.1");
   88|    194|      case 0x1154A:
  ------------------
  |  Branch (88:7): [True: 194, False: 114k]
  ------------------
   89|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 4}, "SphincsPlus-shake-192f-r3.1");
   90|    194|      case 0x1154B:
  ------------------
  |  Branch (90:7): [True: 194, False: 114k]
  ------------------
   91|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 5}, "SphincsPlus-shake-256s-r3.1");
   92|    194|      case 0x1154C:
  ------------------
  |  Branch (92:7): [True: 194, False: 114k]
  ------------------
   93|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 6}, "SphincsPlus-shake-256f-r3.1");
   94|    194|      case 0x11608:
  ------------------
  |  Branch (94:7): [True: 194, False: 114k]
  ------------------
   95|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 1}, "SphincsPlus-sha2-128s-r3.1");
   96|    195|      case 0x11609:
  ------------------
  |  Branch (96:7): [True: 195, False: 114k]
  ------------------
   97|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 2}, "SphincsPlus-sha2-128f-r3.1");
   98|    194|      case 0x1160A:
  ------------------
  |  Branch (98:7): [True: 194, False: 114k]
  ------------------
   99|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 3}, "SphincsPlus-sha2-192s-r3.1");
  100|    198|      case 0x1160B:
  ------------------
  |  Branch (100:7): [True: 198, False: 114k]
  ------------------
  101|    198|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 4}, "SphincsPlus-sha2-192f-r3.1");
  102|    194|      case 0x1160C:
  ------------------
  |  Branch (102:7): [True: 194, False: 114k]
  ------------------
  103|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 5}, "SphincsPlus-sha2-256s-r3.1");
  104|    194|      case 0x1160D:
  ------------------
  |  Branch (104:7): [True: 194, False: 114k]
  ------------------
  105|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 6}, "SphincsPlus-sha2-256f-r3.1");
  106|    194|      case 0x116C9:
  ------------------
  |  Branch (106:7): [True: 194, False: 114k]
  ------------------
  107|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 1}, "SphincsPlus-haraka-128s-r3.1");
  108|    195|      case 0x116CA:
  ------------------
  |  Branch (108:7): [True: 195, False: 114k]
  ------------------
  109|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 2}, "SphincsPlus-haraka-128f-r3.1");
  110|    194|      case 0x116CB:
  ------------------
  |  Branch (110:7): [True: 194, False: 114k]
  ------------------
  111|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 3}, "SphincsPlus-haraka-192s-r3.1");
  112|    194|      case 0x116CC:
  ------------------
  |  Branch (112:7): [True: 194, False: 114k]
  ------------------
  113|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 4}, "SphincsPlus-haraka-192f-r3.1");
  114|    194|      case 0x116CD:
  ------------------
  |  Branch (114:7): [True: 194, False: 114k]
  ------------------
  115|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 5}, "SphincsPlus-haraka-256s-r3.1");
  116|    203|      case 0x116CE:
  ------------------
  |  Branch (116:7): [True: 203, False: 114k]
  ------------------
  117|    203|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 6}, "SphincsPlus-haraka-256f-r3.1");
  118|    260|      case 0x1533B:
  ------------------
  |  Branch (118:7): [True: 260, False: 114k]
  ------------------
  119|    260|         return if_match(oid, {1, 2, 156, 10197, 1, 104, 2}, "SM4/CBC");
  120|    388|      case 0x15341:
  ------------------
  |  Branch (120:7): [True: 388, False: 114k]
  ------------------
  121|    388|         return if_match(oid, {1, 2, 156, 10197, 1, 104, 8}, "SM4/GCM");
  122|    388|      case 0x1539D:
  ------------------
  |  Branch (122:7): [True: 388, False: 114k]
  ------------------
  123|    388|         return if_match(oid, {1, 2, 156, 10197, 1, 104, 100}, "SM4/OCB");
  124|    388|      case 0x187D7:
  ------------------
  |  Branch (124:7): [True: 388, False: 114k]
  ------------------
  125|    388|         return if_match(oid, {1, 3, 14, 3, 2, 7}, "DES/CBC");
  126|    260|      case 0x187EA:
  ------------------
  |  Branch (126:7): [True: 260, False: 114k]
  ------------------
  127|    260|         return if_match(oid, {1, 3, 14, 3, 2, 26}, "SHA-1");
  128|    484|      case 0x19933:
  ------------------
  |  Branch (128:7): [True: 484, False: 114k]
  ------------------
  129|    484|         return if_match(oid, {1, 3, 132, 0, 8}, "secp160r1");
  130|    396|      case 0x19934:
  ------------------
  |  Branch (130:7): [True: 396, False: 114k]
  ------------------
  131|    396|         return if_match(oid, {1, 3, 132, 0, 9}, "secp160k1");
  132|    380|      case 0x19935:
  ------------------
  |  Branch (132:7): [True: 380, False: 114k]
  ------------------
  133|    380|         return if_match(oid, {1, 3, 132, 0, 10}, "secp256k1");
  134|    388|      case 0x19949:
  ------------------
  |  Branch (134:7): [True: 388, False: 114k]
  ------------------
  135|    388|         return if_match(oid, {1, 3, 132, 0, 30}, "secp160r2");
  136|    390|      case 0x1994A:
  ------------------
  |  Branch (136:7): [True: 390, False: 114k]
  ------------------
  137|    390|         return if_match(oid, {1, 3, 132, 0, 31}, "secp192k1");
  138|    389|      case 0x1994B:
  ------------------
  |  Branch (138:7): [True: 389, False: 114k]
  ------------------
  139|    389|         return if_match(oid, {1, 3, 132, 0, 32}, "secp224k1");
  140|    389|      case 0x1994C:
  ------------------
  |  Branch (140:7): [True: 389, False: 114k]
  ------------------
  141|    389|         return if_match(oid, {1, 3, 132, 0, 33}, "secp224r1");
  142|    391|      case 0x1994D:
  ------------------
  |  Branch (142:7): [True: 391, False: 114k]
  ------------------
  143|    391|         return if_match(oid, {1, 3, 132, 0, 34}, "secp384r1");
  144|    385|      case 0x1994E:
  ------------------
  |  Branch (144:7): [True: 385, False: 114k]
  ------------------
  145|    385|         return if_match(oid, {1, 3, 132, 0, 35}, "secp521r1");
  146|    390|      case 0x199F8:
  ------------------
  |  Branch (146:7): [True: 390, False: 114k]
  ------------------
  147|    390|         return if_match(oid, {1, 3, 132, 1, 12}, "ECDH");
  148|    261|      case 0x1E7BF:
  ------------------
  |  Branch (148:7): [True: 261, False: 114k]
  ------------------
  149|    261|         return if_match(oid, {1, 2, 156, 10197, 1, 301, 1}, "SM2");
  150|    260|      case 0x1E7C0:
  ------------------
  |  Branch (150:7): [True: 260, False: 114k]
  ------------------
  151|    260|         return if_match(oid, {1, 2, 156, 10197, 1, 301, 2}, "SM2_Kex");
  152|    389|      case 0x1E7C1:
  ------------------
  |  Branch (152:7): [True: 389, False: 114k]
  ------------------
  153|    389|         return if_match(oid, {1, 2, 156, 10197, 1, 301, 3}, "SM2_Enc");
  154|    388|      case 0x21960:
  ------------------
  |  Branch (154:7): [True: 388, False: 114k]
  ------------------
  155|    388|         return if_match(oid, {1, 3, 36, 3, 3, 1, 2}, "RSA/PKCS1v15(RIPEMD-160)");
  156|    261|      case 0x2198A:
  ------------------
  |  Branch (156:7): [True: 261, False: 114k]
  ------------------
  157|    261|         return if_match(oid, {1, 2, 840, 113533, 7, 66, 10}, "CAST-128/CBC");
  158|    390|      case 0x2198F:
  ------------------
  |  Branch (158:7): [True: 390, False: 114k]
  ------------------
  159|    390|         return if_match(oid, {1, 2, 840, 113533, 7, 66, 15}, "KeyWrap.CAST-128");
  160|    253|      case 0x227C0:
  ------------------
  |  Branch (160:7): [True: 253, False: 114k]
  ------------------
  161|    253|         return if_match(oid, {1, 3, 101, 110}, "X25519");
  162|    388|      case 0x227C1:
  ------------------
  |  Branch (162:7): [True: 388, False: 114k]
  ------------------
  163|    388|         return if_match(oid, {1, 3, 101, 111}, "X448");
  164|    388|      case 0x227C2:
  ------------------
  |  Branch (164:7): [True: 388, False: 114k]
  ------------------
  165|    388|         return if_match(oid, {1, 3, 101, 112}, "Ed25519");
  166|    407|      case 0x227C3:
  ------------------
  |  Branch (166:7): [True: 407, False: 114k]
  ------------------
  167|    407|         return if_match(oid, {1, 3, 101, 113}, "Ed448");
  168|    388|      case 0x27565:
  ------------------
  |  Branch (168:7): [True: 388, False: 114k]
  ------------------
  169|    388|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 48, 1, 1}, "PKIX.OCSP.BasicResponse");
  170|    260|      case 0x27569:
  ------------------
  |  Branch (170:7): [True: 260, False: 114k]
  ------------------
  171|    260|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 48, 1, 5}, "PKIX.OCSP.NoCheck");
  172|    258|      case 0x29F7C:
  ------------------
  |  Branch (172:7): [True: 258, False: 114k]
  ------------------
  173|    258|         return if_match(oid, {1, 2, 410, 200004, 1, 100, 4, 3}, "ECKCDSA/SHA-1");
  174|    199|      case 0x29F7D:
  ------------------
  |  Branch (174:7): [True: 199, False: 114k]
  ------------------
  175|    199|         return if_match(oid, {1, 2, 410, 200004, 1, 100, 4, 4}, "ECKCDSA/SHA-224");
  176|    195|      case 0x29F7E:
  ------------------
  |  Branch (176:7): [True: 195, False: 114k]
  ------------------
  177|    195|         return if_match(oid, {1, 2, 410, 200004, 1, 100, 4, 5}, "ECKCDSA/SHA-256");
  178|    389|      case 0x2AC3B:
  ------------------
  |  Branch (178:7): [True: 389, False: 114k]
  ------------------
  179|    389|         return if_match(oid, {2, 5, 29, 32, 0}, "X509v3.AnyPolicy");
  180|    385|      case 0x2B000:
  ------------------
  |  Branch (180:7): [True: 385, False: 114k]
  ------------------
  181|    385|         return if_match(oid, {2, 5, 29, 37, 0}, "X509v3.AnyExtendedKeyUsage");
  182|    392|      case 0x2B5C9:
  ------------------
  |  Branch (182:7): [True: 392, False: 114k]
  ------------------
  183|    392|         return if_match(oid, {1, 2, 840, 10045, 2, 1}, "ECDSA");
  184|    390|      case 0x2B74B:
  ------------------
  |  Branch (184:7): [True: 390, False: 114k]
  ------------------
  185|    390|         return if_match(oid, {1, 2, 840, 10045, 4, 1}, "ECDSA/SHA-1");
  186|    409|      case 0x3474A:
  ------------------
  |  Branch (186:7): [True: 409, False: 114k]
  ------------------
  187|    409|         return if_match(oid, {1, 2, 840, 10046, 2, 1}, "DH");
  188|    416|      case 0x38D6D:
  ------------------
  |  Branch (188:7): [True: 416, False: 114k]
  ------------------
  189|    416|         return if_match(oid, {1, 2, 643, 7, 1, 2, 1, 1, 1}, "gost_256A");
  190|    424|      case 0x38D6E:
  ------------------
  |  Branch (190:7): [True: 424, False: 114k]
  ------------------
  191|    424|         return if_match(oid, {1, 2, 643, 7, 1, 2, 1, 1, 2}, "gost_256B");
  192|    388|      case 0x38E2E:
  ------------------
  |  Branch (192:7): [True: 388, False: 114k]
  ------------------
  193|    388|         return if_match(oid, {1, 2, 643, 7, 1, 2, 1, 2, 1}, "gost_512A");
  194|    389|      case 0x38E2F:
  ------------------
  |  Branch (194:7): [True: 389, False: 114k]
  ------------------
  195|    389|         return if_match(oid, {1, 2, 643, 7, 1, 2, 1, 2, 2}, "gost_512B");
  196|    382|      case 0x38F2C:
  ------------------
  |  Branch (196:7): [True: 382, False: 114k]
  ------------------
  197|    382|         return if_match(oid, {1, 2, 643, 2, 2, 3}, "GOST-34.10/GOST-R-34.11-94");
  198|    390|      case 0x38F3C:
  ------------------
  |  Branch (198:7): [True: 390, False: 114k]
  ------------------
  199|    390|         return if_match(oid, {1, 2, 643, 2, 2, 19}, "GOST-34.10");
  200|    388|      case 0x3D7B8:
  ------------------
  |  Branch (200:7): [True: 388, False: 114k]
  ------------------
  201|    388|         return if_match(oid, {0, 3, 4401, 5, 3, 1, 9, 6}, "Camellia-128/GCM");
  202|    372|      case 0x3D7CC:
  ------------------
  |  Branch (202:7): [True: 372, False: 114k]
  ------------------
  203|    372|         return if_match(oid, {0, 3, 4401, 5, 3, 1, 9, 26}, "Camellia-192/GCM");
  204|    388|      case 0x3D7E0:
  ------------------
  |  Branch (204:7): [True: 388, False: 114k]
  ------------------
  205|    388|         return if_match(oid, {0, 3, 4401, 5, 3, 1, 9, 46}, "Camellia-256/GCM");
  206|    252|      case 0x3F20F:
  ------------------
  |  Branch (206:7): [True: 252, False: 114k]
  ------------------
  207|    252|         return if_match(oid, {1, 3, 36, 3, 2, 1}, "RIPEMD-160");
  208|    194|      case 0x4266E:
  ------------------
  |  Branch (208:7): [True: 194, False: 114k]
  ------------------
  209|    194|         return if_match(oid, {0, 4, 0, 127, 0, 15, 1, 1, 13, 0}, "XMSS");
  210|    194|      case 0x478C4:
  ------------------
  |  Branch (210:7): [True: 194, False: 114k]
  ------------------
  211|    194|         return if_match(oid, {1, 2, 410, 200004, 1, 4}, "SEED/CBC");
  212|    407|      case 0x47D98:
  ------------------
  |  Branch (212:7): [True: 407, False: 114k]
  ------------------
  213|    407|         return if_match(oid, {1, 2, 156, 10197, 1, 301}, "sm2p256v1");
  214|    389|      case 0x47DFC:
  ------------------
  |  Branch (214:7): [True: 389, False: 114k]
  ------------------
  215|    389|         return if_match(oid, {1, 2, 156, 10197, 1, 401}, "SM3");
  216|    388|      case 0x47E60:
  ------------------
  |  Branch (216:7): [True: 388, False: 114k]
  ------------------
  217|    388|         return if_match(oid, {1, 2, 156, 10197, 1, 501}, "SM2_Sig/SM3");
  218|    390|      case 0x47E63:
  ------------------
  |  Branch (218:7): [True: 390, False: 114k]
  ------------------
  219|    390|         return if_match(oid, {1, 2, 156, 10197, 1, 504}, "RSA/PKCS1v15(SM3)");
  220|    390|      case 0x52B13:
  ------------------
  |  Branch (220:7): [True: 390, False: 114k]
  ------------------
  221|    390|         return if_match(oid, {1, 2, 643, 3, 131, 1, 1}, "GOST.INN");
  222|    196|      case 0x635AE:
  ------------------
  |  Branch (222:7): [True: 196, False: 114k]
  ------------------
  223|    196|         return if_match(oid, {1, 2, 250, 1, 223, 101, 256, 1}, "frp256v1");
  224|    267|      case 0x6A784:
  ------------------
  |  Branch (224:7): [True: 267, False: 114k]
  ------------------
  225|    267|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 1}, "PKCS12.KeyBag");
  226|    397|      case 0x6A785:
  ------------------
  |  Branch (226:7): [True: 397, False: 114k]
  ------------------
  227|    397|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 2}, "PKCS12.PKCS8ShroudedKeyBag");
  228|    406|      case 0x6A786:
  ------------------
  |  Branch (228:7): [True: 406, False: 114k]
  ------------------
  229|    406|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 3}, "PKCS12.CertBag");
  230|    404|      case 0x6A787:
  ------------------
  |  Branch (230:7): [True: 404, False: 114k]
  ------------------
  231|    404|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 4}, "PKCS12.CRLBag");
  232|    422|      case 0x6A788:
  ------------------
  |  Branch (232:7): [True: 422, False: 114k]
  ------------------
  233|    422|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 5}, "PKCS12.SecretBag");
  234|    152|      case 0x6A789:
  ------------------
  |  Branch (234:7): [True: 152, False: 114k]
  ------------------
  235|    152|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 10, 1, 6}, "PKCS12.SafeContentsBag");
  236|    169|      case 0x6EB86:
  ------------------
  |  Branch (236:7): [True: 169, False: 114k]
  ------------------
  237|    169|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 6, 1}, "GOST-34.10-2012-256/SHA-256");
  238|    194|      case 0x6EC47:
  ------------------
  |  Branch (238:7): [True: 194, False: 114k]
  ------------------
  239|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 7, 1}, "Kyber-512-r3");
  240|    214|      case 0x6EC48:
  ------------------
  |  Branch (240:7): [True: 214, False: 114k]
  ------------------
  241|    214|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 7, 2}, "Kyber-768-r3");
  242|    194|      case 0x6EC49:
  ------------------
  |  Branch (242:7): [True: 194, False: 114k]
  ------------------
  243|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 7, 3}, "Kyber-1024-r3");
  244|    194|      case 0x6EDC9:
  ------------------
  |  Branch (244:7): [True: 194, False: 114k]
  ------------------
  245|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 9, 1}, "Dilithium-4x4-r3");
  246|    194|      case 0x6EDCA:
  ------------------
  |  Branch (246:7): [True: 194, False: 114k]
  ------------------
  247|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 9, 2}, "Dilithium-6x5-r3");
  248|    194|      case 0x6EDCB:
  ------------------
  |  Branch (248:7): [True: 194, False: 114k]
  ------------------
  249|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 9, 3}, "Dilithium-8x7-r3");
  250|     66|      case 0x6EE8A:
  ------------------
  |  Branch (250:7): [True: 66, False: 115k]
  ------------------
  251|     66|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 10, 1}, "Dilithium-4x4-AES-r3");
  252|    196|      case 0x6EE8B:
  ------------------
  |  Branch (252:7): [True: 196, False: 114k]
  ------------------
  253|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 10, 2}, "Dilithium-6x5-AES-r3");
  254|    194|      case 0x6EE8C:
  ------------------
  |  Branch (254:7): [True: 194, False: 114k]
  ------------------
  255|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 10, 3}, "Dilithium-8x7-AES-r3");
  256|    195|      case 0x6EF4B:
  ------------------
  |  Branch (256:7): [True: 195, False: 114k]
  ------------------
  257|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 11, 1}, "Kyber-512-90s-r3");
  258|    194|      case 0x6EF4C:
  ------------------
  |  Branch (258:7): [True: 194, False: 114k]
  ------------------
  259|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 11, 2}, "Kyber-768-90s-r3");
  260|    194|      case 0x6EF4D:
  ------------------
  |  Branch (260:7): [True: 194, False: 114k]
  ------------------
  261|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 11, 3}, "Kyber-1024-90s-r3");
  262|     66|      case 0x6F18E:
  ------------------
  |  Branch (262:7): [True: 66, False: 115k]
  ------------------
  263|     66|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 14, 1}, "FrodoKEM-640-SHAKE");
  264|    194|      case 0x6F18F:
  ------------------
  |  Branch (264:7): [True: 194, False: 114k]
  ------------------
  265|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 14, 2}, "FrodoKEM-976-SHAKE");
  266|    195|      case 0x6F190:
  ------------------
  |  Branch (266:7): [True: 195, False: 114k]
  ------------------
  267|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 14, 3}, "FrodoKEM-1344-SHAKE");
  268|    194|      case 0x6F24F:
  ------------------
  |  Branch (268:7): [True: 194, False: 114k]
  ------------------
  269|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 15, 1}, "FrodoKEM-640-AES");
  270|    194|      case 0x6F250:
  ------------------
  |  Branch (270:7): [True: 194, False: 114k]
  ------------------
  271|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 15, 2}, "FrodoKEM-976-AES");
  272|    194|      case 0x6F251:
  ------------------
  |  Branch (272:7): [True: 194, False: 114k]
  ------------------
  273|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 15, 3}, "FrodoKEM-1344-AES");
  274|    194|      case 0x6F310:
  ------------------
  |  Branch (274:7): [True: 194, False: 114k]
  ------------------
  275|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 16, 1}, "eFrodoKEM-640-SHAKE");
  276|    196|      case 0x6F311:
  ------------------
  |  Branch (276:7): [True: 196, False: 114k]
  ------------------
  277|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 16, 2}, "eFrodoKEM-976-SHAKE");
  278|    195|      case 0x6F312:
  ------------------
  |  Branch (278:7): [True: 195, False: 114k]
  ------------------
  279|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 16, 3}, "eFrodoKEM-1344-SHAKE");
  280|    194|      case 0x6F3D1:
  ------------------
  |  Branch (280:7): [True: 194, False: 114k]
  ------------------
  281|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 17, 1}, "eFrodoKEM-640-AES");
  282|    213|      case 0x6F3D2:
  ------------------
  |  Branch (282:7): [True: 213, False: 114k]
  ------------------
  283|    213|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 17, 2}, "eFrodoKEM-976-AES");
  284|    194|      case 0x6F3D3:
  ------------------
  |  Branch (284:7): [True: 194, False: 114k]
  ------------------
  285|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 17, 3}, "eFrodoKEM-1344-AES");
  286|    194|      case 0x6F492:
  ------------------
  |  Branch (286:7): [True: 194, False: 114k]
  ------------------
  287|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 1}, "ClassicMcEliece_6688128pc");
  288|    194|      case 0x6F493:
  ------------------
  |  Branch (288:7): [True: 194, False: 114k]
  ------------------
  289|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 2}, "ClassicMcEliece_6688128pcf");
  290|    231|      case 0x6F494:
  ------------------
  |  Branch (290:7): [True: 231, False: 114k]
  ------------------
  291|    231|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 3}, "ClassicMcEliece_6960119pc");
  292|    194|      case 0x6F495:
  ------------------
  |  Branch (292:7): [True: 194, False: 114k]
  ------------------
  293|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 4}, "ClassicMcEliece_6960119pcf");
  294|    201|      case 0x6F496:
  ------------------
  |  Branch (294:7): [True: 201, False: 114k]
  ------------------
  295|    201|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 5}, "ClassicMcEliece_8192128pc");
  296|    194|      case 0x6F497:
  ------------------
  |  Branch (296:7): [True: 194, False: 114k]
  ------------------
  297|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 18, 6}, "ClassicMcEliece_8192128pcf");
  298|    389|      case 0x6F79D:
  ------------------
  |  Branch (298:7): [True: 389, False: 114k]
  ------------------
  299|    389|         return if_match(oid, {2, 16, 840, 1, 113730, 1, 13}, "Certificate Comment");
  300|    388|      case 0x701A0:
  ------------------
  |  Branch (300:7): [True: 388, False: 114k]
  ------------------
  301|    388|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 2, 1}, "ECGDSA");
  302|    261|      case 0x70322:
  ------------------
  |  Branch (302:7): [True: 261, False: 114k]
  ------------------
  303|    261|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 1}, "ECGDSA/RIPEMD-160");
  304|    388|      case 0x70323:
  ------------------
  |  Branch (304:7): [True: 388, False: 114k]
  ------------------
  305|    388|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 2}, "ECGDSA/SHA-1");
  306|    389|      case 0x70324:
  ------------------
  |  Branch (306:7): [True: 389, False: 114k]
  ------------------
  307|    389|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 3}, "ECGDSA/SHA-224");
  308|    263|      case 0x70325:
  ------------------
  |  Branch (308:7): [True: 263, False: 114k]
  ------------------
  309|    263|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 4}, "ECGDSA/SHA-256");
  310|    385|      case 0x70326:
  ------------------
  |  Branch (310:7): [True: 385, False: 114k]
  ------------------
  311|    385|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 5}, "ECGDSA/SHA-384");
  312|    388|      case 0x70327:
  ------------------
  |  Branch (312:7): [True: 388, False: 114k]
  ------------------
  313|    388|         return if_match(oid, {1, 3, 36, 3, 3, 2, 5, 4, 6}, "ECGDSA/SHA-512");
  314|    407|      case 0x72B21:
  ------------------
  |  Branch (314:7): [True: 407, False: 114k]
  ------------------
  315|    407|         return if_match(oid, {1, 2, 643, 7, 1, 1, 1, 1}, "GOST-34.10-2012-256");
  316|    388|      case 0x72B22:
  ------------------
  |  Branch (316:7): [True: 388, False: 114k]
  ------------------
  317|    388|         return if_match(oid, {1, 2, 643, 7, 1, 1, 1, 2}, "GOST-34.10-2012-512");
  318|    388|      case 0x72BE3:
  ------------------
  |  Branch (318:7): [True: 388, False: 114k]
  ------------------
  319|    388|         return if_match(oid, {1, 2, 643, 7, 1, 1, 2, 2}, "Streebog-256");
  320|    388|      case 0x72BE4:
  ------------------
  |  Branch (320:7): [True: 388, False: 114k]
  ------------------
  321|    388|         return if_match(oid, {1, 2, 643, 7, 1, 1, 2, 3}, "Streebog-512");
  322|    399|      case 0x72CA4:
  ------------------
  |  Branch (322:7): [True: 399, False: 114k]
  ------------------
  323|    399|         return if_match(oid, {1, 2, 643, 7, 1, 1, 3, 2}, "GOST-34.10-2012-256/Streebog-256");
  324|    260|      case 0x72CA5:
  ------------------
  |  Branch (324:7): [True: 260, False: 114k]
  ------------------
  325|    260|         return if_match(oid, {1, 2, 643, 7, 1, 1, 3, 3}, "GOST-34.10-2012-512/Streebog-512");
  326|    373|      case 0x7C7C7:
  ------------------
  |  Branch (326:7): [True: 373, False: 114k]
  ------------------
  327|    373|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 22, 1}, "PKCS9.X509Certificate");
  328|    228|      case 0x7C7C8:
  ------------------
  |  Branch (328:7): [True: 228, False: 114k]
  ------------------
  329|    228|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 22, 2}, "PKCS9.SDSICertificate");
  330|    388|      case 0x7C888:
  ------------------
  |  Branch (330:7): [True: 388, False: 114k]
  ------------------
  331|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 23, 1}, "PKCS9.X509CRL");
  332|    388|      case 0x7E10F:
  ------------------
  |  Branch (332:7): [True: 388, False: 114k]
  ------------------
  333|    388|         return if_match(oid, {2, 5, 4, 3}, "X520.CommonName");
  334|    440|      case 0x7E110:
  ------------------
  |  Branch (334:7): [True: 440, False: 114k]
  ------------------
  335|    440|         return if_match(oid, {2, 5, 4, 4}, "X520.Surname");
  336|    395|      case 0x7E111:
  ------------------
  |  Branch (336:7): [True: 395, False: 114k]
  ------------------
  337|    395|         return if_match(oid, {2, 5, 4, 5}, "X520.SerialNumber");
  338|    423|      case 0x7E112:
  ------------------
  |  Branch (338:7): [True: 423, False: 114k]
  ------------------
  339|    423|         return if_match(oid, {2, 5, 4, 6}, "X520.Country");
  340|    436|      case 0x7E113:
  ------------------
  |  Branch (340:7): [True: 436, False: 114k]
  ------------------
  341|    436|         return if_match(oid, {2, 5, 4, 7}, "X520.Locality");
  342|    409|      case 0x7E114:
  ------------------
  |  Branch (342:7): [True: 409, False: 114k]
  ------------------
  343|    409|         return if_match(oid, {2, 5, 4, 8}, "X520.State");
  344|    391|      case 0x7E115:
  ------------------
  |  Branch (344:7): [True: 391, False: 114k]
  ------------------
  345|    391|         return if_match(oid, {2, 5, 4, 9}, "X520.StreetAddress");
  346|    394|      case 0x7E116:
  ------------------
  |  Branch (346:7): [True: 394, False: 114k]
  ------------------
  347|    394|         return if_match(oid, {2, 5, 4, 10}, "X520.Organization");
  348|    388|      case 0x7E117:
  ------------------
  |  Branch (348:7): [True: 388, False: 114k]
  ------------------
  349|    388|         return if_match(oid, {2, 5, 4, 11}, "X520.OrganizationalUnit");
  350|    399|      case 0x7E118:
  ------------------
  |  Branch (350:7): [True: 399, False: 114k]
  ------------------
  351|    399|         return if_match(oid, {2, 5, 4, 12}, "X520.Title");
  352|    388|      case 0x7E136:
  ------------------
  |  Branch (352:7): [True: 388, False: 114k]
  ------------------
  353|    388|         return if_match(oid, {2, 5, 4, 42}, "X520.GivenName");
  354|    389|      case 0x7E137:
  ------------------
  |  Branch (354:7): [True: 389, False: 114k]
  ------------------
  355|    389|         return if_match(oid, {2, 5, 4, 43}, "X520.Initials");
  356|    388|      case 0x7E138:
  ------------------
  |  Branch (356:7): [True: 388, False: 114k]
  ------------------
  357|    388|         return if_match(oid, {2, 5, 4, 44}, "X520.GenerationalQualifier");
  358|    396|      case 0x7E13A:
  ------------------
  |  Branch (358:7): [True: 396, False: 114k]
  ------------------
  359|    396|         return if_match(oid, {2, 5, 4, 46}, "X520.DNQualifier");
  360|    512|      case 0x7E14D:
  ------------------
  |  Branch (360:7): [True: 512, False: 114k]
  ------------------
  361|    512|         return if_match(oid, {2, 5, 4, 65}, "X520.Pseudonym");
  362|    390|      case 0x7F3F3:
  ------------------
  |  Branch (362:7): [True: 390, False: 114k]
  ------------------
  363|    390|         return if_match(oid, {2, 5, 29, 14}, "X509v3.SubjectKeyIdentifier");
  364|    392|      case 0x7F3F4:
  ------------------
  |  Branch (364:7): [True: 392, False: 114k]
  ------------------
  365|    392|         return if_match(oid, {2, 5, 29, 15}, "X509v3.KeyUsage");
  366|    388|      case 0x7F3F5:
  ------------------
  |  Branch (366:7): [True: 388, False: 114k]
  ------------------
  367|    388|         return if_match(oid, {2, 5, 29, 16}, "X509v3.PrivateKeyUsagePeriod");
  368|    536|      case 0x7F3F6:
  ------------------
  |  Branch (368:7): [True: 536, False: 114k]
  ------------------
  369|    536|         return if_match(oid, {2, 5, 29, 17}, "X509v3.SubjectAlternativeName");
  370|    388|      case 0x7F3F7:
  ------------------
  |  Branch (370:7): [True: 388, False: 114k]
  ------------------
  371|    388|         return if_match(oid, {2, 5, 29, 18}, "X509v3.IssuerAlternativeName");
  372|    431|      case 0x7F3F8:
  ------------------
  |  Branch (372:7): [True: 431, False: 114k]
  ------------------
  373|    431|         return if_match(oid, {2, 5, 29, 19}, "X509v3.BasicConstraints");
  374|    389|      case 0x7F3F9:
  ------------------
  |  Branch (374:7): [True: 389, False: 114k]
  ------------------
  375|    389|         return if_match(oid, {2, 5, 29, 20}, "X509v3.CRLNumber");
  376|    389|      case 0x7F3FA:
  ------------------
  |  Branch (376:7): [True: 389, False: 114k]
  ------------------
  377|    389|         return if_match(oid, {2, 5, 29, 21}, "X509v3.ReasonCode");
  378|    420|      case 0x7F3FC:
  ------------------
  |  Branch (378:7): [True: 420, False: 114k]
  ------------------
  379|    420|         return if_match(oid, {2, 5, 29, 23}, "X509v3.HoldInstructionCode");
  380|    388|      case 0x7F3FD:
  ------------------
  |  Branch (380:7): [True: 388, False: 114k]
  ------------------
  381|    388|         return if_match(oid, {2, 5, 29, 24}, "X509v3.InvalidityDate");
  382|    391|      case 0x7F401:
  ------------------
  |  Branch (382:7): [True: 391, False: 114k]
  ------------------
  383|    391|         return if_match(oid, {2, 5, 29, 28}, "X509v3.CRLIssuingDistributionPoint");
  384|    391|      case 0x7F403:
  ------------------
  |  Branch (384:7): [True: 391, False: 114k]
  ------------------
  385|    391|         return if_match(oid, {2, 5, 29, 30}, "X509v3.NameConstraints");
  386|    391|      case 0x7F404:
  ------------------
  |  Branch (386:7): [True: 391, False: 114k]
  ------------------
  387|    391|         return if_match(oid, {2, 5, 29, 31}, "X509v3.CRLDistributionPoints");
  388|    389|      case 0x7F405:
  ------------------
  |  Branch (388:7): [True: 389, False: 114k]
  ------------------
  389|    389|         return if_match(oid, {2, 5, 29, 32}, "X509v3.CertificatePolicies");
  390|    388|      case 0x7F408:
  ------------------
  |  Branch (390:7): [True: 388, False: 114k]
  ------------------
  391|    388|         return if_match(oid, {2, 5, 29, 35}, "X509v3.AuthorityKeyIdentifier");
  392|    389|      case 0x7F409:
  ------------------
  |  Branch (392:7): [True: 389, False: 114k]
  ------------------
  393|    389|         return if_match(oid, {2, 5, 29, 36}, "X509v3.PolicyConstraints");
  394|    391|      case 0x7F40A:
  ------------------
  |  Branch (394:7): [True: 391, False: 114k]
  ------------------
  395|    391|         return if_match(oid, {2, 5, 29, 37}, "X509v3.ExtendedKeyUsage");
  396|    260|      case 0x7F41D:
  ------------------
  |  Branch (396:7): [True: 260, False: 114k]
  ------------------
  397|    260|         return if_match(oid, {2, 5, 29, 56}, "X509v3.NoRevocationAvailable");
  398|     68|      case 0x80B84:
  ------------------
  |  Branch (398:7): [True: 68, False: 115k]
  ------------------
  399|     68|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 1}, "AES-128/OCB");
  400|    194|      case 0x80B85:
  ------------------
  |  Branch (400:7): [True: 194, False: 114k]
  ------------------
  401|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 2}, "AES-192/OCB");
  402|    194|      case 0x80B86:
  ------------------
  |  Branch (402:7): [True: 194, False: 114k]
  ------------------
  403|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 3}, "AES-256/OCB");
  404|    194|      case 0x80B87:
  ------------------
  |  Branch (404:7): [True: 194, False: 114k]
  ------------------
  405|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 4}, "Serpent/OCB");
  406|    194|      case 0x80B88:
  ------------------
  |  Branch (406:7): [True: 194, False: 114k]
  ------------------
  407|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 5}, "Twofish/OCB");
  408|    194|      case 0x80B89:
  ------------------
  |  Branch (408:7): [True: 194, False: 114k]
  ------------------
  409|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 6}, "Camellia-128/OCB");
  410|    194|      case 0x80B8A:
  ------------------
  |  Branch (410:7): [True: 194, False: 114k]
  ------------------
  411|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 7}, "Camellia-192/OCB");
  412|    194|      case 0x80B8B:
  ------------------
  |  Branch (412:7): [True: 194, False: 114k]
  ------------------
  413|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2, 8}, "Camellia-256/OCB");
  414|    202|      case 0x80D06:
  ------------------
  |  Branch (414:7): [True: 202, False: 114k]
  ------------------
  415|    202|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 1}, "AES-128/SIV");
  416|    194|      case 0x80D07:
  ------------------
  |  Branch (416:7): [True: 194, False: 114k]
  ------------------
  417|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 2}, "AES-192/SIV");
  418|    194|      case 0x80D08:
  ------------------
  |  Branch (418:7): [True: 194, False: 114k]
  ------------------
  419|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 3}, "AES-256/SIV");
  420|    211|      case 0x80D09:
  ------------------
  |  Branch (420:7): [True: 211, False: 114k]
  ------------------
  421|    211|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 4}, "Serpent/SIV");
  422|    194|      case 0x80D0A:
  ------------------
  |  Branch (422:7): [True: 194, False: 114k]
  ------------------
  423|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 5}, "Twofish/SIV");
  424|    194|      case 0x80D0B:
  ------------------
  |  Branch (424:7): [True: 194, False: 114k]
  ------------------
  425|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 6}, "Camellia-128/SIV");
  426|    194|      case 0x80D0C:
  ------------------
  |  Branch (426:7): [True: 194, False: 114k]
  ------------------
  427|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 7}, "Camellia-192/SIV");
  428|    194|      case 0x80D0D:
  ------------------
  |  Branch (428:7): [True: 194, False: 114k]
  ------------------
  429|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 8}, "Camellia-256/SIV");
  430|    194|      case 0x80D0E:
  ------------------
  |  Branch (430:7): [True: 194, False: 114k]
  ------------------
  431|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 4, 9}, "SM4/SIV");
  432|    194|      case 0x84C6A:
  ------------------
  |  Branch (432:7): [True: 194, False: 114k]
  ------------------
  433|    194|         return if_match(oid, {1, 2, 392, 200011, 61, 1, 1, 1, 2}, "Camellia-128/CBC");
  434|    194|      case 0x84C6B:
  ------------------
  |  Branch (434:7): [True: 194, False: 114k]
  ------------------
  435|    194|         return if_match(oid, {1, 2, 392, 200011, 61, 1, 1, 1, 3}, "Camellia-192/CBC");
  436|    244|      case 0x84C6C:
  ------------------
  |  Branch (436:7): [True: 244, False: 114k]
  ------------------
  437|    244|         return if_match(oid, {1, 2, 392, 200011, 61, 1, 1, 1, 4}, "Camellia-256/CBC");
  438|    388|      case 0x88CD3:
  ------------------
  |  Branch (438:7): [True: 388, False: 114k]
  ------------------
  439|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 16, 3, 6}, "KeyWrap.TripleDES");
  440|    392|      case 0x88CD5:
  ------------------
  |  Branch (440:7): [True: 392, False: 114k]
  ------------------
  441|    392|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 16, 3, 8}, "Compression.Zlib");
  442|    260|      case 0x88CDE:
  ------------------
  |  Branch (442:7): [True: 260, False: 114k]
  ------------------
  443|    260|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 16, 3, 17}, "HSS-LMS");
  444|    228|      case 0x88CDF:
  ------------------
  |  Branch (444:7): [True: 228, False: 114k]
  ------------------
  445|    228|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 16, 3, 18}, "ChaCha20Poly1305");
  446|    389|      case 0x92296:
  ------------------
  |  Branch (446:7): [True: 389, False: 114k]
  ------------------
  447|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 2}, "AES-128/CBC");
  448|    389|      case 0x92299:
  ------------------
  |  Branch (448:7): [True: 389, False: 114k]
  ------------------
  449|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 5}, "KeyWrap.AES-128");
  450|    388|      case 0x9229A:
  ------------------
  |  Branch (450:7): [True: 388, False: 114k]
  ------------------
  451|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 6}, "AES-128/GCM");
  452|    396|      case 0x9229B:
  ------------------
  |  Branch (452:7): [True: 396, False: 114k]
  ------------------
  453|    396|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 7}, "AES-128/CCM");
  454|    388|      case 0x922AA:
  ------------------
  |  Branch (454:7): [True: 388, False: 114k]
  ------------------
  455|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 22}, "AES-192/CBC");
  456|    388|      case 0x922AD:
  ------------------
  |  Branch (456:7): [True: 388, False: 114k]
  ------------------
  457|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 25}, "KeyWrap.AES-192");
  458|    388|      case 0x922AE:
  ------------------
  |  Branch (458:7): [True: 388, False: 114k]
  ------------------
  459|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 26}, "AES-192/GCM");
  460|    392|      case 0x922AF:
  ------------------
  |  Branch (460:7): [True: 392, False: 114k]
  ------------------
  461|    392|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 27}, "AES-192/CCM");
  462|    261|      case 0x922BE:
  ------------------
  |  Branch (462:7): [True: 261, False: 114k]
  ------------------
  463|    261|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 42}, "AES-256/CBC");
  464|    261|      case 0x922C1:
  ------------------
  |  Branch (464:7): [True: 261, False: 114k]
  ------------------
  465|    261|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 45}, "KeyWrap.AES-256");
  466|    260|      case 0x922C2:
  ------------------
  |  Branch (466:7): [True: 260, False: 114k]
  ------------------
  467|    260|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 46}, "AES-256/GCM");
  468|    399|      case 0x922C3:
  ------------------
  |  Branch (468:7): [True: 399, False: 114k]
  ------------------
  469|    399|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 1, 47}, "AES-256/CCM");
  470|    388|      case 0x92356:
  ------------------
  |  Branch (470:7): [True: 388, False: 114k]
  ------------------
  471|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 1}, "SHA-256");
  472|    372|      case 0x92357:
  ------------------
  |  Branch (472:7): [True: 372, False: 114k]
  ------------------
  473|    372|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 2}, "SHA-384");
  474|    374|      case 0x92358:
  ------------------
  |  Branch (474:7): [True: 374, False: 114k]
  ------------------
  475|    374|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 3}, "SHA-512");
  476|    260|      case 0x92359:
  ------------------
  |  Branch (476:7): [True: 260, False: 114k]
  ------------------
  477|    260|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 4}, "SHA-224");
  478|    393|      case 0x9235B:
  ------------------
  |  Branch (478:7): [True: 393, False: 114k]
  ------------------
  479|    393|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 6}, "SHA-512-256");
  480|    397|      case 0x9235C:
  ------------------
  |  Branch (480:7): [True: 397, False: 114k]
  ------------------
  481|    397|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 7}, "SHA-3(224)");
  482|    390|      case 0x9235D:
  ------------------
  |  Branch (482:7): [True: 390, False: 114k]
  ------------------
  483|    390|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 8}, "SHA-3(256)");
  484|    260|      case 0x9235E:
  ------------------
  |  Branch (484:7): [True: 260, False: 114k]
  ------------------
  485|    260|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 9}, "SHA-3(384)");
  486|    389|      case 0x9235F:
  ------------------
  |  Branch (486:7): [True: 389, False: 114k]
  ------------------
  487|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 10}, "SHA-3(512)");
  488|    389|      case 0x92360:
  ------------------
  |  Branch (488:7): [True: 389, False: 114k]
  ------------------
  489|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 11}, "SHAKE-128");
  490|    286|      case 0x92361:
  ------------------
  |  Branch (490:7): [True: 286, False: 114k]
  ------------------
  491|    286|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 2, 12}, "SHAKE-256");
  492|    262|      case 0x92417:
  ------------------
  |  Branch (492:7): [True: 262, False: 114k]
  ------------------
  493|    262|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 1}, "DSA/SHA-224");
  494|    389|      case 0x92418:
  ------------------
  |  Branch (494:7): [True: 389, False: 114k]
  ------------------
  495|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 2}, "DSA/SHA-256");
  496|    266|      case 0x92419:
  ------------------
  |  Branch (496:7): [True: 266, False: 114k]
  ------------------
  497|    266|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 3}, "DSA/SHA-384");
  498|    389|      case 0x9241A:
  ------------------
  |  Branch (498:7): [True: 389, False: 114k]
  ------------------
  499|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 4}, "DSA/SHA-512");
  500|    389|      case 0x9241B:
  ------------------
  |  Branch (500:7): [True: 389, False: 114k]
  ------------------
  501|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 5}, "DSA/SHA-3(224)");
  502|    388|      case 0x9241C:
  ------------------
  |  Branch (502:7): [True: 388, False: 114k]
  ------------------
  503|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 6}, "DSA/SHA-3(256)");
  504|    281|      case 0x9241D:
  ------------------
  |  Branch (504:7): [True: 281, False: 114k]
  ------------------
  505|    281|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 7}, "DSA/SHA-3(384)");
  506|    260|      case 0x9241E:
  ------------------
  |  Branch (506:7): [True: 260, False: 114k]
  ------------------
  507|    260|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 8}, "DSA/SHA-3(512)");
  508|    388|      case 0x9241F:
  ------------------
  |  Branch (508:7): [True: 388, False: 114k]
  ------------------
  509|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 9}, "ECDSA/SHA-3(224)");
  510|    386|      case 0x92420:
  ------------------
  |  Branch (510:7): [True: 386, False: 114k]
  ------------------
  511|    386|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 10}, "ECDSA/SHA-3(256)");
  512|    388|      case 0x92421:
  ------------------
  |  Branch (512:7): [True: 388, False: 114k]
  ------------------
  513|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 11}, "ECDSA/SHA-3(384)");
  514|    389|      case 0x92422:
  ------------------
  |  Branch (514:7): [True: 389, False: 114k]
  ------------------
  515|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 12}, "ECDSA/SHA-3(512)");
  516|    132|      case 0x92423:
  ------------------
  |  Branch (516:7): [True: 132, False: 114k]
  ------------------
  517|    132|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 13}, "RSA/PKCS1v15(SHA-3(224))");
  518|    389|      case 0x92424:
  ------------------
  |  Branch (518:7): [True: 389, False: 114k]
  ------------------
  519|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 14}, "RSA/PKCS1v15(SHA-3(256))");
  520|    426|      case 0x92425:
  ------------------
  |  Branch (520:7): [True: 426, False: 114k]
  ------------------
  521|    426|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 15}, "RSA/PKCS1v15(SHA-3(384))");
  522|    400|      case 0x92426:
  ------------------
  |  Branch (522:7): [True: 400, False: 114k]
  ------------------
  523|    400|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 16}, "RSA/PKCS1v15(SHA-3(512))");
  524|    406|      case 0x92427:
  ------------------
  |  Branch (524:7): [True: 406, False: 114k]
  ------------------
  525|    406|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 17}, "ML-DSA-4x4");
  526|    389|      case 0x92428:
  ------------------
  |  Branch (526:7): [True: 389, False: 114k]
  ------------------
  527|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 18}, "ML-DSA-6x5");
  528|    418|      case 0x92429:
  ------------------
  |  Branch (528:7): [True: 418, False: 114k]
  ------------------
  529|    418|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 19}, "ML-DSA-8x7");
  530|    289|      case 0x9242A:
  ------------------
  |  Branch (530:7): [True: 289, False: 114k]
  ------------------
  531|    289|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 20}, "SLH-DSA-SHA2-128s");
  532|    388|      case 0x9242B:
  ------------------
  |  Branch (532:7): [True: 388, False: 114k]
  ------------------
  533|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 21}, "SLH-DSA-SHA2-128f");
  534|    465|      case 0x9242C:
  ------------------
  |  Branch (534:7): [True: 465, False: 114k]
  ------------------
  535|    465|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 22}, "SLH-DSA-SHA2-192s");
  536|    373|      case 0x9242D:
  ------------------
  |  Branch (536:7): [True: 373, False: 114k]
  ------------------
  537|    373|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 23}, "SLH-DSA-SHA2-192f");
  538|    260|      case 0x9242E:
  ------------------
  |  Branch (538:7): [True: 260, False: 114k]
  ------------------
  539|    260|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 24}, "SLH-DSA-SHA2-256s");
  540|    389|      case 0x9242F:
  ------------------
  |  Branch (540:7): [True: 389, False: 114k]
  ------------------
  541|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 25}, "SLH-DSA-SHA2-256f");
  542|    263|      case 0x92430:
  ------------------
  |  Branch (542:7): [True: 263, False: 114k]
  ------------------
  543|    263|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 26}, "SLH-DSA-SHAKE-128s");
  544|    264|      case 0x92431:
  ------------------
  |  Branch (544:7): [True: 264, False: 114k]
  ------------------
  545|    264|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 27}, "SLH-DSA-SHAKE-128f");
  546|    388|      case 0x92432:
  ------------------
  |  Branch (546:7): [True: 388, False: 114k]
  ------------------
  547|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 28}, "SLH-DSA-SHAKE-192s");
  548|    399|      case 0x92433:
  ------------------
  |  Branch (548:7): [True: 399, False: 114k]
  ------------------
  549|    399|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 29}, "SLH-DSA-SHAKE-192f");
  550|    404|      case 0x92434:
  ------------------
  |  Branch (550:7): [True: 404, False: 114k]
  ------------------
  551|    404|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 30}, "SLH-DSA-SHAKE-256s");
  552|    390|      case 0x92435:
  ------------------
  |  Branch (552:7): [True: 390, False: 114k]
  ------------------
  553|    390|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 3, 31}, "SLH-DSA-SHAKE-256f");
  554|    389|      case 0x924D8:
  ------------------
  |  Branch (554:7): [True: 389, False: 114k]
  ------------------
  555|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 4, 1}, "ML-KEM-512");
  556|    388|      case 0x924D9:
  ------------------
  |  Branch (556:7): [True: 388, False: 114k]
  ------------------
  557|    388|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 4, 2}, "ML-KEM-768");
  558|    389|      case 0x924DA:
  ------------------
  |  Branch (558:7): [True: 389, False: 114k]
  ------------------
  559|    389|         return if_match(oid, {2, 16, 840, 1, 101, 3, 4, 4, 3}, "ML-KEM-1024");
  560|    388|      case 0x9479F:
  ------------------
  |  Branch (560:7): [True: 388, False: 114k]
  ------------------
  561|    388|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 1, 1}, "PKIX.AuthorityInformationAccess");
  562|    391|      case 0x947A5:
  ------------------
  |  Branch (562:7): [True: 391, False: 114k]
  ------------------
  563|    391|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 1, 7}, "PKIX.IpAddrBlocks");
  564|    260|      case 0x947A6:
  ------------------
  |  Branch (564:7): [True: 260, False: 114k]
  ------------------
  565|    260|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 1, 8}, "PKIX.AutonomousSysIds");
  566|    260|      case 0x947B8:
  ------------------
  |  Branch (566:7): [True: 260, False: 114k]
  ------------------
  567|    260|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 1, 26}, "PKIX.TNAuthList");
  568|    398|      case 0x94921:
  ------------------
  |  Branch (568:7): [True: 398, False: 114k]
  ------------------
  569|    398|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 1}, "PKIX.ServerAuth");
  570|    459|      case 0x94922:
  ------------------
  |  Branch (570:7): [True: 459, False: 114k]
  ------------------
  571|    459|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 2}, "PKIX.ClientAuth");
  572|    395|      case 0x94923:
  ------------------
  |  Branch (572:7): [True: 395, False: 114k]
  ------------------
  573|    395|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 3}, "PKIX.CodeSigning");
  574|    388|      case 0x94924:
  ------------------
  |  Branch (574:7): [True: 388, False: 114k]
  ------------------
  575|    388|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 4}, "PKIX.EmailProtection");
  576|    384|      case 0x94925:
  ------------------
  |  Branch (576:7): [True: 384, False: 114k]
  ------------------
  577|    384|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 5}, "PKIX.IPsecEndSystem");
  578|    263|      case 0x94926:
  ------------------
  |  Branch (578:7): [True: 263, False: 114k]
  ------------------
  579|    263|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 6}, "PKIX.IPsecTunnel");
  580|    389|      case 0x94927:
  ------------------
  |  Branch (580:7): [True: 389, False: 114k]
  ------------------
  581|    389|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 7}, "PKIX.IPsecUser");
  582|    388|      case 0x94928:
  ------------------
  |  Branch (582:7): [True: 388, False: 114k]
  ------------------
  583|    388|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 8}, "PKIX.TimeStamping");
  584|    388|      case 0x94929:
  ------------------
  |  Branch (584:7): [True: 388, False: 114k]
  ------------------
  585|    388|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 3, 9}, "PKIX.OCSPSigning");
  586|    389|      case 0x94CEA:
  ------------------
  |  Branch (586:7): [True: 389, False: 114k]
  ------------------
  587|    389|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 8, 5}, "PKIX.XMPPAddr");
  588|    390|      case 0x94CEE:
  ------------------
  |  Branch (588:7): [True: 390, False: 114k]
  ------------------
  589|    390|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 8, 9}, "PKIX.SmtpUTF8Mailbox");
  590|    267|      case 0x954DB:
  ------------------
  |  Branch (590:7): [True: 267, False: 114k]
  ------------------
  591|    267|         return if_match(oid, {1, 3, 6, 1, 4, 1, 311, 20, 2, 2}, "Microsoft SmartcardLogon");
  592|    389|      case 0x954DC:
  ------------------
  |  Branch (592:7): [True: 389, False: 114k]
  ------------------
  593|    389|         return if_match(oid, {1, 3, 6, 1, 4, 1, 311, 20, 2, 3}, "Microsoft UPN");
  594|    391|      case 0x96B0E:
  ------------------
  |  Branch (594:7): [True: 391, False: 114k]
  ------------------
  595|    391|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 48, 1}, "PKIX.OCSP");
  596|    390|      case 0x96B0F:
  ------------------
  |  Branch (596:7): [True: 390, False: 114k]
  ------------------
  597|    390|         return if_match(oid, {1, 3, 6, 1, 5, 5, 7, 48, 2}, "PKIX.CertificateAuthorityIssuers");
  598|    327|      case 0x96C77:
  ------------------
  |  Branch (598:7): [True: 327, False: 114k]
  ------------------
  599|    327|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 1, 3}, "PBE-SHA1-3DES");
  600|    390|      case 0x96C78:
  ------------------
  |  Branch (600:7): [True: 390, False: 114k]
  ------------------
  601|    390|         return if_match(oid, {1, 2, 840, 113549, 1, 12, 1, 4}, "PBE-SHA1-2DES");
  602|    500|      case 0x9A008:
  ------------------
  |  Branch (602:7): [True: 500, False: 114k]
  ------------------
  603|    500|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 1}, "brainpool160r1");
  604|    391|      case 0x9A00A:
  ------------------
  |  Branch (604:7): [True: 391, False: 114k]
  ------------------
  605|    391|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 3}, "brainpool192r1");
  606|    388|      case 0x9A00C:
  ------------------
  |  Branch (606:7): [True: 388, False: 114k]
  ------------------
  607|    388|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 5}, "brainpool224r1");
  608|    260|      case 0x9A00E:
  ------------------
  |  Branch (608:7): [True: 260, False: 114k]
  ------------------
  609|    260|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 7}, "brainpool256r1");
  610|    360|      case 0x9A010:
  ------------------
  |  Branch (610:7): [True: 360, False: 114k]
  ------------------
  611|    360|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 9}, "brainpool320r1");
  612|    389|      case 0x9A012:
  ------------------
  |  Branch (612:7): [True: 389, False: 114k]
  ------------------
  613|    389|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 11}, "brainpool384r1");
  614|    388|      case 0x9A014:
  ------------------
  |  Branch (614:7): [True: 388, False: 114k]
  ------------------
  615|    388|         return if_match(oid, {1, 3, 36, 3, 3, 2, 8, 1, 1, 13}, "brainpool512r1");
  616|    196|      case 0xA0D61:
  ------------------
  |  Branch (616:7): [True: 196, False: 114k]
  ------------------
  617|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 3}, "McEliece");
  618|     66|      case 0xA0D63:
  ------------------
  |  Branch (618:7): [True: 66, False: 115k]
  ------------------
  619|     66|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 5}, "XMSS-draft6");
  620|     67|      case 0xA0D66:
  ------------------
  |  Branch (620:7): [True: 67, False: 115k]
  ------------------
  621|     67|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 8}, "XMSS-draft12");
  622|    194|      case 0xA0D6B:
  ------------------
  |  Branch (622:7): [True: 194, False: 114k]
  ------------------
  623|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 1, 13}, "HSS-LMS-Private-Key");
  624|    194|      case 0xA0EE1:
  ------------------
  |  Branch (624:7): [True: 194, False: 114k]
  ------------------
  625|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 1}, "Serpent/CBC");
  626|    194|      case 0xA0EE2:
  ------------------
  |  Branch (626:7): [True: 194, False: 114k]
  ------------------
  627|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 2}, "Threefish-512/CBC");
  628|    197|      case 0xA0EE3:
  ------------------
  |  Branch (628:7): [True: 197, False: 114k]
  ------------------
  629|    197|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 3}, "Twofish/CBC");
  630|    195|      case 0xA0F45:
  ------------------
  |  Branch (630:7): [True: 195, False: 114k]
  ------------------
  631|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 101}, "Serpent/GCM");
  632|    158|      case 0xA0F46:
  ------------------
  |  Branch (632:7): [True: 158, False: 114k]
  ------------------
  633|    158|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 3, 102}, "Twofish/GCM");
  634|    194|      case 0xA0FA2:
  ------------------
  |  Branch (634:7): [True: 194, False: 114k]
  ------------------
  635|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 4, 1}, "numsp256d1");
  636|    195|      case 0xA0FA3:
  ------------------
  |  Branch (636:7): [True: 195, False: 114k]
  ------------------
  637|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 4, 2}, "numsp384d1");
  638|    195|      case 0xA0FA4:
  ------------------
  |  Branch (638:7): [True: 195, False: 114k]
  ------------------
  639|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 25258, 4, 3}, "numsp512d1");
  640|    194|      case 0xA244B:
  ------------------
  |  Branch (640:7): [True: 194, False: 114k]
  ------------------
  641|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 1}, "ClassicMcEliece_348864");
  642|    194|      case 0xA244C:
  ------------------
  |  Branch (642:7): [True: 194, False: 114k]
  ------------------
  643|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 2}, "ClassicMcEliece_348864f");
  644|    194|      case 0xA244D:
  ------------------
  |  Branch (644:7): [True: 194, False: 114k]
  ------------------
  645|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 3}, "ClassicMcEliece_460896");
  646|    196|      case 0xA244E:
  ------------------
  |  Branch (646:7): [True: 196, False: 114k]
  ------------------
  647|    196|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 4}, "ClassicMcEliece_460896f");
  648|    213|      case 0xA244F:
  ------------------
  |  Branch (648:7): [True: 213, False: 114k]
  ------------------
  649|    213|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 5}, "ClassicMcEliece_6688128");
  650|    194|      case 0xA2450:
  ------------------
  |  Branch (650:7): [True: 194, False: 114k]
  ------------------
  651|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 6}, "ClassicMcEliece_6688128f");
  652|    194|      case 0xA2451:
  ------------------
  |  Branch (652:7): [True: 194, False: 114k]
  ------------------
  653|    194|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 7}, "ClassicMcEliece_6960119");
  654|    197|      case 0xA2452:
  ------------------
  |  Branch (654:7): [True: 197, False: 114k]
  ------------------
  655|    197|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 8}, "ClassicMcEliece_6960119f");
  656|    195|      case 0xA2453:
  ------------------
  |  Branch (656:7): [True: 195, False: 114k]
  ------------------
  657|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 9}, "ClassicMcEliece_8192128");
  658|    195|      case 0xA2454:
  ------------------
  |  Branch (658:7): [True: 195, False: 114k]
  ------------------
  659|    195|         return if_match(oid, {1, 3, 6, 1, 4, 1, 22554, 5, 1, 10}, "ClassicMcEliece_8192128f");
  660|    260|      case 0xAF989:
  ------------------
  |  Branch (660:7): [True: 260, False: 114k]
  ------------------
  661|    260|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 1}, "RSA");
  662|    388|      case 0xAF98A:
  ------------------
  |  Branch (662:7): [True: 388, False: 114k]
  ------------------
  663|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 2}, "RSA/PKCS1v15(MD2)");
  664|    392|      case 0xAF98C:
  ------------------
  |  Branch (664:7): [True: 392, False: 114k]
  ------------------
  665|    392|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 4}, "RSA/PKCS1v15(MD5)");
  666|    394|      case 0xAF98D:
  ------------------
  |  Branch (666:7): [True: 394, False: 114k]
  ------------------
  667|    394|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 5}, "RSA/PKCS1v15(SHA-1)");
  668|    388|      case 0xAF98F:
  ------------------
  |  Branch (668:7): [True: 388, False: 114k]
  ------------------
  669|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 7}, "RSA/OAEP");
  670|    389|      case 0xAF990:
  ------------------
  |  Branch (670:7): [True: 389, False: 114k]
  ------------------
  671|    389|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 8}, "MGF1");
  672|    389|      case 0xAF992:
  ------------------
  |  Branch (672:7): [True: 389, False: 114k]
  ------------------
  673|    389|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 10}, "RSA/PSS");
  674|    390|      case 0xAF993:
  ------------------
  |  Branch (674:7): [True: 390, False: 114k]
  ------------------
  675|    390|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 11}, "RSA/PKCS1v15(SHA-256)");
  676|    406|      case 0xAF994:
  ------------------
  |  Branch (676:7): [True: 406, False: 114k]
  ------------------
  677|    406|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 12}, "RSA/PKCS1v15(SHA-384)");
  678|    390|      case 0xAF995:
  ------------------
  |  Branch (678:7): [True: 390, False: 114k]
  ------------------
  679|    390|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 13}, "RSA/PKCS1v15(SHA-512)");
  680|    388|      case 0xAF996:
  ------------------
  |  Branch (680:7): [True: 388, False: 114k]
  ------------------
  681|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 14}, "RSA/PKCS1v15(SHA-224)");
  682|    388|      case 0xAF998:
  ------------------
  |  Branch (682:7): [True: 388, False: 114k]
  ------------------
  683|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 1, 16}, "RSA/PKCS1v15(SHA-512-256)");
  684|    260|      case 0xAFC98:
  ------------------
  |  Branch (684:7): [True: 260, False: 114k]
  ------------------
  685|    260|         return if_match(oid, {1, 2, 840, 113549, 1, 5, 12}, "PKCS5.PBKDF2");
  686|    380|      case 0xAFC99:
  ------------------
  |  Branch (686:7): [True: 380, False: 114k]
  ------------------
  687|    380|         return if_match(oid, {1, 2, 840, 113549, 1, 5, 13}, "PBE-PKCS5v20");
  688|    252|      case 0xAFE0F:
  ------------------
  |  Branch (688:7): [True: 252, False: 114k]
  ------------------
  689|    252|         return if_match(oid, {1, 2, 840, 113549, 1, 7, 1}, "PKCS7.Data");
  690|    481|      case 0xAFE14:
  ------------------
  |  Branch (690:7): [True: 481, False: 114k]
  ------------------
  691|    481|         return if_match(oid, {1, 2, 840, 113549, 1, 7, 6}, "PKCS7.EncryptedData");
  692|    388|      case 0xAFF91:
  ------------------
  |  Branch (692:7): [True: 388, False: 114k]
  ------------------
  693|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 1}, "PKCS9.EmailAddress");
  694|    388|      case 0xAFF92:
  ------------------
  |  Branch (694:7): [True: 388, False: 114k]
  ------------------
  695|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 2}, "PKCS9.UnstructuredName");
  696|    433|      case 0xAFF93:
  ------------------
  |  Branch (696:7): [True: 433, False: 114k]
  ------------------
  697|    433|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 3}, "PKCS9.ContentType");
  698|    389|      case 0xAFF94:
  ------------------
  |  Branch (698:7): [True: 389, False: 114k]
  ------------------
  699|    389|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 4}, "PKCS9.MessageDigest");
  700|    389|      case 0xAFF97:
  ------------------
  |  Branch (700:7): [True: 389, False: 114k]
  ------------------
  701|    389|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 7}, "PKCS9.ChallengePassword");
  702|    388|      case 0xAFF9E:
  ------------------
  |  Branch (702:7): [True: 388, False: 114k]
  ------------------
  703|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 14}, "PKCS9.ExtensionRequest");
  704|    389|      case 0xAFFA4:
  ------------------
  |  Branch (704:7): [True: 389, False: 114k]
  ------------------
  705|    389|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 20}, "PKCS9.FriendlyName");
  706|    388|      case 0xAFFA5:
  ------------------
  |  Branch (706:7): [True: 388, False: 114k]
  ------------------
  707|    388|         return if_match(oid, {1, 2, 840, 113549, 1, 9, 21}, "PKCS9.LocalKeyId");
  708|    389|      case 0xC0226:
  ------------------
  |  Branch (708:7): [True: 389, False: 114k]
  ------------------
  709|    389|         return if_match(oid, {1, 3, 6, 1, 4, 1, 11591, 4, 11}, "Scrypt");
  710|    252|      case 0xC0A67:
  ------------------
  |  Branch (710:7): [True: 252, False: 114k]
  ------------------
  711|    252|         return if_match(oid, {1, 3, 6, 1, 4, 1, 11591, 15, 1}, "OpenPGP.Ed25519");
  712|    260|      case 0xC4CE5:
  ------------------
  |  Branch (712:7): [True: 260, False: 114k]
  ------------------
  713|    260|         return if_match(oid, {1, 2, 643, 100, 1}, "GOST.OGRN");
  714|    261|      case 0xC4D53:
  ------------------
  |  Branch (714:7): [True: 261, False: 114k]
  ------------------
  715|    261|         return if_match(oid, {1, 2, 643, 100, 111}, "GOST.SubjectSigningTool");
  716|    269|      case 0xC4D54:
  ------------------
  |  Branch (716:7): [True: 269, False: 114k]
  ------------------
  717|    269|         return if_match(oid, {1, 2, 643, 100, 112}, "GOST.IssuerSigningTool");
  718|    415|      case 0xC9C50:
  ------------------
  |  Branch (718:7): [True: 415, False: 114k]
  ------------------
  719|    415|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 1}, "secp192r1");
  720|    260|      case 0xC9C51:
  ------------------
  |  Branch (720:7): [True: 260, False: 114k]
  ------------------
  721|    260|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 2}, "x962_p192v2");
  722|    392|      case 0xC9C52:
  ------------------
  |  Branch (722:7): [True: 392, False: 114k]
  ------------------
  723|    392|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 3}, "x962_p192v3");
  724|    372|      case 0xC9C53:
  ------------------
  |  Branch (724:7): [True: 372, False: 114k]
  ------------------
  725|    372|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 4}, "x962_p239v1");
  726|    389|      case 0xC9C54:
  ------------------
  |  Branch (726:7): [True: 389, False: 114k]
  ------------------
  727|    389|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 5}, "x962_p239v2");
  728|    388|      case 0xC9C55:
  ------------------
  |  Branch (728:7): [True: 388, False: 114k]
  ------------------
  729|    388|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 6}, "x962_p239v3");
  730|    267|      case 0xC9C56:
  ------------------
  |  Branch (730:7): [True: 267, False: 114k]
  ------------------
  731|    267|         return if_match(oid, {1, 2, 840, 10045, 3, 1, 7}, "secp256r1");
  732|    388|      case 0xCFA13:
  ------------------
  |  Branch (732:7): [True: 388, False: 114k]
  ------------------
  733|    388|         return if_match(oid, {1, 2, 840, 10040, 4, 1}, "DSA");
  734|    389|      case 0xCFA15:
  ------------------
  |  Branch (734:7): [True: 389, False: 114k]
  ------------------
  735|    389|         return if_match(oid, {1, 2, 840, 10040, 4, 3}, "DSA/SHA-1");
  736|  7.96k|      default:
  ------------------
  |  Branch (736:7): [True: 7.96k, False: 107k]
  ------------------
  737|  7.96k|         return {};
  738|   115k|   }
  739|   115k|}
_ZN5Botan7OID_Map16load_oid2str_mapEv:
 1435|      1|std::unordered_map<OID, std::string> OID_Map::load_oid2str_map() {
 1436|      1|   return {
 1437|      1|      {OID{2, 5, 8, 1, 1}, "RSA"},
 1438|      1|      {OID{1, 3, 6, 1, 4, 1, 8301, 3, 1, 2, 9, 0, 38}, "secp521r1"},
 1439|      1|      {OID{1, 2, 643, 2, 2, 35, 1}, "gost_256A"},
 1440|      1|      {OID{1, 2, 643, 2, 2, 36, 0}, "gost_256A"},
 1441|      1|   };
 1442|      1|}
_ZN5Botan7OID_Map16load_str2oid_mapEv:
 1444|      1|std::unordered_map<std::string, OID> OID_Map::load_str2oid_map() {
 1445|      1|   return {
 1446|      1|      {"Curve25519", OID{1, 3, 101, 110}},
 1447|      1|      {"SM2_Sig", OID{1, 2, 156, 10197, 1, 301, 1}},
 1448|      1|      {"RSA/EMSA3(MD2)", OID{1, 2, 840, 113549, 1, 1, 2}},
 1449|      1|      {"RSA/EMSA3(MD5)", OID{1, 2, 840, 113549, 1, 1, 4}},
 1450|      1|      {"RSA/EMSA3(SHA-1)", OID{1, 2, 840, 113549, 1, 1, 5}},
 1451|      1|      {"RSA/EMSA3(SHA-256)", OID{1, 2, 840, 113549, 1, 1, 11}},
 1452|      1|      {"RSA/EMSA3(SHA-384)", OID{1, 2, 840, 113549, 1, 1, 12}},
 1453|      1|      {"RSA/EMSA3(SHA-512)", OID{1, 2, 840, 113549, 1, 1, 13}},
 1454|      1|      {"RSA/EMSA3(SHA-224)", OID{1, 2, 840, 113549, 1, 1, 14}},
 1455|      1|      {"RSA/EMSA3(SHA-512-256)", OID{1, 2, 840, 113549, 1, 1, 16}},
 1456|      1|      {"RSA/EMSA3(SHA-3(224))", OID{2, 16, 840, 1, 101, 3, 4, 3, 13}},
 1457|      1|      {"RSA/EMSA3(SHA-3(256))", OID{2, 16, 840, 1, 101, 3, 4, 3, 14}},
 1458|      1|      {"RSA/EMSA3(SHA-3(384))", OID{2, 16, 840, 1, 101, 3, 4, 3, 15}},
 1459|      1|      {"RSA/EMSA3(SHA-3(512))", OID{2, 16, 840, 1, 101, 3, 4, 3, 16}},
 1460|      1|      {"RSA/EMSA3(SM3)", OID{1, 2, 156, 10197, 1, 504}},
 1461|      1|      {"RSA/EMSA3(RIPEMD-160)", OID{1, 3, 36, 3, 3, 1, 2}},
 1462|      1|      {"RSA/EMSA4", OID{1, 2, 840, 113549, 1, 1, 10}},
 1463|      1|      {"PBES2", OID{1, 2, 840, 113549, 1, 5, 13}},
 1464|      1|   };
 1465|      1|}
static_oids.cpp:_ZN5Botan12_GLOBAL__N_18if_matchERKNS_3OIDESt16initializer_listIjENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
   18|   107k|std::optional<std::string_view> if_match(const OID& oid, std::initializer_list<uint32_t> val, std::string_view name) {
   19|   107k|   if(oid.matches(val)) {
  ------------------
  |  Branch (19:7): [True: 42.6k, False: 64.4k]
  ------------------
   20|  42.6k|      return name;
   21|  64.4k|   } else {
   22|  64.4k|      return {};
   23|  64.4k|   }
   24|   107k|}

_ZN5Botan6BigInt4Data11set_to_zeroEv:
  191|  3.13k|void BigInt::Data::set_to_zero() {
  192|  3.13k|   m_reg.resize(m_reg.capacity());
  193|  3.13k|   clear_mem(m_reg.data(), m_reg.size());
  194|  3.13k|   m_sig_words = 0;
  195|  3.13k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  215|    739|size_t BigInt::Data::calc_sig_words() const {
  216|    739|   const size_t sz = m_reg.size();
  217|    739|   size_t sig = sz;
  218|       |
  219|    739|   word sub = 1;
  220|       |
  221|  9.15k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (221:22): [True: 8.41k, False: 739]
  ------------------
  222|  8.41k|      const word w = m_reg[sz - i - 1];
  223|  8.41k|      sub &= ct_is_zero(w);
  224|  8.41k|      sig -= sub;
  225|  8.41k|   }
  226|       |
  227|       |   /*
  228|       |   * This depends on the data so is poisoned, but unpoison it here as
  229|       |   * later conditionals are made on the size.
  230|       |   */
  231|    739|   CT::unpoison(sig);
  232|       |
  233|    739|   return sig;
  234|    739|}
_ZN5Botan6BigInt17assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  425|  2.27k|void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {
  426|  2.27k|   clear();
  427|       |
  428|  2.27k|   const size_t length = bytes.size();
  429|  2.27k|   const size_t full_words = length / sizeof(word);
  430|  2.27k|   const size_t extra_bytes = length % sizeof(word);
  431|       |
  432|  2.27k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (432:52): [True: 2.02k, False: 244]
  ------------------
  433|       |
  434|  7.43k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (434:22): [True: 5.16k, False: 2.27k]
  ------------------
  435|  5.16k|      reg[i] = load_be<word>(bytes.last<sizeof(word)>());
  436|  5.16k|      bytes = bytes.first(bytes.size() - sizeof(word));
  437|  5.16k|   }
  438|       |
  439|  2.27k|   if(!bytes.empty()) {
  ------------------
  |  Branch (439:7): [True: 2.02k, False: 244]
  ------------------
  440|  2.02k|      BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());
  ------------------
  |  |   77|  2.02k|   do {                                                                     \
  |  |   78|  2.02k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  2.02k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 2.02k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  2.02k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 2.02k]
  |  |  ------------------
  ------------------
  441|  2.02k|      std::array<uint8_t, sizeof(word)> last_partial_word = {0};
  442|  2.02k|      copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);
  443|  2.02k|      reg[full_words] = load_be<word>(last_partial_word);
  444|  2.02k|   }
  445|       |
  446|  2.27k|   m_data.swap(reg);
  447|  2.27k|}
_ZNK5Botan6BigInt20_const_time_unpoisonEv:
  559|  3.13k|void BigInt::_const_time_unpoison() const {
  560|  3.13k|   CT::unpoison(m_data.const_data(), m_data.size());
  561|  3.13k|}

_ZN5Botan15allocate_memoryEmm:
   21|   200k|BOTAN_MALLOC_FN void* allocate_memory(size_t elems, size_t elem_size) {
   22|   200k|   if(elems == 0 || elem_size == 0) {
  ------------------
  |  Branch (22:7): [True: 0, False: 200k]
  |  Branch (22:21): [True: 0, False: 200k]
  ------------------
   23|      0|      return nullptr;
   24|      0|   }
   25|       |
   26|       |   // Some calloc implementations do not check for overflow (?!?)
   27|   200k|   if(!checked_mul(elems, elem_size).has_value()) {
  ------------------
  |  Branch (27:7): [True: 0, False: 200k]
  ------------------
   28|      0|      throw std::bad_alloc();
   29|      0|   }
   30|       |
   31|       |#if defined(BOTAN_HAS_LOCKING_ALLOCATOR)
   32|       |   // NOLINTNEXTLINE(*-const-correctness) bug in clang-tidy
   33|       |   if(void* p = mlock_allocator::instance().allocate(elems, elem_size)) {
   34|       |      return p;
   35|       |   }
   36|       |#endif
   37|       |
   38|       |#if defined(BOTAN_TARGET_OS_HAS_ALLOC_CONCEAL)
   39|       |   void* ptr = ::calloc_conceal(elems, elem_size);
   40|       |#else
   41|       |   // NOLINTNEXTLINE(*-const-correctness) bug in clang-tidy
   42|   200k|   void* ptr = std::calloc(elems, elem_size);  // NOLINT(*-no-malloc,*-owning-memory)
   43|   200k|#endif
   44|   200k|   if(ptr == nullptr) {
  ------------------
  |  Branch (44:7): [True: 0, False: 200k]
  ------------------
   45|      0|      [[unlikely]] throw std::bad_alloc();
   46|      0|   }
   47|   200k|   return ptr;
   48|   200k|}
_ZN5Botan17deallocate_memoryEPvmm:
   50|   200k|void deallocate_memory(void* p, size_t elems, size_t elem_size) {
   51|   200k|   if(p == nullptr) {
  ------------------
  |  Branch (51:7): [True: 0, False: 200k]
  ------------------
   52|      0|      [[unlikely]] return;
   53|      0|   }
   54|       |
   55|   200k|   secure_scrub_memory(p, elems * elem_size);
   56|       |
   57|       |#if defined(BOTAN_HAS_LOCKING_ALLOCATOR)
   58|       |   if(mlock_allocator::instance().deallocate(p, elems, elem_size)) {
   59|       |      return;
   60|       |   }
   61|       |#endif
   62|       |
   63|   200k|   std::free(p);  // NOLINT(*-no-malloc,*-owning-memory)
   64|   200k|}

_ZN5Botan22throw_invalid_argumentEPKcS1_S1_:
   23|  1.00k|void throw_invalid_argument(const char* message, const char* func, const char* file) {
   24|  1.00k|   throw Invalid_Argument(fmt("{} in {}:{}", message, func, file));
   25|  1.00k|}

_ZN5Botan13is_valid_utf8ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  106|  2.25k|bool is_valid_utf8(std::string_view utf8) {
  107|  2.25k|   try {
  108|  2.25k|      size_t pos = 0;
  109|  10.4k|      while(pos < utf8.size()) {
  ------------------
  |  Branch (109:13): [True: 8.24k, False: 2.25k]
  ------------------
  110|  8.24k|         const uint32_t c = next_utf8_codepoint(utf8, pos);
  111|  8.24k|         BOTAN_UNUSED(c);
  ------------------
  |  |  144|  8.24k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  112|  8.24k|      }
  113|  2.25k|   } catch(Decoding_Error&) {
  114|  1.29k|      return false;
  115|  1.29k|   }
  116|    959|   return true;
  117|  2.25k|}
_ZN5Botan12ucs2_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  119|  1.40k|std::string ucs2_to_utf8(std::span<const uint8_t> ucs2) {
  120|  1.40k|   if(ucs2.size() % 2 != 0) {
  ------------------
  |  Branch (120:7): [True: 406, False: 1.00k]
  ------------------
  121|    406|      throw Decoding_Error("Invalid length for UCS-2 string");
  122|    406|   }
  123|       |
  124|  1.00k|   const size_t chars = ucs2.size() / 2;
  125|       |
  126|  1.00k|   std::string s;
  127|  8.88k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (127:22): [True: 7.87k, False: 1.00k]
  ------------------
  128|  7.87k|      const uint32_t c = load_be<uint16_t>(ucs2.data(), i);
  129|  7.87k|      append_utf8_for(s, c);
  130|  7.87k|   }
  131|       |
  132|  1.00k|   return s;
  133|  1.40k|}
_ZN5Botan12ucs4_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  153|  1.09k|std::string ucs4_to_utf8(std::span<const uint8_t> ucs4) {
  154|  1.09k|   if(ucs4.size() % 4 != 0) {
  ------------------
  |  Branch (154:7): [True: 259, False: 833]
  ------------------
  155|    259|      throw Decoding_Error("Invalid length for UCS-4 string");
  156|    259|   }
  157|       |
  158|    833|   const size_t chars = ucs4.size() / 4;
  159|       |
  160|    833|   std::string s;
  161|  2.25k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (161:22): [True: 1.42k, False: 833]
  ------------------
  162|  1.42k|      const uint32_t c = load_be<uint32_t>(ucs4.data(), i);
  163|  1.42k|      append_utf8_for(s, c);
  164|  1.42k|   }
  165|       |
  166|    833|   return s;
  167|  1.09k|}
_ZN5Botan14latin1_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  188|    845|std::string latin1_to_utf8(std::span<const uint8_t> chars) {
  189|    845|   std::string s;
  190|  6.94k|   for(const uint8_t b : chars) {
  ------------------
  |  Branch (190:24): [True: 6.94k, False: 845]
  ------------------
  191|  6.94k|      append_utf8_for(s, static_cast<uint32_t>(b));
  192|  6.94k|   }
  193|    845|   return s;
  194|    845|}
charset.cpp:_ZN5Botan12_GLOBAL__N_119next_utf8_codepointENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERm:
   52|  8.24k|uint32_t next_utf8_codepoint(std::string_view utf8, size_t& pos) {
   53|  8.24k|   auto read_continuation = [&]() -> uint32_t {
   54|  8.24k|      if(pos >= utf8.size()) {
   55|  8.24k|         throw Decoding_Error("Invalid UTF-8 sequence");
   56|  8.24k|      }
   57|  8.24k|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   58|  8.24k|      if((b & 0xC0) != 0x80) {
   59|  8.24k|         throw Decoding_Error("Invalid UTF-8 sequence");
   60|  8.24k|      }
   61|  8.24k|      return b & 0x3F;
   62|  8.24k|   };
   63|       |
   64|  8.24k|   const uint8_t lead = static_cast<uint8_t>(utf8[pos++]);
   65|  8.24k|   uint32_t c = 0;
   66|       |
   67|  8.24k|   if(lead <= 0x7F) {
  ------------------
  |  Branch (67:7): [True: 5.93k, False: 2.30k]
  ------------------
   68|  5.93k|      c = lead;
   69|  5.93k|   } else if((lead & 0xE0) == 0xC0) {
  ------------------
  |  Branch (69:14): [True: 512, False: 1.79k]
  ------------------
   70|    512|      c = (lead & 0x1F) << 6;
   71|    512|      c |= read_continuation();
   72|    512|      if(c < 0x80) {
  ------------------
  |  Branch (72:10): [True: 67, False: 445]
  ------------------
   73|     67|         throw Decoding_Error("Overlong UTF-8 sequence");
   74|     67|      }
   75|  1.79k|   } else if((lead & 0xF0) == 0xE0) {
  ------------------
  |  Branch (75:14): [True: 1.00k, False: 791]
  ------------------
   76|  1.00k|      c = (lead & 0x0F) << 12;
   77|  1.00k|      c |= read_continuation() << 6;
   78|  1.00k|      c |= read_continuation();
   79|  1.00k|      if(c < 0x800) {
  ------------------
  |  Branch (79:10): [True: 91, False: 914]
  ------------------
   80|     91|         throw Decoding_Error("Overlong UTF-8 sequence");
   81|     91|      }
   82|  1.00k|   } else if((lead & 0xF8) == 0xF0) {
  ------------------
  |  Branch (82:14): [True: 435, False: 356]
  ------------------
   83|    435|      c = (lead & 0x07) << 18;
   84|    435|      c |= read_continuation() << 12;
   85|    435|      c |= read_continuation() << 6;
   86|    435|      c |= read_continuation();
   87|    435|      if(c < 0x10000) {
  ------------------
  |  Branch (87:10): [True: 38, False: 397]
  ------------------
   88|     38|         throw Decoding_Error("Overlong UTF-8 sequence");
   89|     38|      }
   90|    435|   } else {
   91|    356|      throw Decoding_Error("Invalid UTF-8 sequence");
   92|    356|   }
   93|       |
   94|  7.69k|   if(c > 0x10FFFF) {
  ------------------
  |  Branch (94:7): [True: 68, False: 7.62k]
  ------------------
   95|     68|      throw Decoding_Error("UTF-8 sequence encodes value outside Unicode range");
   96|     68|   }
   97|  7.62k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (97:7): [True: 829, False: 6.79k]
  |  Branch (97:22): [True: 211, False: 618]
  ------------------
   98|    211|      throw Decoding_Error("UTF-8 sequence encodes surrogate code point");
   99|    211|   }
  100|       |
  101|  7.41k|   return c;
  102|  7.62k|}
charset.cpp:_ZZN5Botan12_GLOBAL__N_119next_utf8_codepointENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERmENK3$_0clEv:
   53|  3.78k|   auto read_continuation = [&]() -> uint32_t {
   54|  3.78k|      if(pos >= utf8.size()) {
  ------------------
  |  Branch (54:10): [True: 204, False: 3.57k]
  ------------------
   55|    204|         throw Decoding_Error("Invalid UTF-8 sequence");
   56|    204|      }
   57|  3.57k|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   58|  3.57k|      if((b & 0xC0) != 0x80) {
  ------------------
  |  Branch (58:10): [True: 260, False: 3.31k]
  ------------------
   59|    260|         throw Decoding_Error("Invalid UTF-8 sequence");
   60|    260|      }
   61|  3.31k|      return b & 0x3F;
   62|  3.57k|   };
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   18|  16.2k|void append_utf8_for(std::string& s, uint32_t c) {
   19|  16.2k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (19:7): [True: 2.10k, False: 14.1k]
  |  Branch (19:22): [True: 273, False: 1.82k]
  ------------------
   20|    273|      throw Decoding_Error("Invalid Unicode character");
   21|    273|   }
   22|       |
   23|  15.9k|   if(c <= 0x7F) {
  ------------------
  |  Branch (23:7): [True: 5.33k, False: 10.6k]
  ------------------
   24|  5.33k|      const uint8_t b0 = static_cast<uint8_t>(c);
   25|  5.33k|      s.push_back(static_cast<char>(b0));
   26|  10.6k|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (26:14): [True: 4.31k, False: 6.32k]
  ------------------
   27|  4.31k|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   28|  4.31k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   29|  4.31k|      s.push_back(static_cast<char>(b0));
   30|  4.31k|      s.push_back(static_cast<char>(b1));
   31|  6.32k|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (31:14): [True: 5.22k, False: 1.09k]
  ------------------
   32|  5.22k|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   33|  5.22k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   34|  5.22k|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   35|  5.22k|      s.push_back(static_cast<char>(b0));
   36|  5.22k|      s.push_back(static_cast<char>(b1));
   37|  5.22k|      s.push_back(static_cast<char>(b2));
   38|  5.22k|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (38:14): [True: 779, False: 319]
  ------------------
   39|    779|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   40|    779|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   41|    779|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   42|    779|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   43|    779|      s.push_back(static_cast<char>(b0));
   44|    779|      s.push_back(static_cast<char>(b1));
   45|    779|      s.push_back(static_cast<char>(b2));
   46|    779|      s.push_back(static_cast<char>(b3));
   47|    779|   } else {
   48|    319|      throw Decoding_Error("Invalid Unicode character");
   49|    319|   }
   50|  15.9k|}

_ZN5Botan10DataSource9read_byteERh:
   27|   340k|size_t DataSource::read_byte(uint8_t& out) {
   28|   340k|   return read(&out, 1);
   29|   340k|}
_ZN5Botan10DataSource9read_byteEv:
   34|   363k|std::optional<uint8_t> DataSource::read_byte() {
   35|   363k|   uint8_t b = 0;
   36|   363k|   if(this->read(&b, 1) == 1) {
  ------------------
  |  Branch (36:7): [True: 348k, False: 15.3k]
  ------------------
   37|   348k|      return b;
   38|   348k|   } else {
   39|  15.3k|      return {};
   40|  15.3k|   }
   41|   363k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   73|  1.03M|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   74|  1.03M|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   75|  1.03M|   copy_mem(out, m_source.data() + m_offset, got);
   76|  1.03M|   m_offset += got;
   77|  1.03M|   return got;
   78|  1.03M|}
_ZN5Botan17DataSource_Memory15check_availableEm:
   80|   332k|bool DataSource_Memory::check_available(size_t n) {
   81|   332k|   return (n <= (m_source.size() - m_offset));
   82|   332k|}
_ZNK5Botan17DataSource_Memory4peekEPhmm:
   87|  93.6k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   88|  93.6k|   const size_t bytes_left = m_source.size() - m_offset;
   89|  93.6k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (89:7): [True: 1.24k, False: 92.3k]
  ------------------
   90|  1.24k|      return 0;
   91|  1.24k|   }
   92|       |
   93|  92.3k|   const size_t got = std::min(bytes_left - peek_offset, length);
   94|  92.3k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   95|  92.3k|   return got;
   96|  93.6k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  28.7k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|  3.58k|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  25.1k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}

_ZN5Botan19secure_scrub_memoryEPvm:
   25|   750k|void secure_scrub_memory(void* ptr, size_t n) {
   26|   750k|   return secure_zeroize_buffer(ptr, n);
   27|   750k|}
_ZN5Botan21secure_zeroize_bufferEPvm:
   29|   750k|void secure_zeroize_buffer(void* ptr, size_t n) {
   30|   750k|   if(n == 0) {
  ------------------
  |  Branch (30:7): [True: 392k, False: 357k]
  ------------------
   31|   392k|      return;
   32|   392k|   }
   33|       |
   34|       |#if defined(BOTAN_TARGET_OS_HAS_RTLSECUREZEROMEMORY)
   35|       |   ::RtlSecureZeroMemory(ptr, n);
   36|       |
   37|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_BZERO)
   38|   357k|   ::explicit_bzero(ptr, n);
   39|       |
   40|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_MEMSET)
   41|       |   (void)::explicit_memset(ptr, 0, n);
   42|       |
   43|       |#else
   44|       |   /*
   45|       |   * Call memset through a static volatile pointer, which the compiler should
   46|       |   * not elide. This construct should be safe in conforming compilers, but who
   47|       |   * knows. This has been checked to generate the expected code, which saves the
   48|       |   * memset address in the data segment and unconditionally loads and jumps to
   49|       |   * that address, with the following targets:
   50|       |   *
   51|       |   * x86-64: Clang 19, GCC 6, 11, 13, 14
   52|       |   * riscv64: GCC 14
   53|       |   * aarch64: GCC 14
   54|       |   * armv7: GCC 14
   55|       |   *
   56|       |   * Actually all of them generated the expected jump even without marking the
   57|       |   * function pointer as volatile. However this seems worth including as an
   58|       |   * additional precaution.
   59|       |   */
   60|       |   static void* (*const volatile memset_ptr)(void*, int, size_t) = std::memset;
   61|       |   (memset_ptr)(ptr, 0, n);
   62|       |#endif
   63|   357k|}

_ZN5Botan9to_u32bitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   30|  19.8k|uint32_t to_u32bit(std::string_view str_view) {
   31|  19.8k|   const std::string str(str_view);
   32|       |
   33|       |   // std::stoul is not strict enough. Ensure that str is digit only [0-9]*
   34|  41.1k|   for(const char chr : str) {
  ------------------
  |  Branch (34:23): [True: 41.1k, False: 19.3k]
  ------------------
   35|  41.1k|      if(chr < '0' || chr > '9') {
  ------------------
  |  Branch (35:10): [True: 218, False: 40.9k]
  |  Branch (35:23): [True: 323, False: 40.6k]
  ------------------
   36|    541|         throw Invalid_Argument("to_u32bit invalid decimal string '" + str + "'");
   37|    541|      }
   38|  41.1k|   }
   39|       |
   40|  19.3k|   const unsigned long int x = std::stoul(str);
   41|       |
   42|  19.3k|   if constexpr(sizeof(unsigned long int) > 4) {
   43|       |      // x might be uint64
   44|  19.3k|      if(x > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (44:10): [True: 0, False: 19.3k]
  ------------------
   45|      0|         throw Invalid_Argument("Integer value of " + str + " exceeds 32 bit range");
   46|      0|      }
   47|  19.3k|   }
   48|       |
   49|  19.3k|   return static_cast<uint32_t>(x);
   50|  19.8k|}