_ZN5Botan8high_bitIjEEmT_:
   60|  1.48k|{
   61|  1.48k|   size_t hb = 0;
   62|       |
   63|  8.90k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 7.42k, False: 1.48k]
  ------------------
   64|  7.42k|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|  7.42k|      hb += z;
   66|  7.42k|      n >>= z;
   67|  7.42k|   }
   68|       |
   69|  1.48k|   hb += n;
   70|       |
   71|  1.48k|   return hb;
   72|  1.48k|}
_ZN5Botan10ct_is_zeroIjEET_S1_:
   35|  7.42k|{
   36|  7.42k|   return expand_top_bit<T>(~x & (x - 1));
   37|  7.42k|}
_ZN5Botan14expand_top_bitIjEET_S1_:
   25|  7.42k|{
   26|  7.42k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  7.42k|}
_ZN5Botan17significant_bytesImEEmT_:
   82|  2.14k|{
   83|  2.14k|   size_t b = 0;
   84|       |
   85|  8.58k|   for(size_t s = 8 * sizeof(n) / 2; s >= 8; s /= 2) {
  ------------------
  |  Branch (85:38): [True: 6.43k, False: 2.14k]
  ------------------
   86|  6.43k|      const size_t z = s * (~ct_is_zero(n >> s) & 1);
   87|  6.43k|      b += z / 8;
   88|  6.43k|      n >>= z;
   89|  6.43k|   }
   90|       |
   91|  2.14k|   b += (n != 0);
   92|       |
   93|  2.14k|   return b;
   94|  2.14k|}
_ZN5Botan10ct_is_zeroImEET_S1_:
   35|  19.8k|{
   36|  19.8k|   return expand_top_bit<T>(~x & (x - 1));
   37|  19.8k|}
_ZN5Botan14expand_top_bitImEET_S1_:
   25|  19.8k|{
   26|  19.8k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  19.8k|}

_ZN5Botan13reverse_bytesEt:
   19|  13.8k|inline constexpr uint16_t reverse_bytes(uint16_t x) {
   20|  13.8k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   21|  13.8k|   return __builtin_bswap16(x);
   22|       |#else
   23|       |   return static_cast<uint16_t>((x << 8) | (x >> 8));
   24|       |#endif
   25|  13.8k|}
_ZN5Botan13reverse_bytesEj:
   33|  2.35k|inline constexpr uint32_t reverse_bytes(uint32_t x) {
   34|  2.35k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   35|  2.35k|   return __builtin_bswap32(x);
   36|       |#else
   37|       |   // MSVC at least recognizes this as a bswap
   38|       |   return ((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) | ((x & 0xFF000000) >> 24);
   39|       |#endif
   40|  2.35k|}
_ZN5Botan13reverse_bytesEm:
   48|  10.3k|inline constexpr uint64_t reverse_bytes(uint64_t x) {
   49|  10.3k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   50|  10.3k|   return __builtin_bswap64(x);
   51|       |#else
   52|       |   uint32_t hi = static_cast<uint32_t>(x >> 32);
   53|       |   uint32_t lo = static_cast<uint32_t>(x);
   54|       |
   55|       |   hi = reverse_bytes(hi);
   56|       |   lo = reverse_bytes(lo);
   57|       |
   58|       |   return (static_cast<uint64_t>(lo) << 32) | hi;
   59|       |#endif
   60|  10.3k|}

_ZN5Botan2CT4MaskIhE3setEv:
   99|  4.13k|      static Mask<T> set() { return Mask<T>(static_cast<T>(~0)); }
_ZN5Botan2CT4MaskIhEC2Eh:
  280|  4.13k|      Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskIhE5valueEv:
  277|  4.13k|      T value() const { return m_mask; }
_ZNK5Botan2CT4MaskIhE7as_boolEv:
  272|  4.13k|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskIhE16unpoisoned_valueEv:
  263|  4.13k|      T unpoisoned_value() const {
  264|  4.13k|         T r = value();
  265|  4.13k|         CT::unpoison(r);
  266|  4.13k|         return r;
  267|  4.13k|      }
_ZN5Botan2CT8unpoisonIhEEvRT_:
   64|  4.13k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  4.13k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  4.13k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  4.13k|#endif
   70|  4.13k|}
_ZN5Botan2CT8unpoisonImEEvRT_:
   64|    635|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|    635|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|    635|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|    635|#endif
   70|    635|}

_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    863|std::string fmt(std::string_view format, const T&... args) {
   54|    863|   std::ostringstream oss;
   55|    863|   oss.imbue(std::locale::classic());
   56|    863|   fmt_detail::do_fmt(oss, format, args...);
   57|    863|   return oss.str();
   58|    863|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJS8_EEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    863|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    863|   size_t i = 0;
   27|       |
   28|    863|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 863, False: 0]
  ------------------
   29|    863|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 863, False: 0]
  |  Branch (29:30): [True: 863, False: 0]
  |  Branch (29:59): [True: 863, False: 0]
  ------------------
   30|    863|         oss << val;
   31|    863|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    863|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    863|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    863|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    863|   size_t i = 0;
   27|       |
   28|  2.58k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 2.58k, False: 0]
  ------------------
   29|  2.58k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 863, False: 1.72k]
  |  Branch (29:30): [True: 863, False: 0]
  |  Branch (29:59): [True: 863, False: 0]
  ------------------
   30|    863|         oss << val;
   31|    863|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  1.72k|      } else {
   33|  1.72k|         oss << format[i];
   34|  1.72k|      }
   35|       |
   36|  1.72k|      i += 1;
   37|  1.72k|   }
   38|    863|}
_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  13.0k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  13.0k|   oss << format;
   22|  13.0k|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|  1.60k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.60k|   size_t i = 0;
   27|       |
   28|  4.80k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.80k, False: 0]
  ------------------
   29|  4.80k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.60k, False: 3.20k]
  |  Branch (29:30): [True: 1.60k, False: 0]
  |  Branch (29:59): [True: 1.60k, False: 0]
  ------------------
   30|  1.60k|         oss << val;
   31|  1.60k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.20k|      } else {
   33|  3.20k|         oss << format[i];
   34|  3.20k|      }
   35|       |
   36|  3.20k|      i += 1;
   37|  3.20k|   }
   38|  1.60k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  9.69k|std::string fmt(std::string_view format, const T&... args) {
   54|  9.69k|   std::ostringstream oss;
   55|  9.69k|   oss.imbue(std::locale::classic());
   56|  9.69k|   fmt_detail::do_fmt(oss, format, args...);
   57|  9.69k|   return oss.str();
   58|  9.69k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  9.69k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  9.69k|   size_t i = 0;
   27|       |
   28|  89.1k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 89.1k, False: 0]
  ------------------
   29|  89.1k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 9.69k, False: 79.4k]
  |  Branch (29:30): [True: 9.69k, False: 0]
  |  Branch (29:59): [True: 9.69k, False: 0]
  ------------------
   30|  9.69k|         oss << val;
   31|  9.69k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  79.4k|      } else {
   33|  79.4k|         oss << format[i];
   34|  79.4k|      }
   35|       |
   36|  79.4k|      i += 1;
   37|  79.4k|   }
   38|  9.69k|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|    849|std::string fmt(std::string_view format, const T&... args) {
   54|    849|   std::ostringstream oss;
   55|    849|   oss.imbue(std::locale::classic());
   56|    849|   fmt_detail::do_fmt(oss, format, args...);
   57|    849|   return oss.str();
   58|    849|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    849|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    849|   size_t i = 0;
   27|       |
   28|    849|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 849, False: 0]
  ------------------
   29|    849|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 849, False: 0]
  |  Branch (29:30): [True: 849, False: 0]
  |  Branch (29:59): [True: 849, False: 0]
  ------------------
   30|    849|         oss << val;
   31|    849|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    849|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    849|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    849|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    849|   size_t i = 0;
   27|       |
   28|  4.24k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.24k, False: 0]
  ------------------
   29|  4.24k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 849, False: 3.39k]
  |  Branch (29:30): [True: 849, False: 0]
  |  Branch (29:59): [True: 849, False: 0]
  ------------------
   30|    849|         oss << val;
   31|    849|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.39k|      } else {
   33|  3.39k|         oss << format[i];
   34|  3.39k|      }
   35|       |
   36|  3.39k|      i += 1;
   37|  3.39k|   }
   38|    849|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    849|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    849|   size_t i = 0;
   27|       |
   28|  1.69k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.69k, False: 0]
  ------------------
   29|  1.69k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 849, False: 849]
  |  Branch (29:30): [True: 849, False: 0]
  |  Branch (29:59): [True: 849, False: 0]
  ------------------
   30|    849|         oss << val;
   31|    849|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    849|      } else {
   33|    849|         oss << format[i];
   34|    849|      }
   35|       |
   36|    849|      i += 1;
   37|    849|   }
   38|    849|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  1.60k|std::string fmt(std::string_view format, const T&... args) {
   54|  1.60k|   std::ostringstream oss;
   55|  1.60k|   oss.imbue(std::locale::classic());
   56|  1.60k|   fmt_detail::do_fmt(oss, format, args...);
   57|  1.60k|   return oss.str();
   58|  1.60k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  1.60k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.60k|   size_t i = 0;
   27|       |
   28|  1.60k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.60k, False: 0]
  ------------------
   29|  1.60k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.60k, False: 0]
  |  Branch (29:30): [True: 1.60k, False: 0]
  |  Branch (29:59): [True: 1.60k, False: 0]
  ------------------
   30|  1.60k|         oss << val;
   31|  1.60k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  1.60k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  1.60k|}

_ZN5Botan8get_byteILm0EmEEhT0_:
   39|  3.54k|{
   40|  3.54k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  3.54k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  3.54k|}
_ZN5Botan12get_byte_varImEEhmT_:
   27|  3.26k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   28|  3.26k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   29|  3.26k|}
_ZN5Botan7load_beImEET_PKhm:
  226|  10.3k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  10.3k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  10.3k|}
_ZN5Botan7load_beImNSt3__14spanIKhLm8EEEEET_OT0_:
   92|  10.3k|inline constexpr T load_be(InR&& in_range) {
   93|  10.3k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  10.3k|   std::span in{in_range};
   95|  10.3k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  10.3k|      return static_cast<T>(in[0]);
   97|  10.3k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  10.3k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  10.3k|   }
  109|  10.3k|}
_ZN5Botan7load_beItEET_PKhm:
  226|  13.8k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  13.8k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  13.8k|}
_ZN5Botan7load_beItNSt3__14spanIKhLm2EEEEET_OT0_:
   92|  13.8k|inline constexpr T load_be(InR&& in_range) {
   93|  13.8k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  13.8k|   std::span in{in_range};
   95|  13.8k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  13.8k|      return static_cast<T>(in[0]);
   97|  13.8k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  13.8k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  13.8k|   }
  109|  13.8k|}
_ZN5Botan7load_beIjEET_PKhm:
  226|  2.35k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  2.35k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  2.35k|}
_ZN5Botan7load_beIjNSt3__14spanIKhLm4EEEEET_OT0_:
   92|  2.35k|inline constexpr T load_be(InR&& in_range) {
   93|  2.35k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  2.35k|   std::span in{in_range};
   95|  2.35k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  2.35k|      return static_cast<T>(in[0]);
   97|  2.35k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  2.35k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  2.35k|   }
  109|  2.35k|}

_ZN5Botan8round_upEmm:
   21|  1.07k|inline size_t round_up(size_t n, size_t align_to) {
   22|  1.07k|   BOTAN_ARG_CHECK(align_to != 0, "align_to must not be 0");
  ------------------
  |  |   30|  1.07k|   do {                                                          \
  |  |   31|  1.07k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 1.07k]
  |  |  ------------------
  |  |   32|  1.07k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.07k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   23|       |
   24|  1.07k|   if(n % align_to) {
  ------------------
  |  Branch (24:7): [True: 994, False: 79]
  ------------------
   25|    994|      n += align_to - (n % align_to);
   26|    994|   }
   27|  1.07k|   return n;
   28|  1.07k|}

_ZN5Botan11checked_addEmmPKci:
   30|   747k|inline size_t checked_add(size_t x, size_t y, const char* file, int line) {
   31|   747k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   32|   747k|   size_t z;
   33|   747k|   if(__builtin_add_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (33:7): [True: 0, False: 747k]
  ------------------
   34|       |#elif defined(_MSC_VER)
   35|       |   size_t z;
   36|       |   if(SizeTAdd(x, y, &z) != S_OK) [[unlikely]]
   37|       |#else
   38|       |   size_t z = x + y;
   39|       |   if(z < x) [[unlikely]]
   40|       |#endif
   41|      0|   {
   42|      0|      throw Integer_Overflow_Detected(file, line);
   43|      0|   }
   44|   747k|   return z;
   45|   747k|}
_ZN5Botan11checked_mulEmm:
   47|   294k|inline std::optional<size_t> checked_mul(size_t x, size_t y) {
   48|   294k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   49|   294k|   size_t z;
   50|   294k|   if(__builtin_mul_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (50:7): [True: 0, False: 294k]
  ------------------
   51|       |#elif defined(_MSC_VER)
   52|       |   size_t z;
   53|       |   if(SizeTMult(x, y, &z) != S_OK) [[unlikely]]
   54|       |#else
   55|       |   size_t z = x * y;
   56|       |   if(y && z / y != x) [[unlikely]]
   57|       |#endif
   58|      0|   {
   59|      0|      return std::nullopt;
   60|      0|   }
   61|   294k|   return z;
   62|   294k|}

_ZN5Botan10BER_ObjectC2Ev:
  128|   189k|      BER_Object() : m_type_tag(ASN1_Type::NoObject), m_class_tag(ASN1_Class::Universal) {}
_ZNK5Botan10BER_Object6is_setEv:
  138|   285k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|  98.5k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|  98.5k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|  98.5k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  76.5k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|  63.5k|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|   115k|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|   238k|      size_t length() const { return m_value.size(); }
_ZN5Botan10BER_Object12mutable_bitsEm:
  169|  94.8k|      uint8_t* mutable_bits(size_t length) {
  170|  94.8k|         m_value.resize(length);
  171|  94.8k|         return m_value.data();
  172|  94.8k|      }
_ZN5Botan3OIDC2ESt16initializer_listIjE:
  229|    281|      explicit OID(std::initializer_list<uint32_t> init) : m_id(init) {
  230|    281|         BOTAN_ARG_CHECK(m_id.size() > 2 && m_id[0] <= 2 && (m_id[0] != 2 || m_id[1] <= 39), "Invalid OID");
  ------------------
  |  |   30|    281|   do {                                                          \
  |  |   31|  1.47k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 281, False: 0]
  |  |  |  Branch (31:12): [True: 281, False: 0]
  |  |  |  Branch (31:12): [True: 208, False: 73]
  |  |  |  Branch (31:12): [True: 73, False: 0]
  |  |  ------------------
  |  |   32|    281|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    281|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  231|    281|      }
_ZNK5Botan3OID14get_componentsEv:
  277|  6.19k|      const std::vector<uint32_t>& get_components() const { return m_id; }
_ZNK5Botan11ASN1_String5valueEv:
  415|  2.87k|      const std::string& value() const { return m_utf8_str; }
_ZN5Botan10intersectsENS_10ASN1_ClassES0_:
   70|   178k|inline bool intersects(ASN1_Class x, ASN1_Class y) {
   71|   178k|   return static_cast<uint32_t>(x) & static_cast<uint32_t>(y);
   72|   178k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|  98.5k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|  98.5k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|  98.5k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  3.71k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  3.71k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  3.71k|}
_ZN5Botan3OIDC2Ev:
  218|  3.71k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectC2Ev:
  117|  12.8k|      ASN1_Object() = default;
_ZN5Botan11ASN1_ObjectD2Ev:
  120|  8.69k|      virtual ~ASN1_Object() = default;
_ZN5Botan9ASN1_TimeC2Ev:
  362|  4.68k|      ASN1_Time() = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  136|  55.4k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|    562|      ASN1_Object(const ASN1_Object&) = default;

_ZN5Botan14ASN1_FormatterC2Ebm:
   33|  2.56k|            m_print_context_specific(print_context_specific), m_max_depth(max_depth) {}

_ZN5Botan13ignore_paramsIJRhEEEvDpOT_:
  114|  4.13k|void ignore_params(T&&... args) {
  115|  4.13k|   (ignore_param(args), ...);
  116|  4.13k|}
_ZN5Botan12ignore_paramIRhEEvOT_:
  111|  4.13k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRmEEEvDpOT_:
  114|    635|void ignore_params(T&&... args) {
  115|    635|   (ignore_param(args), ...);
  116|    635|}
_ZN5Botan12ignore_paramIRmEEvOT_:
  111|    635|void ignore_param(T&&) {}

_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  186|  1.22k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeERb:
  176|    697|      BER_Decoder& decode(bool& out) { return decode(out, ASN1_Type::Boolean, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  198|  16.3k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  199|  16.3k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  200|  16.3k|      }

_ZN5Botan6BigIntC2Ev:
   40|  1.48k|      BigInt() = default;
_ZN5Botan6BigIntD2Ev:
  148|  2.55k|      ~BigInt() { const_time_unpoison(); }
_ZNK5Botan6BigInt19const_time_unpoisonEv:
  726|  2.55k|      void const_time_unpoison() const {}
_ZN5Botan6BigIntaSEOS0_:
  153|  1.07k|      BigInt& operator=(BigInt&& other) {
  154|  1.07k|         if(this != &other) {
  ------------------
  |  Branch (154:13): [True: 1.07k, False: 0]
  ------------------
  155|  1.07k|            this->swap(other);
  156|  1.07k|         }
  157|       |
  158|  1.07k|         return (*this);
  159|  1.07k|      }
_ZN5Botan6BigInt4swapERS0_:
  170|  1.07k|      void swap(BigInt& other) {
  171|  1.07k|         m_data.swap(other.m_data);
  172|  1.07k|         std::swap(m_signedness, other.m_signedness);
  173|  1.07k|      }
_ZN5Botan6BigInt5clearEv:
  370|  1.48k|      void clear() {
  371|  1.48k|         m_data.set_to_zero();
  372|  1.48k|         m_signedness = Positive;
  373|  1.48k|      }
_ZNK5Botan6BigInt7is_zeroEv:
  428|    635|      bool is_zero() const { return (sig_words() == 0); }
_ZNK5Botan6BigInt4signEv:
  540|    635|      Sign sign() const { return (m_signedness); }
_ZNK5Botan6BigInt12reverse_signEv:
  545|    635|      Sign reverse_sign() const {
  546|    635|         if(sign() == Positive) {
  ------------------
  |  Branch (546:13): [True: 635, False: 0]
  ------------------
  547|    635|            return Negative;
  548|    635|         }
  549|      0|         return Positive;
  550|    635|      }
_ZN5Botan6BigInt9flip_signEv:
  555|    635|      void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  561|    635|      void set_sign(Sign sign) {
  562|    635|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (562:13): [True: 635, False: 0]
  |  Branch (562:33): [True: 0, False: 635]
  ------------------
  563|      0|            sign = Positive;
  564|      0|         }
  565|       |
  566|    635|         m_signedness = sign;
  567|    635|      }
_ZNK5Botan6BigInt9sig_wordsEv:
  584|    635|      size_t sig_words() const { return m_data.sig_words(); }
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  871|  1.48k|            void set_to_zero() {
  872|  1.48k|               m_reg.resize(m_reg.capacity());
  873|  1.48k|               clear_mem(m_reg.data(), m_reg.size());
  874|  1.48k|               m_sig_words = 0;
  875|  1.48k|            }
_ZN5Botan6BigInt4Data4swapERS1_:
  921|  1.07k|            void swap(Data& other) {
  922|  1.07k|               m_reg.swap(other.m_reg);
  923|  1.07k|               std::swap(m_sig_words, other.m_sig_words);
  924|  1.07k|            }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  926|  1.07k|            void swap(secure_vector<word>& reg) {
  927|  1.07k|               m_reg.swap(reg);
  928|  1.07k|               invalidate_sig_words();
  929|  1.07k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
  931|  1.07k|            void invalidate_sig_words() const { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
  933|    635|            size_t sig_words() const {
  934|    635|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (934:19): [True: 635, False: 0]
  ------------------
  935|    635|                  m_sig_words = calc_sig_words();
  936|    635|               } else {
  937|      0|                  BOTAN_DEBUG_ASSERT(m_sig_words == calc_sig_words());
  ------------------
  |  |   99|      0|      do {                          \
  |  |  100|      0|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  938|      0|               }
  939|    635|               return m_sig_words;
  940|    635|            }

_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIKhLm8EEEEEvOT0_:
   86|  20.6k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  20.6k|   const std::span s{r};
   88|  20.6k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  20.6k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  20.6k|   } else {
   91|  20.6k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  20.6k|   }
   93|  20.6k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanImLm1EEEJRNS3_IKhLm8EEEEEEvOT_DpOT0_:
  107|  10.3k|{
  108|  10.3k|   const std::span s0{r0};
  109|       |
  110|  10.3k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  10.3k|      constexpr size_t expected_size = s0.size_bytes();
  112|  10.3k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  10.3k|   } else {
  114|  10.3k|      const size_t expected_size = s0.size_bytes();
  115|  10.3k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  10.3k|                      "memory regions don't have equal lengths");
  117|  10.3k|   }
  118|  10.3k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanImLm1EEEEEmOT_:
   73|  10.3k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  10.3k|   return std::span{r}.size_bytes();
   75|  10.3k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm2ERNSt3__14spanIKhLm2EEEEEvOT0_:
   86|  27.7k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  27.7k|   const std::span s{r};
   88|  27.7k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  27.7k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  27.7k|   } else {
   91|  27.7k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  27.7k|   }
   93|  27.7k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanItLm1EEEJRNS3_IKhLm2EEEEEEvOT_DpOT0_:
  107|  13.8k|{
  108|  13.8k|   const std::span s0{r0};
  109|       |
  110|  13.8k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  13.8k|      constexpr size_t expected_size = s0.size_bytes();
  112|  13.8k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  13.8k|   } else {
  114|  13.8k|      const size_t expected_size = s0.size_bytes();
  115|  13.8k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  13.8k|                      "memory regions don't have equal lengths");
  117|  13.8k|   }
  118|  13.8k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanItLm1EEEEEmOT_:
   73|  13.8k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  13.8k|   return std::span{r}.size_bytes();
   75|  13.8k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIKhLm4EEEEEvOT0_:
   86|  4.70k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  4.70k|   const std::span s{r};
   88|  4.70k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  4.70k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  4.70k|   } else {
   91|  4.70k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  4.70k|   }
   93|  4.70k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIjLm1EEEJRNS3_IKhLm4EEEEEEvOT_DpOT0_:
  107|  2.35k|{
  108|  2.35k|   const std::span s0{r0};
  109|       |
  110|  2.35k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  2.35k|      constexpr size_t expected_size = s0.size_bytes();
  112|  2.35k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  2.35k|   } else {
  114|  2.35k|      const size_t expected_size = s0.size_bytes();
  115|  2.35k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  2.35k|                      "memory regions don't have equal lengths");
  117|  2.35k|   }
  118|  2.35k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIjLm1EEEEEmOT_:
   73|  2.35k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  2.35k|   return std::span{r}.size_bytes();
   75|  2.35k|}

_ZN5Botan17DataSource_MemoryC2EPKhm:
  118|  83.8k|      DataSource_Memory(const uint8_t in[], size_t length) : m_source(in, in + length), m_offset(0) {}
_ZN5Botan17DataSource_MemoryC2ENSt3__16vectorIhNS_16secure_allocatorIhEEEE:
  124|  52.9k|      explicit DataSource_Memory(secure_vector<uint8_t> in) : m_source(std::move(in)), m_offset(0) {}
_ZN5Botan10DataSourceC2Ev:
   91|   136k|      DataSource() = default;
_ZN5Botan10DataSourceD2Ev:
   92|   136k|      virtual ~DataSource() = default;

_ZN5Botan11clear_bytesEPvm:
  103|  1.48k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  1.48k|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 0, False: 1.48k]
  ------------------
  105|      0|      std::memset(ptr, 0, bytes);
  106|      0|   }
  107|  1.48k|}
_ZN5Botan22cast_uint8_ptr_to_charEPKh:
  276|  5.81k|inline const char* cast_uint8_ptr_to_char(const uint8_t* b) {
  277|  5.81k|   return reinterpret_cast<const char*>(b);
  278|  5.81k|}
_ZN5Botan22cast_uint8_ptr_to_charEPh:
  284|    476|inline char* cast_uint8_ptr_to_char(uint8_t* b) {
  285|    476|   return reinterpret_cast<char*>(b);
  286|    476|}
_ZN5Botan8copy_memIhEEvPT_PKS1_m:
  146|  1.17M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  1.17M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  1.17M|   do {                                                                                          \
  |  |   79|  2.16M|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 1.08M, False: 92.3k]
  |  |  |  Branch (79:23): [True: 1.08M, False: 0]
  |  |  |  Branch (79:23): [True: 1.08M, False: 0]
  |  |  ------------------
  |  |   80|  1.17M|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  1.17M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  1.17M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 1.17M, False: 3.83k]
  |  Branch (149:24): [True: 1.13M, False: 39.6k]
  |  Branch (149:42): [True: 1.08M, False: 48.8k]
  ------------------
  150|  1.08M|      std::memmove(out, in, sizeof(T) * n);
  151|  1.08M|   }
  152|  1.17M|}
_ZN5Botan9clear_memImEEvPT_m:
  120|  1.48k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  1.48k|   clear_bytes(ptr, sizeof(T) * n);
  122|  1.48k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEET_OT0_:
  209|  10.3k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  10.3k|   ToT dst;
  211|  10.3k|   typecast_copy(dst, src);
  212|  10.3k|   return dst;
  213|  10.3k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEEvRT_OT0_:
  188|  10.3k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  10.3k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  10.3k|}
_ZN5Botan13typecast_copyINSt3__14spanImLm1EEERNS2_IKhLm8EEEEEvOT_OT0_:
  176|  10.3k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  10.3k|   ranges::assert_equal_byte_lengths(out, in);
  178|  10.3k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  10.3k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEET_OT0_:
  209|  13.8k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  13.8k|   ToT dst;
  211|  13.8k|   typecast_copy(dst, src);
  212|  13.8k|   return dst;
  213|  13.8k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEEvRT_OT0_:
  188|  13.8k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  13.8k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  13.8k|}
_ZN5Botan13typecast_copyINSt3__14spanItLm1EEERNS2_IKhLm2EEEEEvOT_OT0_:
  176|  13.8k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  13.8k|   ranges::assert_equal_byte_lengths(out, in);
  178|  13.8k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  13.8k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEET_OT0_:
  209|  2.35k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  2.35k|   ToT dst;
  211|  2.35k|   typecast_copy(dst, src);
  212|  2.35k|   return dst;
  213|  2.35k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEEvRT_OT0_:
  188|  2.35k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  2.35k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  2.35k|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm1EEERNS2_IKhLm4EEEEEvOT_OT0_:
  176|  2.35k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  2.35k|   ranges::assert_equal_byte_lengths(out, in);
  178|  2.35k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  2.35k|}

_ZN5Botan16secure_allocatorIhE8allocateEm:
   45|   293k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
   47|   293k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE10deallocateEPmm:
   47|  1.07k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5BotanneIhhEEbRKNS_16secure_allocatorIT_EERKNS1_IT0_EE:
   56|  55.4k|inline bool operator!=(const secure_allocator<T>&, const secure_allocator<U>&) {
   57|  55.4k|   return false;
   58|  55.4k|}
_ZN5Botan16secure_allocatorImE8allocateEm:
   45|  1.07k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPS5_T1_EE:
   98|  52.1k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<T*, L>& in) {
   99|  52.1k|   out.insert(out.end(), in.first, in.first + in.second);
  100|  52.1k|   return out;
  101|  52.1k|}

_Z4fuzzPKhm:
   28|  2.56k|void fuzz(const uint8_t in[], size_t len) {
   29|  2.56k|   try {
   30|       |      /*
   31|       |      * Here we use an uninitialized ofstream so the fuzzer doesn't spend time
   32|       |      * on actual output formatting, no memory is allocated, etc.
   33|       |      */
   34|  2.56k|      std::ofstream out;
   35|  2.56k|      ASN1_Parser printer;
   36|  2.56k|      printer.print_to_stream(out, in, len);
   37|  2.56k|   } catch(Botan::Exception& e) {}
   38|  2.56k|}
_ZN11ASN1_ParserC2Ev:
   14|  2.56k|      ASN1_Parser() : Botan::ASN1_Formatter(true, 64) {}
_ZNK11ASN1_Parser6formatEN5Botan9ASN1_TypeENS0_10ASN1_ClassEmmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   17|  30.4k|      std::string format(Botan::ASN1_Type, Botan::ASN1_Class, size_t, size_t, std::string_view) const override {
   18|  30.4k|         return "";
   19|  30.4k|      }
_ZNK11ASN1_Parser10format_binEN5Botan9ASN1_TypeENS0_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
   21|  12.1k|      std::string format_bin(Botan::ASN1_Type, Botan::ASN1_Class, const std::vector<uint8_t>&) const override {
   22|  12.1k|         return "";
   23|  12.1k|      }
_ZNK11ASN1_Parser9format_bnERKN5Botan6BigIntE:
   25|  1.48k|      std::string format_bn(const Botan::BigInt&) const override { return ""; }

LLVMFuzzerInitialize:
   24|      2|extern "C" int LLVMFuzzerInitialize(int*, char***) {
   25|       |   /*
   26|       |   * This disables the mlock pool, as overwrites within the pool are
   27|       |   * opaque to ASan or other instrumentation.
   28|       |   */
   29|      2|   ::setenv("BOTAN_MLOCK_POOL_SIZE", "0", 1);
   30|      2|   return 0;
   31|      2|}
LLVMFuzzerTestOneInput:
   34|  2.57k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t in[], size_t len) {
   35|  2.57k|   if(len <= max_fuzzer_input_size) {
  ------------------
  |  Branch (35:7): [True: 2.56k, False: 9]
  ------------------
   36|  2.56k|      fuzz(in, len);
   37|  2.56k|   }
   38|  2.57k|   return 0;
   39|  2.57k|}

_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   29|  16.9k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   30|  16.9k|   if(this->is_a(expected_type_tag, expected_class_tag) == false) {
  ------------------
  |  Branch (30:7): [True: 1.18k, False: 15.7k]
  ------------------
   31|  1.18k|      std::stringstream msg;
   32|       |
   33|  1.18k|      msg << "Tag mismatch when decoding " << descr << " got ";
   34|       |
   35|  1.18k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (35:10): [True: 0, False: 1.18k]
  |  Branch (35:49): [True: 0, False: 0]
  ------------------
   36|      0|         msg << "EOF";
   37|  1.18k|      } else {
   38|  1.18k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (38:13): [True: 0, False: 1.18k]
  |  Branch (38:53): [True: 0, False: 1.18k]
  ------------------
   39|      0|            msg << asn1_tag_to_string(m_type_tag);
   40|  1.18k|         } else {
   41|  1.18k|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   42|  1.18k|         }
   43|       |
   44|  1.18k|         msg << "/" << asn1_class_to_string(m_class_tag);
   45|  1.18k|      }
   46|       |
   47|  1.18k|      msg << " expected ";
   48|       |
   49|  1.18k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (49:10): [True: 1.18k, False: 0]
  |  Branch (49:57): [True: 0, False: 0]
  ------------------
   50|  1.18k|         msg << asn1_tag_to_string(expected_type_tag);
   51|  1.18k|      } else {
   52|      0|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   53|      0|      }
   54|       |
   55|  1.18k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   56|       |
   57|  1.18k|      throw BER_Decoding_Error(msg.str());
   58|  1.18k|   }
   59|  16.9k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   61|  16.9k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   62|  16.9k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (62:12): [True: 16.9k, False: 0]
  |  Branch (62:47): [True: 15.7k, False: 1.18k]
  ------------------
   63|  16.9k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   69|   106k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   70|   106k|   m_type_tag = type_tag;
   71|   106k|   m_class_tag = class_tag;
   72|   106k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   74|  2.37k|std::string asn1_class_to_string(ASN1_Class type) {
   75|  2.37k|   switch(type) {
   76|  1.18k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (76:7): [True: 1.18k, False: 1.18k]
  ------------------
   77|  1.18k|         return "UNIVERSAL";
   78|      0|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (78:7): [True: 0, False: 2.37k]
  ------------------
   79|      0|         return "CONSTRUCTED";
   80|    363|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (80:7): [True: 363, False: 2.01k]
  ------------------
   81|    363|         return "CONTEXT_SPECIFIC";
   82|    282|      case ASN1_Class::Application:
  ------------------
  |  Branch (82:7): [True: 282, False: 2.09k]
  ------------------
   83|    282|         return "APPLICATION";
   84|    543|      case ASN1_Class::Private:
  ------------------
  |  Branch (84:7): [True: 543, False: 1.83k]
  ------------------
   85|    543|         return "PRIVATE";
   86|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (86:7): [True: 0, False: 2.37k]
  ------------------
   87|      0|         return "NO_OBJECT";
   88|      0|      default:
  ------------------
  |  Branch (88:7): [True: 0, False: 2.37k]
  ------------------
   89|      0|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   90|  2.37k|   }
   91|  2.37k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   93|  1.18k|std::string asn1_tag_to_string(ASN1_Type type) {
   94|  1.18k|   switch(type) {
   95|      0|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (95:7): [True: 0, False: 1.18k]
  ------------------
   96|      0|         return "SEQUENCE";
   97|       |
   98|      0|      case ASN1_Type::Set:
  ------------------
  |  Branch (98:7): [True: 0, False: 1.18k]
  ------------------
   99|      0|         return "SET";
  100|       |
  101|      0|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (101:7): [True: 0, False: 1.18k]
  ------------------
  102|      0|         return "PRINTABLE STRING";
  103|       |
  104|      0|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (104:7): [True: 0, False: 1.18k]
  ------------------
  105|      0|         return "NUMERIC STRING";
  106|       |
  107|      0|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (107:7): [True: 0, False: 1.18k]
  ------------------
  108|      0|         return "IA5 STRING";
  109|       |
  110|      0|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (110:7): [True: 0, False: 1.18k]
  ------------------
  111|      0|         return "T61 STRING";
  112|       |
  113|      0|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (113:7): [True: 0, False: 1.18k]
  ------------------
  114|      0|         return "UTF8 STRING";
  115|       |
  116|      0|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (116:7): [True: 0, False: 1.18k]
  ------------------
  117|      0|         return "VISIBLE STRING";
  118|       |
  119|      0|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (119:7): [True: 0, False: 1.18k]
  ------------------
  120|      0|         return "BMP STRING";
  121|       |
  122|      0|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (122:7): [True: 0, False: 1.18k]
  ------------------
  123|      0|         return "UNIVERSAL STRING";
  124|       |
  125|      0|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (125:7): [True: 0, False: 1.18k]
  ------------------
  126|      0|         return "UTC TIME";
  127|       |
  128|      0|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (128:7): [True: 0, False: 1.18k]
  ------------------
  129|      0|         return "GENERALIZED TIME";
  130|       |
  131|    638|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (131:7): [True: 638, False: 550]
  ------------------
  132|    638|         return "OCTET STRING";
  133|       |
  134|    550|      case ASN1_Type::BitString:
  ------------------
  |  Branch (134:7): [True: 550, False: 638]
  ------------------
  135|    550|         return "BIT STRING";
  136|       |
  137|      0|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (137:7): [True: 0, False: 1.18k]
  ------------------
  138|      0|         return "ENUMERATED";
  139|       |
  140|      0|      case ASN1_Type::Integer:
  ------------------
  |  Branch (140:7): [True: 0, False: 1.18k]
  ------------------
  141|      0|         return "INTEGER";
  142|       |
  143|      0|      case ASN1_Type::Null:
  ------------------
  |  Branch (143:7): [True: 0, False: 1.18k]
  ------------------
  144|      0|         return "NULL";
  145|       |
  146|      0|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (146:7): [True: 0, False: 1.18k]
  ------------------
  147|      0|         return "OBJECT";
  148|       |
  149|      0|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (149:7): [True: 0, False: 1.18k]
  ------------------
  150|      0|         return "BOOLEAN";
  151|       |
  152|      0|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (152:7): [True: 0, False: 1.18k]
  ------------------
  153|      0|         return "NO_OBJECT";
  154|       |
  155|      0|      default:
  ------------------
  |  Branch (155:7): [True: 0, False: 1.18k]
  ------------------
  156|      0|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  157|  1.18k|   }
  158|  1.18k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  163|  7.30k|BER_Decoding_Error::BER_Decoding_Error(std::string_view str) : Decoding_Error(fmt("BER: {}", str)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  165|  1.60k|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  185|  5.81k|std::string to_string(const BER_Object& obj) {
  186|  5.81k|   return std::string(cast_uint8_ptr_to_char(obj.bits()), obj.length());
  187|  5.81k|}

_ZNK5Botan3OID9to_stringEv:
  108|  6.19k|std::string OID::to_string() const {
  109|  6.19k|   std::ostringstream out;
  110|  6.19k|   out << (*this);
  111|  6.19k|   return out.str();
  112|  6.19k|}
_ZNK5Botan3OID19human_name_or_emptyEv:
  122|  3.09k|std::string OID::human_name_or_empty() const {
  123|  3.09k|   return OID_Map::global_registry().oid2str(*this);
  124|  3.09k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_3OIDE:
  140|  6.19k|std::ostream& operator<<(std::ostream& out, const OID& oid) {
  141|  6.19k|   const auto& val = oid.get_components();
  142|       |
  143|   174k|   for(size_t i = 0; i != val.size(); ++i) {
  ------------------
  |  Branch (143:22): [True: 168k, False: 6.19k]
  ------------------
  144|       |      // avoid locale issues with integer formatting
  145|   168k|      out << std::to_string(val[i]);
  146|   168k|      if(i != val.size() - 1) {
  ------------------
  |  Branch (146:10): [True: 162k, False: 6.19k]
  ------------------
  147|   162k|         out << ".";
  148|   162k|      }
  149|   168k|   }
  150|       |
  151|  6.19k|   return out;
  152|  6.19k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  191|  3.71k|void OID::decode_from(BER_Decoder& decoder) {
  192|  3.71k|   BER_Object obj = decoder.get_next_object();
  193|  3.71k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (193:7): [True: 0, False: 3.71k]
  ------------------
  194|      0|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  195|      0|   }
  196|       |
  197|  3.71k|   const size_t length = obj.length();
  198|  3.71k|   const uint8_t* bits = obj.bits();
  199|       |
  200|  3.71k|   if(length < 2 && !(length == 1 && bits[0] == 0)) {
  ------------------
  |  Branch (200:7): [True: 862, False: 2.85k]
  |  Branch (200:23): [True: 651, False: 211]
  |  Branch (200:38): [True: 449, False: 202]
  ------------------
  201|    413|      throw BER_Decoding_Error("OID encoding is too short");
  202|    413|   }
  203|       |
  204|  3.30k|   m_id.clear();
  205|  3.30k|   m_id.push_back(bits[0] / 40);
  206|  3.30k|   m_id.push_back(bits[0] % 40);
  207|       |
  208|  3.30k|   size_t i = 0;
  209|  87.6k|   while(i != length - 1) {
  ------------------
  |  Branch (209:10): [True: 84.5k, False: 3.09k]
  ------------------
  210|  84.5k|      uint32_t component = 0;
  211|  87.8k|      while(i != length - 1) {
  ------------------
  |  Branch (211:13): [True: 86.9k, False: 944]
  ------------------
  212|  86.9k|         ++i;
  213|       |
  214|  86.9k|         if(component >> (32 - 7)) {
  ------------------
  |  Branch (214:13): [True: 209, False: 86.7k]
  ------------------
  215|    209|            throw Decoding_Error("OID component overflow");
  216|    209|         }
  217|       |
  218|  86.7k|         component = (component << 7) + (bits[i] & 0x7F);
  219|       |
  220|  86.7k|         if(!(bits[i] & 0x80)) {
  ------------------
  |  Branch (220:13): [True: 83.3k, False: 3.33k]
  ------------------
  221|  83.3k|            break;
  222|  83.3k|         }
  223|  86.7k|      }
  224|  84.3k|      m_id.push_back(component);
  225|  84.3k|   }
  226|  3.30k|}

_ZNK5Botan14ASN1_Formatter15print_to_streamERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKhm:
   67|  2.56k|void ASN1_Formatter::print_to_stream(std::ostream& output, const uint8_t in[], size_t len) const {
   68|  2.56k|   BER_Decoder dec(in, len);
   69|  2.56k|   decode(output, dec, 0);
   70|  2.56k|}
_ZNK5Botan14ASN1_Formatter6decodeERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERNS_11BER_DecoderEm:
   72|  20.0k|void ASN1_Formatter::decode(std::ostream& output, BER_Decoder& decoder, size_t level) const {
   73|  20.0k|   BER_Object obj = decoder.get_next_object();
   74|       |
   75|  20.0k|   const bool recurse_deeper = (m_max_depth == 0 || level < m_max_depth);
  ------------------
  |  Branch (75:33): [True: 2.50k, False: 17.5k]
  |  Branch (75:53): [True: 17.4k, False: 40]
  ------------------
   76|       |
   77|  83.6k|   while(obj.is_set()) {
  ------------------
  |  Branch (77:10): [True: 63.5k, False: 20.0k]
  ------------------
   78|  63.5k|      const ASN1_Type type_tag = obj.type();
   79|  63.5k|      const ASN1_Class class_tag = obj.get_class();
   80|  63.5k|      const size_t length = obj.length();
   81|       |
   82|       |      /* hack to insert the tag+length back in front of the stuff now
   83|       |         that we've gotten the type info */
   84|  63.5k|      std::vector<uint8_t> bits;
   85|  63.5k|      DER_Encoder(bits).add_object(type_tag, class_tag, obj.bits(), obj.length());
   86|       |
   87|  63.5k|      BER_Decoder data(bits);
   88|       |
   89|  63.5k|      if(intersects(class_tag, ASN1_Class::Constructed)) {
  ------------------
  |  Branch (89:10): [True: 5.08k, False: 58.4k]
  ------------------
   90|  5.08k|         BER_Decoder cons_info(obj.bits(), obj.length());
   91|       |
   92|  5.08k|         if(recurse_deeper) {
  ------------------
  |  Branch (92:13): [True: 4.83k, False: 251]
  ------------------
   93|  4.83k|            output << format(type_tag, class_tag, level, length, "");
   94|  4.83k|            decode(output, cons_info, level + 1);  // recurse
   95|  4.83k|         } else {
   96|    251|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, bits));
   97|    251|         }
   98|  58.4k|      } else if(intersects(class_tag, ASN1_Class::Application) || intersects(class_tag, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (98:17): [True: 1.61k, False: 56.8k]
  |  Branch (98:67): [True: 1.85k, False: 55.0k]
  ------------------
   99|  3.46k|         bool success_parsing_cs = false;
  100|       |
  101|  3.46k|         if(m_print_context_specific) {
  ------------------
  |  Branch (101:13): [True: 3.46k, False: 0]
  ------------------
  102|  3.46k|            try {
  103|  3.46k|               if(possibly_a_general_name(bits.data(), bits.size())) {
  ------------------
  |  Branch (103:19): [True: 476, False: 2.99k]
  ------------------
  104|    476|                  output << format(
  105|    476|                     type_tag, class_tag, level, level, std::string(cast_uint8_ptr_to_char(&bits[2]), bits.size() - 2));
  106|    476|                  success_parsing_cs = true;
  107|  2.99k|               } else if(recurse_deeper) {
  ------------------
  |  Branch (107:26): [True: 2.79k, False: 201]
  ------------------
  108|  2.79k|                  std::vector<uint8_t> inner_bits;
  109|  2.79k|                  data.decode(inner_bits, type_tag);
  110|       |
  111|  2.79k|                  BER_Decoder inner(inner_bits);
  112|  2.79k|                  std::ostringstream inner_data;
  113|  2.79k|                  decode(inner_data, inner, level + 1);  // recurse
  114|  2.79k|                  output << inner_data.str();
  115|  2.79k|                  success_parsing_cs = true;
  116|  2.79k|               }
  117|  3.46k|            } catch(...) {}
  118|  3.46k|         }
  119|       |
  120|  3.46k|         if(success_parsing_cs == false) {
  ------------------
  |  Branch (120:13): [True: 2.99k, False: 476]
  ------------------
  121|  2.99k|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, bits));
  122|  2.99k|         }
  123|  55.0k|      } else if(type_tag == ASN1_Type::ObjectId) {
  ------------------
  |  Branch (123:17): [True: 3.71k, False: 51.2k]
  ------------------
  124|  3.71k|         OID oid;
  125|  3.71k|         data.decode(oid);
  126|       |
  127|  3.71k|         const std::string name = oid.human_name_or_empty();
  128|  3.71k|         const std::string oid_str = oid.to_string();
  129|       |
  130|  3.71k|         if(name.empty()) {
  ------------------
  |  Branch (130:13): [True: 2.23k, False: 1.48k]
  ------------------
  131|  2.23k|            output << format(type_tag, class_tag, level, length, oid_str);
  132|  2.23k|         } else {
  133|  1.48k|            output << format(type_tag, class_tag, level, length, fmt("{} [{}]", name, oid_str));
  134|  1.48k|         }
  135|  51.2k|      } else if(type_tag == ASN1_Type::Integer || type_tag == ASN1_Type::Enumerated) {
  ------------------
  |  Branch (135:17): [True: 1.22k, False: 50.0k]
  |  Branch (135:51): [True: 257, False: 49.8k]
  ------------------
  136|  1.48k|         BigInt number;
  137|       |
  138|  1.48k|         if(type_tag == ASN1_Type::Integer) {
  ------------------
  |  Branch (138:13): [True: 1.22k, False: 257]
  ------------------
  139|  1.22k|            data.decode(number);
  140|  1.22k|         } else if(type_tag == ASN1_Type::Enumerated) {
  ------------------
  |  Branch (140:20): [True: 257, False: 0]
  ------------------
  141|    257|            data.decode(number, ASN1_Type::Enumerated, class_tag);
  142|    257|         }
  143|       |
  144|  1.48k|         output << format(type_tag, class_tag, level, length, format_bn(number));
  145|  49.8k|      } else if(type_tag == ASN1_Type::Boolean) {
  ------------------
  |  Branch (145:17): [True: 697, False: 49.1k]
  ------------------
  146|    697|         bool boolean;
  147|    697|         data.decode(boolean);
  148|    697|         output << format(type_tag, class_tag, level, length, (boolean ? "true" : "false"));
  ------------------
  |  Branch (148:64): [True: 368, False: 329]
  ------------------
  149|  49.1k|      } else if(type_tag == ASN1_Type::Null) {
  ------------------
  |  Branch (149:17): [True: 196, False: 48.9k]
  ------------------
  150|    196|         output << format(type_tag, class_tag, level, length, "");
  151|  48.9k|      } else if(type_tag == ASN1_Type::OctetString || type_tag == ASN1_Type::BitString) {
  ------------------
  |  Branch (151:17): [True: 11.3k, False: 37.5k]
  |  Branch (151:55): [True: 2.17k, False: 35.3k]
  ------------------
  152|  13.5k|         std::vector<uint8_t> decoded_bits;
  153|  13.5k|         data.decode(decoded_bits, type_tag);
  154|  13.5k|         bool printing_octet_string_worked = false;
  155|       |
  156|  13.5k|         if(recurse_deeper) {
  ------------------
  |  Branch (156:13): [True: 12.6k, False: 906]
  ------------------
  157|  12.6k|            try {
  158|  12.6k|               BER_Decoder inner(decoded_bits);
  159|       |
  160|  12.6k|               std::ostringstream inner_data;
  161|  12.6k|               decode(inner_data, inner, level + 1);  // recurse
  162|       |
  163|  12.6k|               output << format(type_tag, class_tag, level, length, "");
  164|  12.6k|               output << inner_data.str();
  165|  12.6k|               printing_octet_string_worked = true;
  166|  12.6k|            } catch(...) {}
  167|  12.6k|         }
  168|       |
  169|  13.5k|         if(!printing_octet_string_worked) {
  ------------------
  |  Branch (169:13): [True: 8.94k, False: 4.60k]
  ------------------
  170|  8.94k|            output << format(type_tag, class_tag, level, length, format_bin(type_tag, class_tag, decoded_bits));
  171|  8.94k|         }
  172|  35.3k|      } else if(ASN1_String::is_string_type(type_tag)) {
  ------------------
  |  Branch (172:17): [True: 4.13k, False: 31.2k]
  ------------------
  173|  4.13k|         ASN1_String str;
  174|  4.13k|         data.decode(str);
  175|  4.13k|         output << format(type_tag, class_tag, level, length, str.value());
  176|  31.2k|      } else if(type_tag == ASN1_Type::UtcTime || type_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (176:17): [True: 3.65k, False: 27.5k]
  |  Branch (176:51): [True: 1.03k, False: 26.5k]
  ------------------
  177|  4.68k|         ASN1_Time time;
  178|  4.68k|         data.decode(time);
  179|  4.68k|         output << format(type_tag, class_tag, level, length, time.readable_string());
  180|  26.5k|      } else {
  181|  26.5k|         output << "Unknown ASN.1 tag class=" << static_cast<int>(class_tag) << " type=" << static_cast<int>(type_tag)
  182|  26.5k|                << "\n";
  183|  26.5k|      }
  184|       |
  185|  63.5k|      obj = decoder.get_next_object();
  186|  63.5k|   }
  187|  20.0k|}
asn1_print.cpp:_ZN5Botan12_GLOBAL__N_123possibly_a_general_nameEPKhm:
   39|  3.46k|bool possibly_a_general_name(const uint8_t bits[], size_t bits_len) {
   40|  3.46k|   if(bits_len <= 2) {
  ------------------
  |  Branch (40:7): [True: 1.84k, False: 1.62k]
  ------------------
   41|  1.84k|      return false;
   42|  1.84k|   }
   43|       |
   44|  1.62k|   if(bits[0] != 0x82 && bits[0] != 0x86) {
  ------------------
  |  Branch (44:7): [True: 1.16k, False: 463]
  |  Branch (44:26): [True: 565, False: 599]
  ------------------
   45|    565|      return false;
   46|    565|   }
   47|       |
   48|  1.06k|   if(bits[1] != bits_len - 2) {
  ------------------
  |  Branch (48:7): [True: 97, False: 965]
  ------------------
   49|     97|      return false;
   50|     97|   }
   51|       |
   52|    965|   if(all_printable_chars(bits + 2, bits_len - 2) == false) {
  ------------------
  |  Branch (52:7): [True: 489, False: 476]
  ------------------
   53|    489|      return false;
   54|    489|   }
   55|       |
   56|    476|   return true;
   57|    965|}
asn1_print.cpp:_ZN5Botan12_GLOBAL__N_119all_printable_charsEPKhm:
   22|    965|bool all_printable_chars(const uint8_t bits[], size_t bits_len) {
   23|  7.03k|   for(size_t i = 0; i != bits_len; ++i) {
  ------------------
  |  Branch (23:22): [True: 6.55k, False: 476]
  ------------------
   24|  6.55k|      int c = bits[i];
   25|  6.55k|      if(c > 127) {
  ------------------
  |  Branch (25:10): [True: 280, False: 6.27k]
  ------------------
   26|    280|         return false;
   27|    280|      }
   28|       |
   29|  6.27k|      if((std::isalnum(c) || c == '.' || c == ':' || c == '/' || c == '-') == false) {
  ------------------
  |  Branch (29:10): [True: 209, False: 6.07k]
  |  Branch (29:11): [True: 1.08k, False: 5.19k]
  |  Branch (29:30): [True: 433, False: 4.76k]
  |  Branch (29:42): [True: 438, False: 4.32k]
  |  Branch (29:54): [True: 3.76k, False: 562]
  |  Branch (29:66): [True: 353, False: 209]
  ------------------
   30|    209|         return false;
   31|    209|      }
   32|  6.27k|   }
   33|    476|   return true;
   34|    965|}

_ZN5Botan11ASN1_String14is_string_typeENS_9ASN1_TypeE:
   60|  35.3k|bool ASN1_String::is_string_type(ASN1_Type tag) {
   61|  35.3k|   return is_asn1_string_type(tag);
   62|  35.3k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
   64|  4.13k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
   65|  4.13k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (65:7): [True: 0, False: 4.13k]
  ------------------
   66|      0|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
   67|      0|   }
   68|  4.13k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   70|  4.13k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
   88|  4.13k|void ASN1_String::decode_from(BER_Decoder& source) {
   89|  4.13k|   BER_Object obj = source.get_next_object();
   90|       |
   91|  4.13k|   if(!is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (91:7): [True: 0, False: 4.13k]
  ------------------
   92|      0|      auto typ = static_cast<uint32_t>(obj.type());
   93|      0|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}", typ));
   94|      0|   }
   95|       |
   96|  4.13k|   m_tag = obj.type();
   97|  4.13k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
   98|       |
   99|  4.13k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (99:7): [True: 1.05k, False: 3.07k]
  ------------------
  100|  1.05k|      m_utf8_str = ucs2_to_utf8(m_data.data(), m_data.size());
  101|  3.07k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (101:14): [True: 1.22k, False: 1.85k]
  ------------------
  102|  1.22k|      m_utf8_str = ucs4_to_utf8(m_data.data(), m_data.size());
  103|  1.85k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (103:14): [True: 728, False: 1.13k]
  ------------------
  104|       |      /*
  105|       |      TeletexString is nominally ITU T.61 not ISO-8859-1 but it seems
  106|       |      the majority of implementations actually used that charset here.
  107|       |      */
  108|    728|      m_utf8_str = latin1_to_utf8(m_data.data(), m_data.size());
  109|  1.13k|   } else {
  110|       |      // All other supported string types are UTF-8 or some subset thereof
  111|  1.13k|      m_utf8_str = ASN1::to_string(obj);
  112|  1.13k|   }
  113|  4.13k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   52|  39.4k|bool is_asn1_string_type(ASN1_Type tag) {
   53|  39.4k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (53:12): [True: 2.26k, False: 37.2k]
  |  Branch (53:47): [True: 1.45k, False: 35.7k]
  |  Branch (53:82): [True: 2.10k, False: 33.6k]
  ------------------
   54|  39.4k|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (54:12): [True: 2.44k, False: 31.2k]
  ------------------
   55|  39.4k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   47|  43.6k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   48|  43.6k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (48:12): [True: 578, False: 43.0k]
  |  Branch (48:47): [True: 4.71k, False: 38.3k]
  |  Branch (48:84): [True: 528, False: 37.8k]
  ------------------
   49|  43.6k|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (49:12): [True: 540, False: 37.2k]
  |  Branch (49:43): [True: 30, False: 37.2k]
  ------------------
   50|  43.6k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   23|  4.13k|ASN1_Type choose_encoding(std::string_view str) {
   24|  4.13k|   auto all_printable = CT::Mask<uint8_t>::set();
   25|       |
   26|  4.13k|   for(size_t i = 0; i != str.size(); ++i) {
  ------------------
  |  Branch (26:22): [True: 0, False: 4.13k]
  ------------------
   27|      0|      const uint8_t c = static_cast<uint8_t>(str[i]);
   28|       |
   29|      0|      auto is_alpha_lower = CT::Mask<uint8_t>::is_within_range(c, 'a', 'z');
   30|      0|      auto is_alpha_upper = CT::Mask<uint8_t>::is_within_range(c, 'A', 'Z');
   31|      0|      auto is_decimal = CT::Mask<uint8_t>::is_within_range(c, '0', '9');
   32|       |
   33|      0|      auto is_print_punc = CT::Mask<uint8_t>::is_any_of(c, {' ', '(', ')', '+', ',', '-', '.', '/', ':', '=', '?'});
   34|       |
   35|      0|      auto is_printable = is_alpha_lower | is_alpha_upper | is_decimal | is_print_punc;
   36|       |
   37|      0|      all_printable &= is_printable;
   38|      0|   }
   39|       |
   40|  4.13k|   if(all_printable.as_bool()) {
  ------------------
  |  Branch (40:7): [True: 4.13k, False: 0]
  ------------------
   41|  4.13k|      return ASN1_Type::PrintableString;
   42|  4.13k|   } else {
   43|      0|      return ASN1_Type::Utf8String;
   44|      0|   }
   45|  4.13k|}

_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   53|  4.68k|void ASN1_Time::decode_from(BER_Decoder& source) {
   54|  4.68k|   BER_Object ber_time = source.get_next_object();
   55|       |
   56|  4.68k|   set_to(ASN1::to_string(ber_time), ber_time.type());
   57|  4.68k|}
_ZNK5Botan9ASN1_Time15readable_stringEv:
   92|  1.05k|std::string ASN1_Time::readable_string() const {
   93|  1.05k|   if(time_is_set() == false) {
  ------------------
  |  Branch (93:7): [True: 0, False: 1.05k]
  ------------------
   94|      0|      throw Invalid_State("ASN1_Time::readable_string: No time set");
   95|      0|   }
   96|       |
   97|       |   // desired format: "%04d/%02d/%02d %02d:%02d:%02d UTC"
   98|  1.05k|   std::stringstream output;
   99|  1.05k|   output << std::setfill('0') << std::setw(4) << m_year << "/" << std::setw(2) << m_month << "/" << std::setw(2)
  100|  1.05k|          << m_day << " " << std::setw(2) << m_hour << ":" << std::setw(2) << m_minute << ":" << std::setw(2)
  101|  1.05k|          << m_second << " UTC";
  102|       |
  103|  1.05k|   return output.str();
  104|  1.05k|}
_ZNK5Botan9ASN1_Time11time_is_setEv:
  106|  1.05k|bool ASN1_Time::time_is_set() const {
  107|  1.05k|   return (m_year != 0);
  108|  1.05k|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  157|  4.68k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  158|  4.68k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   30|  4.68k|   do {                                                          \
  |  |   31|  5.71k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 3.65k, False: 1.03k]
  |  |  |  Branch (31:12): [True: 1.03k, False: 0]
  |  |  ------------------
  |  |   32|  4.68k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  4.68k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  159|  4.68k|                   "Invalid tag for ASN1_Time");
  160|       |
  161|  4.68k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (161:7): [True: 1.03k, False: 3.65k]
  ------------------
  162|  1.03k|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   30|  1.03k|   do {                                                          \
  |  |   31|  1.03k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 230, False: 802]
  |  |  ------------------
  |  |   32|  1.03k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.03k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  3.65k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (163:14): [True: 3.65k, False: 0]
  ------------------
  164|  3.65k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   30|  3.65k|   do {                                                          \
  |  |   31|  3.65k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 416, False: 3.23k]
  |  |  ------------------
  |  |   32|  3.65k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  3.65k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  3.65k|   }
  166|       |
  167|  4.68k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   30|  4.68k|   do {                                                          \
  |  |   31|  4.68k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 203, False: 4.48k]
  |  |  ------------------
  |  |   32|  4.68k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  4.68k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  168|       |
  169|  4.68k|   const size_t field_len = 2;
  170|       |
  171|  4.68k|   const size_t year_start = 0;
  172|  4.68k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (172:28): [True: 3.03k, False: 1.65k]
  ------------------
  173|  4.68k|   const size_t month_start = year_start + year_len;
  174|  4.68k|   const size_t day_start = month_start + field_len;
  175|  4.68k|   const size_t hour_start = day_start + field_len;
  176|  4.68k|   const size_t min_start = hour_start + field_len;
  177|  4.68k|   const size_t sec_start = min_start + field_len;
  178|       |
  179|  4.68k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  180|  4.68k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  181|  4.68k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  182|  4.68k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  183|  4.68k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  184|  4.68k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  185|  4.68k|   m_tag = spec_tag;
  186|       |
  187|  4.68k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (187:7): [True: 2.63k, False: 2.04k]
  ------------------
  188|  2.63k|      if(m_year >= 50) {
  ------------------
  |  Branch (188:10): [True: 351, False: 2.28k]
  ------------------
  189|    351|         m_year += 1900;
  190|  2.28k|      } else {
  191|  2.28k|         m_year += 2000;
  192|  2.28k|      }
  193|  2.63k|   }
  194|       |
  195|  4.68k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (195:7): [True: 2.38k, False: 2.30k]
  ------------------
  196|  2.38k|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  197|  2.38k|   }
  198|  4.68k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  203|  3.43k|bool ASN1_Time::passes_sanity_check() const {
  204|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  205|  3.43k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (205:7): [True: 203, False: 3.23k]
  |  Branch (205:24): [True: 202, False: 3.03k]
  ------------------
  206|    405|      return false;
  207|    405|   }
  208|  3.03k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (208:7): [True: 194, False: 2.83k]
  |  Branch (208:23): [True: 203, False: 2.63k]
  ------------------
  209|    397|      return false;
  210|    397|   }
  211|       |
  212|  2.63k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  213|       |
  214|  2.63k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (214:7): [True: 204, False: 2.43k]
  |  Branch (214:21): [True: 203, False: 2.22k]
  ------------------
  215|    407|      return false;
  216|    407|   }
  217|       |
  218|  2.22k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (218:7): [True: 1.28k, False: 948]
  |  Branch (218:23): [True: 1.00k, False: 276]
  ------------------
  219|  1.00k|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (219:10): [True: 194, False: 810]
  ------------------
  220|    194|         return false;  // not a leap year
  221|    194|      }
  222|       |
  223|    810|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (223:10): [True: 484, False: 326]
  |  Branch (223:31): [True: 197, False: 287]
  ------------------
  224|    197|         return false;
  225|    197|      }
  226|    810|   }
  227|       |
  228|  1.83k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (228:7): [True: 196, False: 1.64k]
  |  Branch (228:23): [True: 197, False: 1.44k]
  |  Branch (228:41): [True: 198, False: 1.24k]
  ------------------
  229|    591|      return false;
  230|    591|   }
  231|       |
  232|  1.24k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (232:7): [True: 1.05k, False: 195]
  ------------------
  233|       |      /*
  234|       |      UTCTime limits the value of components such that leap seconds
  235|       |      are not covered. See "UNIVERSAL 23" in "Information technology
  236|       |      Abstract Syntax Notation One (ASN.1): Specification of basic notation"
  237|       |
  238|       |      http://www.itu.int/ITU-T/studygroups/com17/languages/
  239|       |      */
  240|  1.05k|      if(m_second > 59) {
  ------------------
  |  Branch (240:10): [True: 194, False: 857]
  ------------------
  241|    194|         return false;
  242|    194|      }
  243|  1.05k|   }
  244|       |
  245|  1.05k|   return true;
  246|  1.24k|}

_ZN5Botan11BER_Decoder15get_next_objectEv:
  231|   105k|BER_Object BER_Decoder::get_next_object() {
  232|   105k|   BER_Object next;
  233|       |
  234|   105k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (234:7): [True: 0, False: 105k]
  ------------------
  235|      0|      std::swap(next, m_pushed);
  236|      0|      return next;
  237|      0|   }
  238|       |
  239|   107k|   for(;;) {
  240|   107k|      ASN1_Type type_tag;
  241|   107k|      ASN1_Class class_tag;
  242|   107k|      decode_tag(m_source, type_tag, class_tag);
  243|   107k|      next.set_tagging(type_tag, class_tag);
  244|   107k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (244:10): [True: 9.39k, False: 97.9k]
  ------------------
  245|  9.39k|         return next;
  246|  9.39k|      }
  247|       |
  248|  97.9k|      size_t field_size;
  249|  97.9k|      const size_t length = decode_length(m_source, field_size, ALLOWED_EOC_NESTINGS);
  250|  97.9k|      if(!m_source->check_available(length)) {
  ------------------
  |  Branch (250:10): [True: 777, False: 97.1k]
  ------------------
  251|    777|         throw BER_Decoding_Error("Value truncated");
  252|    777|      }
  253|       |
  254|  97.1k|      uint8_t* out = next.mutable_bits(length);
  255|  97.1k|      if(m_source->read(out, length) != length) {
  ------------------
  |  Branch (255:10): [True: 0, False: 97.1k]
  ------------------
  256|      0|         throw BER_Decoding_Error("Value truncated");
  257|      0|      }
  258|       |
  259|  97.1k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (259:10): [True: 1.81k, False: 95.3k]
  ------------------
  260|  1.81k|         continue;
  261|  95.3k|      } else {
  262|  95.3k|         break;
  263|  95.3k|      }
  264|  97.1k|   }
  265|       |
  266|  95.3k|   return next;
  267|   105k|}
_ZN5Botan11BER_DecoderC2EPKhm:
  321|  7.65k|BER_Decoder::BER_Decoder(const uint8_t data[], size_t length) {
  322|  7.65k|   m_data_src = std::make_unique<DataSource_Memory>(data, length);
  323|  7.65k|   m_source = m_data_src.get();
  324|  7.65k|}
_ZN5Botan11BER_DecoderC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  337|  76.2k|BER_Decoder::BER_Decoder(const std::vector<uint8_t>& data) {
  338|  76.2k|   m_data_src = std::make_unique<DataSource_Memory>(data.data(), data.size());
  339|  76.2k|   m_source = m_data_src.get();
  340|  76.2k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  356|  12.5k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  357|  12.5k|   obj.decode_from(*this);
  358|  12.5k|   return (*this);
  359|  12.5k|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  383|    697|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  384|    697|   BER_Object obj = get_next_object();
  385|    697|   obj.assert_is_a(type_tag, class_tag);
  386|       |
  387|    697|   if(obj.length() != 1) {
  ------------------
  |  Branch (387:7): [True: 307, False: 390]
  ------------------
  388|    307|      throw BER_Decoding_Error("BER boolean value had invalid size");
  389|    307|   }
  390|       |
  391|    390|   out = (obj.bits()[0]) ? true : false;
  ------------------
  |  Branch (391:10): [True: 368, False: 22]
  ------------------
  392|    390|   return (*this);
  393|    697|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  444|  1.48k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  445|  1.48k|   BER_Object obj = get_next_object();
  446|  1.48k|   obj.assert_is_a(type_tag, class_tag);
  447|       |
  448|  1.48k|   if(obj.length() == 0) {
  ------------------
  |  Branch (448:7): [True: 411, False: 1.07k]
  ------------------
  449|    411|      out.clear();
  450|  1.07k|   } else {
  451|  1.07k|      const bool negative = (obj.bits()[0] & 0x80) ? true : false;
  ------------------
  |  Branch (451:29): [True: 635, False: 438]
  ------------------
  452|       |
  453|  1.07k|      if(negative) {
  ------------------
  |  Branch (453:10): [True: 635, False: 438]
  ------------------
  454|    635|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  455|    990|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (455:39): [True: 990, False: 0]
  ------------------
  456|    990|            if(vec[i - 1]--) {
  ------------------
  |  Branch (456:16): [True: 635, False: 355]
  ------------------
  457|    635|               break;
  458|    635|            }
  459|    990|         }
  460|  70.6k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (460:28): [True: 70.0k, False: 635]
  ------------------
  461|  70.0k|            vec[i] = ~vec[i];
  462|  70.0k|         }
  463|    635|         out = BigInt(vec.data(), vec.size());
  464|    635|         out.flip_sign();
  465|    635|      } else {
  466|    438|         out = BigInt(obj.bits(), obj.length());
  467|    438|      }
  468|  1.07k|   }
  469|       |
  470|  1.48k|   return (*this);
  471|  1.48k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  521|  16.3k|                                 ASN1_Class class_tag) {
  522|  16.3k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (522:7): [True: 4.32k, False: 12.0k]
  |  Branch (522:46): [True: 1.60k, False: 2.72k]
  ------------------
  523|  1.60k|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  524|  1.60k|   }
  525|       |
  526|  14.7k|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag);
  527|  14.7k|   return (*this);
  528|  16.3k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|   401k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|   401k|   uint8_t b;
   31|   401k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (31:7): [True: 50.2k, False: 350k]
  ------------------
   32|  50.2k|      type_tag = ASN1_Type::NoObject;
   33|  50.2k|      class_tag = ASN1_Class::NoObject;
   34|  50.2k|      return 0;
   35|  50.2k|   }
   36|       |
   37|   350k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (37:7): [True: 344k, False: 6.71k]
  ------------------
   38|   344k|      type_tag = ASN1_Type(b & 0x1F);
   39|   344k|      class_tag = ASN1_Class(b & 0xE0);
   40|   344k|      return 1;
   41|   344k|   }
   42|       |
   43|  6.71k|   size_t tag_bytes = 1;
   44|  6.71k|   class_tag = ASN1_Class(b & 0xE0);
   45|       |
   46|  6.71k|   size_t tag_buf = 0;
   47|  13.9k|   while(true) {
  ------------------
  |  Branch (47:10): [Folded - Ignored]
  ------------------
   48|  13.9k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (48:10): [True: 453, False: 13.4k]
  ------------------
   49|    453|         throw BER_Decoding_Error("Long-form tag truncated");
   50|    453|      }
   51|  13.4k|      if(tag_buf & 0xFF000000) {
  ------------------
  |  Branch (51:10): [True: 205, False: 13.2k]
  ------------------
   52|    205|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|    205|      }
   54|  13.2k|      ++tag_bytes;
   55|  13.2k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
   56|  13.2k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (56:10): [True: 6.05k, False: 7.23k]
  ------------------
   57|  6.05k|         break;
   58|  6.05k|      }
   59|  13.2k|   }
   60|  6.05k|   type_tag = ASN1_Type(tag_buf);
   61|  6.05k|   return tag_bytes;
   62|  6.71k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceERmm:
   72|   350k|size_t decode_length(DataSource* ber, size_t& field_size, size_t allow_indef) {
   73|   350k|   uint8_t b;
   74|   350k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (74:7): [True: 1.01k, False: 349k]
  ------------------
   75|  1.01k|      throw BER_Decoding_Error("Length field not found");
   76|  1.01k|   }
   77|   349k|   field_size = 1;
   78|   349k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (78:7): [True: 293k, False: 55.7k]
  ------------------
   79|   293k|      return b;
   80|   293k|   }
   81|       |
   82|  55.7k|   field_size += (b & 0x7F);
   83|  55.7k|   if(field_size > 5) {
  ------------------
  |  Branch (83:7): [True: 219, False: 55.4k]
  ------------------
   84|    219|      throw BER_Decoding_Error("Length field is too large");
   85|    219|   }
   86|       |
   87|  55.4k|   if(field_size == 1) {
  ------------------
  |  Branch (87:7): [True: 53.2k, False: 2.27k]
  ------------------
   88|  53.2k|      if(allow_indef == 0) {
  ------------------
  |  Branch (88:10): [True: 206, False: 52.9k]
  ------------------
   89|    206|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
   90|  52.9k|      } else {
   91|  52.9k|         return find_eoc(ber, allow_indef - 1);
   92|  52.9k|      }
   93|  53.2k|   }
   94|       |
   95|  2.27k|   size_t length = 0;
   96|       |
   97|  5.61k|   for(size_t i = 0; i != field_size - 1; ++i) {
  ------------------
  |  Branch (97:22): [True: 3.54k, False: 2.06k]
  ------------------
   98|  3.54k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (98:10): [True: 0, False: 3.54k]
  ------------------
   99|      0|         throw BER_Decoding_Error("Field length overflow");
  100|      0|      }
  101|  3.54k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (101:10): [True: 215, False: 3.33k]
  ------------------
  102|    215|         throw BER_Decoding_Error("Corrupted length field");
  103|    215|      }
  104|  3.33k|      length = (length << 8) | b;
  105|  3.33k|   }
  106|  2.06k|   return length;
  107|  2.27k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEm:
  112|  52.9k|size_t find_eoc(DataSource* ber, size_t allow_indef) {
  113|  52.9k|   secure_vector<uint8_t> buffer(BOTAN_DEFAULT_BUFFER_SIZE), data;
  ------------------
  |  |  388|  52.9k|#define BOTAN_DEFAULT_BUFFER_SIZE 4096
  ------------------
  114|       |
  115|   105k|   while(true) {
  ------------------
  |  Branch (115:10): [Folded - Ignored]
  ------------------
  116|   105k|      const size_t got = ber->peek(buffer.data(), buffer.size(), data.size());
  117|   105k|      if(got == 0) {
  ------------------
  |  Branch (117:10): [True: 52.9k, False: 52.1k]
  ------------------
  118|  52.9k|         break;
  119|  52.9k|      }
  120|       |
  121|  52.1k|      data += std::make_pair(buffer.data(), got);
  122|  52.1k|   }
  123|       |
  124|  52.9k|   DataSource_Memory source(data);
  125|  52.9k|   data.clear();
  126|       |
  127|  52.9k|   size_t length = 0;
  128|   297k|   while(true) {
  ------------------
  |  Branch (128:10): [Folded - Ignored]
  ------------------
  129|   293k|      ASN1_Type type_tag;
  130|   293k|      ASN1_Class class_tag;
  131|   293k|      size_t tag_size = decode_tag(&source, type_tag, class_tag);
  132|   293k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (132:10): [True: 40.9k, False: 252k]
  ------------------
  133|  40.9k|         break;
  134|  40.9k|      }
  135|       |
  136|   252k|      size_t length_size = 0;
  137|   252k|      size_t item_size = decode_length(&source, length_size, allow_indef);
  138|   252k|      source.discard_next(item_size);
  139|       |
  140|   252k|      length = BOTAN_CHECKED_ADD(length, item_size);
  ------------------
  |  |   73|   252k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  141|   252k|      length = BOTAN_CHECKED_ADD(length, tag_size);
  ------------------
  |  |   73|   252k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  142|   252k|      length = BOTAN_CHECKED_ADD(length, length_size);
  ------------------
  |  |   73|   252k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  143|       |
  144|   252k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (144:10): [True: 45.7k, False: 207k]
  |  Branch (144:40): [True: 8.37k, False: 37.3k]
  ------------------
  145|  8.37k|         break;
  146|  8.37k|      }
  147|   252k|   }
  148|  52.9k|   return length;
  149|  52.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassE:
  480|  14.7k|                               ASN1_Class class_tag) {
  481|  14.7k|   obj.assert_is_a(type_tag, class_tag);
  482|       |
  483|  14.7k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (483:7): [True: 11.3k, False: 3.36k]
  ------------------
  484|  11.3k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  485|  11.3k|   } else {
  486|  3.36k|      if(obj.length() == 0) {
  ------------------
  |  Branch (486:10): [True: 375, False: 2.98k]
  ------------------
  487|    375|         throw BER_Decoding_Error("Invalid BIT STRING");
  488|    375|      }
  489|  2.98k|      if(obj.bits()[0] >= 8) {
  ------------------
  |  Branch (489:10): [True: 328, False: 2.65k]
  ------------------
  490|    328|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  491|    328|      }
  492|       |
  493|  2.65k|      buffer.resize(obj.length() - 1);
  494|       |
  495|  2.65k|      if(obj.length() > 1) {
  ------------------
  |  Branch (495:10): [True: 1.24k, False: 1.41k]
  ------------------
  496|  1.24k|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  497|  1.24k|      }
  498|  2.65k|   }
  499|  14.7k|}

_ZN5Botan11DER_EncoderC2ERNSt3__16vectorIhNS1_9allocatorIhEEEE:
   71|  63.5k|DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   72|  63.5k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
   73|  63.5k|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEPKhm:
  222|  63.5k|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
  223|  63.5k|   std::vector<uint8_t> hdr;
  224|  63.5k|   encode_tag(hdr, type_tag, class_tag);
  225|  63.5k|   encode_length(hdr, length);
  226|       |
  227|  63.5k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (227:7): [True: 0, False: 63.5k]
  ------------------
  228|      0|      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
  229|  63.5k|   } else if(m_append_output) {
  ------------------
  |  Branch (229:14): [True: 63.5k, False: 0]
  ------------------
  230|  63.5k|      m_append_output(hdr.data(), hdr.size());
  231|  63.5k|      m_append_output(rep, length);
  232|  63.5k|   } else {
  233|      0|      m_default_outbuf += hdr;
  234|      0|      m_default_outbuf += std::make_pair(rep, length);
  235|      0|   }
  236|       |
  237|  63.5k|   return (*this);
  238|  63.5k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_110encode_tagERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeENS_10ASN1_ClassE:
   24|  63.5k|void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   25|  63.5k|   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   26|  63.5k|   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
   27|       |
   28|  63.5k|   if((class_tag | 0xE0) != 0xE0) {
  ------------------
  |  Branch (28:7): [True: 0, False: 63.5k]
  ------------------
   29|      0|      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   30|      0|   }
   31|       |
   32|  63.5k|   if(type_tag <= 30) {
  ------------------
  |  Branch (32:7): [True: 62.0k, False: 1.48k]
  ------------------
   33|  62.0k|      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   34|  62.0k|   } else {
   35|  1.48k|      size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
   36|  1.48k|      blocks = (blocks - (blocks % 7)) / 7;
   37|       |
   38|  1.48k|      BOTAN_ASSERT_NOMSG(blocks > 0);
  ------------------
  |  |   60|  1.48k|   do {                                                                     \
  |  |   61|  1.48k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   62|  1.48k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.48k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   39|       |
   40|  1.48k|      encoded_tag.push_back(static_cast<uint8_t>(class_tag | 0x1F));
   41|  3.88k|      for(size_t i = 0; i != blocks - 1; ++i) {
  ------------------
  |  Branch (41:25): [True: 2.40k, False: 1.48k]
  ------------------
   42|  2.40k|         encoded_tag.push_back(0x80 | ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
   43|  2.40k|      }
   44|  1.48k|      encoded_tag.push_back(type_tag & 0x7F);
   45|  1.48k|   }
   46|  63.5k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_113encode_lengthERNSt3__16vectorIhNS1_9allocatorIhEEEEm:
   51|  63.5k|void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   52|  63.5k|   if(length <= 127) {
  ------------------
  |  Branch (52:7): [True: 61.4k, False: 2.14k]
  ------------------
   53|  61.4k|      encoded_length.push_back(static_cast<uint8_t>(length));
   54|  61.4k|   } else {
   55|  2.14k|      const size_t bytes_needed = significant_bytes(length);
   56|       |
   57|  2.14k|      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));
   58|       |
   59|  5.40k|      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
  ------------------
  |  Branch (59:53): [True: 3.26k, False: 2.14k]
  ------------------
   60|  3.26k|         encoded_length.push_back(get_byte_var(i, length));
   61|  3.26k|      }
   62|  2.14k|   }
   63|  63.5k|}
der_enc.cpp:_ZZN5Botan11DER_EncoderC1ERNSt3__16vectorIhNS1_9allocatorIhEEEEENK3$_1clEPKhm:
   72|   127k|   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|  3.09k|OID_Map& OID_Map::global_registry() {
   17|  3.09k|   static OID_Map g_map;
   18|  3.09k|   return g_map;
   19|  3.09k|}
_ZN5Botan7OID_Map7oid2strERKNS_3OIDE:
   56|  3.09k|std::string OID_Map::oid2str(const OID& oid) {
   57|  3.09k|   const std::string oid_str = oid.to_string();
   58|       |
   59|  3.09k|   lock_guard_type<mutex_type> lock(m_mutex);
   60|       |
   61|  3.09k|   auto i = m_oid2str.find(oid_str);
   62|  3.09k|   if(i != m_oid2str.end()) {
  ------------------
  |  Branch (62:7): [True: 863, False: 2.23k]
  ------------------
   63|    863|      return i->second;
   64|    863|   }
   65|       |
   66|  2.23k|   return "";
   67|  3.09k|}

_ZN5Botan7OID_Map16load_oid2str_mapEv:
   17|      1|std::unordered_map<std::string, std::string> OID_Map::load_oid2str_map() {
   18|      1|   return std::unordered_map<std::string, std::string>{
   19|       |
   20|      1|      {"0.3.4401.5.3.1.9.26", "Camellia-192/GCM"},
   21|      1|      {"0.3.4401.5.3.1.9.46", "Camellia-256/GCM"},
   22|      1|      {"0.3.4401.5.3.1.9.6", "Camellia-128/GCM"},
   23|      1|      {"0.4.0.127.0.15.1.1.13.0", "XMSS"},
   24|      1|      {"1.0.14888.3.0.5", "ECKCDSA"},
   25|      1|      {"1.2.156.10197.1.104.100", "SM4/OCB"},
   26|      1|      {"1.2.156.10197.1.104.2", "SM4/CBC"},
   27|      1|      {"1.2.156.10197.1.104.8", "SM4/GCM"},
   28|      1|      {"1.2.156.10197.1.301", "sm2p256v1"},
   29|      1|      {"1.2.156.10197.1.301.1", "SM2"},
   30|      1|      {"1.2.156.10197.1.301.2", "SM2_Kex"},
   31|      1|      {"1.2.156.10197.1.301.3", "SM2_Enc"},
   32|      1|      {"1.2.156.10197.1.401", "SM3"},
   33|      1|      {"1.2.156.10197.1.501", "SM2_Sig/SM3"},
   34|      1|      {"1.2.156.10197.1.504", "RSA/EMSA3(SM3)"},
   35|      1|      {"1.2.250.1.223.101.256.1", "frp256v1"},
   36|      1|      {"1.2.392.200011.61.1.1.1.2", "Camellia-128/CBC"},
   37|      1|      {"1.2.392.200011.61.1.1.1.3", "Camellia-192/CBC"},
   38|      1|      {"1.2.392.200011.61.1.1.1.4", "Camellia-256/CBC"},
   39|      1|      {"1.2.410.200004.1.100.4.3", "ECKCDSA/SHA-1"},
   40|      1|      {"1.2.410.200004.1.100.4.4", "ECKCDSA/SHA-224"},
   41|      1|      {"1.2.410.200004.1.100.4.5", "ECKCDSA/SHA-256"},
   42|      1|      {"1.2.410.200004.1.4", "SEED/CBC"},
   43|      1|      {"1.2.643.100.1", "GOST.OGRN"},
   44|      1|      {"1.2.643.100.111", "GOST.SubjectSigningTool"},
   45|      1|      {"1.2.643.100.112", "GOST.IssuerSigningTool"},
   46|      1|      {"1.2.643.2.2.19", "GOST-34.10"},
   47|      1|      {"1.2.643.2.2.3", "GOST-34.10/GOST-R-34.11-94"},
   48|      1|      {"1.2.643.2.2.35.1", "gost_256A"},
   49|      1|      {"1.2.643.2.2.36.0", "gost_256A"},
   50|      1|      {"1.2.643.3.131.1.1", "GOST.INN"},
   51|      1|      {"1.2.643.7.1.1.1.1", "GOST-34.10-2012-256"},
   52|      1|      {"1.2.643.7.1.1.1.2", "GOST-34.10-2012-512"},
   53|      1|      {"1.2.643.7.1.1.2.2", "Streebog-256"},
   54|      1|      {"1.2.643.7.1.1.2.3", "Streebog-512"},
   55|      1|      {"1.2.643.7.1.1.3.2", "GOST-34.10-2012-256/Streebog-256"},
   56|      1|      {"1.2.643.7.1.1.3.3", "GOST-34.10-2012-512/Streebog-512"},
   57|      1|      {"1.2.643.7.1.2.1.1.1", "gost_256A"},
   58|      1|      {"1.2.643.7.1.2.1.1.2", "gost_256B"},
   59|      1|      {"1.2.643.7.1.2.1.2.1", "gost_512A"},
   60|      1|      {"1.2.643.7.1.2.1.2.2", "gost_512B"},
   61|      1|      {"1.2.840.10040.4.1", "DSA"},
   62|      1|      {"1.2.840.10040.4.3", "DSA/SHA-1"},
   63|      1|      {"1.2.840.10045.2.1", "ECDSA"},
   64|      1|      {"1.2.840.10045.3.1.1", "secp192r1"},
   65|      1|      {"1.2.840.10045.3.1.2", "x962_p192v2"},
   66|      1|      {"1.2.840.10045.3.1.3", "x962_p192v3"},
   67|      1|      {"1.2.840.10045.3.1.4", "x962_p239v1"},
   68|      1|      {"1.2.840.10045.3.1.5", "x962_p239v2"},
   69|      1|      {"1.2.840.10045.3.1.6", "x962_p239v3"},
   70|      1|      {"1.2.840.10045.3.1.7", "secp256r1"},
   71|      1|      {"1.2.840.10045.4.1", "ECDSA/SHA-1"},
   72|      1|      {"1.2.840.10045.4.3.1", "ECDSA/SHA-224"},
   73|      1|      {"1.2.840.10045.4.3.2", "ECDSA/SHA-256"},
   74|      1|      {"1.2.840.10045.4.3.3", "ECDSA/SHA-384"},
   75|      1|      {"1.2.840.10045.4.3.4", "ECDSA/SHA-512"},
   76|      1|      {"1.2.840.10046.2.1", "DH"},
   77|      1|      {"1.2.840.113533.7.66.10", "CAST-128/CBC"},
   78|      1|      {"1.2.840.113533.7.66.15", "KeyWrap.CAST-128"},
   79|      1|      {"1.2.840.113549.1.1.1", "RSA"},
   80|      1|      {"1.2.840.113549.1.1.10", "RSA/EMSA4"},
   81|      1|      {"1.2.840.113549.1.1.11", "RSA/EMSA3(SHA-256)"},
   82|      1|      {"1.2.840.113549.1.1.12", "RSA/EMSA3(SHA-384)"},
   83|      1|      {"1.2.840.113549.1.1.13", "RSA/EMSA3(SHA-512)"},
   84|      1|      {"1.2.840.113549.1.1.14", "RSA/EMSA3(SHA-224)"},
   85|      1|      {"1.2.840.113549.1.1.16", "RSA/EMSA3(SHA-512-256)"},
   86|      1|      {"1.2.840.113549.1.1.4", "RSA/EMSA3(MD5)"},
   87|      1|      {"1.2.840.113549.1.1.5", "RSA/EMSA3(SHA-1)"},
   88|      1|      {"1.2.840.113549.1.1.7", "RSA/OAEP"},
   89|      1|      {"1.2.840.113549.1.1.8", "MGF1"},
   90|      1|      {"1.2.840.113549.1.5.12", "PKCS5.PBKDF2"},
   91|      1|      {"1.2.840.113549.1.5.13", "PBE-PKCS5v20"},
   92|      1|      {"1.2.840.113549.1.9.1", "PKCS9.EmailAddress"},
   93|      1|      {"1.2.840.113549.1.9.14", "PKCS9.ExtensionRequest"},
   94|      1|      {"1.2.840.113549.1.9.16.3.18", "ChaCha20Poly1305"},
   95|      1|      {"1.2.840.113549.1.9.16.3.6", "KeyWrap.TripleDES"},
   96|      1|      {"1.2.840.113549.1.9.16.3.8", "Compression.Zlib"},
   97|      1|      {"1.2.840.113549.1.9.2", "PKCS9.UnstructuredName"},
   98|      1|      {"1.2.840.113549.1.9.3", "PKCS9.ContentType"},
   99|      1|      {"1.2.840.113549.1.9.4", "PKCS9.MessageDigest"},
  100|      1|      {"1.2.840.113549.1.9.7", "PKCS9.ChallengePassword"},
  101|      1|      {"1.2.840.113549.2.10", "HMAC(SHA-384)"},
  102|      1|      {"1.2.840.113549.2.11", "HMAC(SHA-512)"},
  103|      1|      {"1.2.840.113549.2.13", "HMAC(SHA-512-256)"},
  104|      1|      {"1.2.840.113549.2.5", "MD5"},
  105|      1|      {"1.2.840.113549.2.7", "HMAC(SHA-1)"},
  106|      1|      {"1.2.840.113549.2.8", "HMAC(SHA-224)"},
  107|      1|      {"1.2.840.113549.2.9", "HMAC(SHA-256)"},
  108|      1|      {"1.2.840.113549.3.7", "TripleDES/CBC"},
  109|      1|      {"1.3.101.110", "Curve25519"},
  110|      1|      {"1.3.101.112", "Ed25519"},
  111|      1|      {"1.3.132.0.10", "secp256k1"},
  112|      1|      {"1.3.132.0.30", "secp160r2"},
  113|      1|      {"1.3.132.0.31", "secp192k1"},
  114|      1|      {"1.3.132.0.32", "secp224k1"},
  115|      1|      {"1.3.132.0.33", "secp224r1"},
  116|      1|      {"1.3.132.0.34", "secp384r1"},
  117|      1|      {"1.3.132.0.35", "secp521r1"},
  118|      1|      {"1.3.132.0.8", "secp160r1"},
  119|      1|      {"1.3.132.0.9", "secp160k1"},
  120|      1|      {"1.3.132.1.12", "ECDH"},
  121|      1|      {"1.3.14.3.2.26", "SHA-1"},
  122|      1|      {"1.3.14.3.2.7", "DES/CBC"},
  123|      1|      {"1.3.36.3.2.1", "RIPEMD-160"},
  124|      1|      {"1.3.36.3.3.1.2", "RSA/EMSA3(RIPEMD-160)"},
  125|      1|      {"1.3.36.3.3.2.5.2.1", "ECGDSA"},
  126|      1|      {"1.3.36.3.3.2.5.4.1", "ECGDSA/RIPEMD-160"},
  127|      1|      {"1.3.36.3.3.2.5.4.2", "ECGDSA/SHA-1"},
  128|      1|      {"1.3.36.3.3.2.5.4.3", "ECGDSA/SHA-224"},
  129|      1|      {"1.3.36.3.3.2.5.4.4", "ECGDSA/SHA-256"},
  130|      1|      {"1.3.36.3.3.2.5.4.5", "ECGDSA/SHA-384"},
  131|      1|      {"1.3.36.3.3.2.5.4.6", "ECGDSA/SHA-512"},
  132|      1|      {"1.3.36.3.3.2.8.1.1.1", "brainpool160r1"},
  133|      1|      {"1.3.36.3.3.2.8.1.1.11", "brainpool384r1"},
  134|      1|      {"1.3.36.3.3.2.8.1.1.13", "brainpool512r1"},
  135|      1|      {"1.3.36.3.3.2.8.1.1.3", "brainpool192r1"},
  136|      1|      {"1.3.36.3.3.2.8.1.1.5", "brainpool224r1"},
  137|      1|      {"1.3.36.3.3.2.8.1.1.7", "brainpool256r1"},
  138|      1|      {"1.3.36.3.3.2.8.1.1.9", "brainpool320r1"},
  139|      1|      {"1.3.6.1.4.1.11591.15.1", "OpenPGP.Ed25519"},
  140|      1|      {"1.3.6.1.4.1.11591.4.11", "Scrypt"},
  141|      1|      {"1.3.6.1.4.1.25258.1.10.1", "Dilithium-4x4-AES-r3"},
  142|      1|      {"1.3.6.1.4.1.25258.1.10.2", "Dilithium-6x5-AES-r3"},
  143|      1|      {"1.3.6.1.4.1.25258.1.10.3", "Dilithium-8x7-AES-r3"},
  144|      1|      {"1.3.6.1.4.1.25258.1.11.1", "Kyber-512-90s-r3"},
  145|      1|      {"1.3.6.1.4.1.25258.1.11.2", "Kyber-768-90s-r3"},
  146|      1|      {"1.3.6.1.4.1.25258.1.11.3", "Kyber-1024-90s-r3"},
  147|      1|      {"1.3.6.1.4.1.25258.1.12.1.1", "SphincsPlus-shake-128s-r3.1"},
  148|      1|      {"1.3.6.1.4.1.25258.1.12.1.2", "SphincsPlus-shake-128f-r3.1"},
  149|      1|      {"1.3.6.1.4.1.25258.1.12.1.3", "SphincsPlus-shake-192s-r3.1"},
  150|      1|      {"1.3.6.1.4.1.25258.1.12.1.4", "SphincsPlus-shake-192f-r3.1"},
  151|      1|      {"1.3.6.1.4.1.25258.1.12.1.5", "SphincsPlus-shake-256s-r3.1"},
  152|      1|      {"1.3.6.1.4.1.25258.1.12.1.6", "SphincsPlus-shake-256f-r3.1"},
  153|      1|      {"1.3.6.1.4.1.25258.1.12.2.1", "SphincsPlus-sha2-128s-r3.1"},
  154|      1|      {"1.3.6.1.4.1.25258.1.12.2.2", "SphincsPlus-sha2-128f-r3.1"},
  155|      1|      {"1.3.6.1.4.1.25258.1.12.2.3", "SphincsPlus-sha2-192s-r3.1"},
  156|      1|      {"1.3.6.1.4.1.25258.1.12.2.4", "SphincsPlus-sha2-192f-r3.1"},
  157|      1|      {"1.3.6.1.4.1.25258.1.12.2.5", "SphincsPlus-sha2-256s-r3.1"},
  158|      1|      {"1.3.6.1.4.1.25258.1.12.2.6", "SphincsPlus-sha2-256f-r3.1"},
  159|      1|      {"1.3.6.1.4.1.25258.1.12.3.1", "SphincsPlus-haraka-128s-r3.1"},
  160|      1|      {"1.3.6.1.4.1.25258.1.12.3.2", "SphincsPlus-haraka-128f-r3.1"},
  161|      1|      {"1.3.6.1.4.1.25258.1.12.3.3", "SphincsPlus-haraka-192s-r3.1"},
  162|      1|      {"1.3.6.1.4.1.25258.1.12.3.4", "SphincsPlus-haraka-192f-r3.1"},
  163|      1|      {"1.3.6.1.4.1.25258.1.12.3.5", "SphincsPlus-haraka-256s-r3.1"},
  164|      1|      {"1.3.6.1.4.1.25258.1.12.3.6", "SphincsPlus-haraka-256f-r3.1"},
  165|      1|      {"1.3.6.1.4.1.25258.1.14.1", "FrodoKEM-640-SHAKE"},
  166|      1|      {"1.3.6.1.4.1.25258.1.14.2", "FrodoKEM-976-SHAKE"},
  167|      1|      {"1.3.6.1.4.1.25258.1.14.3", "FrodoKEM-1344-SHAKE"},
  168|      1|      {"1.3.6.1.4.1.25258.1.15.1", "FrodoKEM-640-AES"},
  169|      1|      {"1.3.6.1.4.1.25258.1.15.2", "FrodoKEM-976-AES"},
  170|      1|      {"1.3.6.1.4.1.25258.1.15.3", "FrodoKEM-1344-AES"},
  171|      1|      {"1.3.6.1.4.1.25258.1.16.1", "eFrodoKEM-640-SHAKE"},
  172|      1|      {"1.3.6.1.4.1.25258.1.16.2", "eFrodoKEM-976-SHAKE"},
  173|      1|      {"1.3.6.1.4.1.25258.1.16.3", "eFrodoKEM-1344-SHAKE"},
  174|      1|      {"1.3.6.1.4.1.25258.1.17.1", "eFrodoKEM-640-AES"},
  175|      1|      {"1.3.6.1.4.1.25258.1.17.2", "eFrodoKEM-976-AES"},
  176|      1|      {"1.3.6.1.4.1.25258.1.17.3", "eFrodoKEM-1344-AES"},
  177|      1|      {"1.3.6.1.4.1.25258.1.3", "McEliece"},
  178|      1|      {"1.3.6.1.4.1.25258.1.5", "XMSS-draft6"},
  179|      1|      {"1.3.6.1.4.1.25258.1.6.1", "GOST-34.10-2012-256/SHA-256"},
  180|      1|      {"1.3.6.1.4.1.25258.1.7.1", "Kyber-512-r3"},
  181|      1|      {"1.3.6.1.4.1.25258.1.7.2", "Kyber-768-r3"},
  182|      1|      {"1.3.6.1.4.1.25258.1.7.3", "Kyber-1024-r3"},
  183|      1|      {"1.3.6.1.4.1.25258.1.8", "XMSS-draft12"},
  184|      1|      {"1.3.6.1.4.1.25258.1.9.1", "Dilithium-4x4-r3"},
  185|      1|      {"1.3.6.1.4.1.25258.1.9.2", "Dilithium-6x5-r3"},
  186|      1|      {"1.3.6.1.4.1.25258.1.9.3", "Dilithium-8x7-r3"},
  187|      1|      {"1.3.6.1.4.1.25258.3.1", "Serpent/CBC"},
  188|      1|      {"1.3.6.1.4.1.25258.3.101", "Serpent/GCM"},
  189|      1|      {"1.3.6.1.4.1.25258.3.102", "Twofish/GCM"},
  190|      1|      {"1.3.6.1.4.1.25258.3.2", "Threefish-512/CBC"},
  191|      1|      {"1.3.6.1.4.1.25258.3.2.1", "AES-128/OCB"},
  192|      1|      {"1.3.6.1.4.1.25258.3.2.2", "AES-192/OCB"},
  193|      1|      {"1.3.6.1.4.1.25258.3.2.3", "AES-256/OCB"},
  194|      1|      {"1.3.6.1.4.1.25258.3.2.4", "Serpent/OCB"},
  195|      1|      {"1.3.6.1.4.1.25258.3.2.5", "Twofish/OCB"},
  196|      1|      {"1.3.6.1.4.1.25258.3.2.6", "Camellia-128/OCB"},
  197|      1|      {"1.3.6.1.4.1.25258.3.2.7", "Camellia-192/OCB"},
  198|      1|      {"1.3.6.1.4.1.25258.3.2.8", "Camellia-256/OCB"},
  199|      1|      {"1.3.6.1.4.1.25258.3.3", "Twofish/CBC"},
  200|      1|      {"1.3.6.1.4.1.25258.3.4.1", "AES-128/SIV"},
  201|      1|      {"1.3.6.1.4.1.25258.3.4.2", "AES-192/SIV"},
  202|      1|      {"1.3.6.1.4.1.25258.3.4.3", "AES-256/SIV"},
  203|      1|      {"1.3.6.1.4.1.25258.3.4.4", "Serpent/SIV"},
  204|      1|      {"1.3.6.1.4.1.25258.3.4.5", "Twofish/SIV"},
  205|      1|      {"1.3.6.1.4.1.25258.3.4.6", "Camellia-128/SIV"},
  206|      1|      {"1.3.6.1.4.1.25258.3.4.7", "Camellia-192/SIV"},
  207|      1|      {"1.3.6.1.4.1.25258.3.4.8", "Camellia-256/SIV"},
  208|      1|      {"1.3.6.1.4.1.25258.3.4.9", "SM4/SIV"},
  209|      1|      {"1.3.6.1.4.1.3029.1.2.1", "ElGamal"},
  210|      1|      {"1.3.6.1.4.1.3029.1.5.1", "OpenPGP.Curve25519"},
  211|      1|      {"1.3.6.1.4.1.311.20.2.2", "Microsoft SmartcardLogon"},
  212|      1|      {"1.3.6.1.4.1.311.20.2.3", "Microsoft UPN"},
  213|      1|      {"1.3.6.1.4.1.8301.3.1.2.9.0.38", "secp521r1"},
  214|      1|      {"1.3.6.1.5.5.7.1.1", "PKIX.AuthorityInformationAccess"},
  215|      1|      {"1.3.6.1.5.5.7.3.1", "PKIX.ServerAuth"},
  216|      1|      {"1.3.6.1.5.5.7.3.2", "PKIX.ClientAuth"},
  217|      1|      {"1.3.6.1.5.5.7.3.3", "PKIX.CodeSigning"},
  218|      1|      {"1.3.6.1.5.5.7.3.4", "PKIX.EmailProtection"},
  219|      1|      {"1.3.6.1.5.5.7.3.5", "PKIX.IPsecEndSystem"},
  220|      1|      {"1.3.6.1.5.5.7.3.6", "PKIX.IPsecTunnel"},
  221|      1|      {"1.3.6.1.5.5.7.3.7", "PKIX.IPsecUser"},
  222|      1|      {"1.3.6.1.5.5.7.3.8", "PKIX.TimeStamping"},
  223|      1|      {"1.3.6.1.5.5.7.3.9", "PKIX.OCSPSigning"},
  224|      1|      {"1.3.6.1.5.5.7.48.1", "PKIX.OCSP"},
  225|      1|      {"1.3.6.1.5.5.7.48.1.1", "PKIX.OCSP.BasicResponse"},
  226|      1|      {"1.3.6.1.5.5.7.48.1.5", "PKIX.OCSP.NoCheck"},
  227|      1|      {"1.3.6.1.5.5.7.48.2", "PKIX.CertificateAuthorityIssuers"},
  228|      1|      {"1.3.6.1.5.5.7.8.5", "PKIX.XMPPAddr"},
  229|      1|      {"2.16.840.1.101.3.4.1.2", "AES-128/CBC"},
  230|      1|      {"2.16.840.1.101.3.4.1.22", "AES-192/CBC"},
  231|      1|      {"2.16.840.1.101.3.4.1.25", "KeyWrap.AES-192"},
  232|      1|      {"2.16.840.1.101.3.4.1.26", "AES-192/GCM"},
  233|      1|      {"2.16.840.1.101.3.4.1.27", "AES-192/CCM"},
  234|      1|      {"2.16.840.1.101.3.4.1.42", "AES-256/CBC"},
  235|      1|      {"2.16.840.1.101.3.4.1.45", "KeyWrap.AES-256"},
  236|      1|      {"2.16.840.1.101.3.4.1.46", "AES-256/GCM"},
  237|      1|      {"2.16.840.1.101.3.4.1.47", "AES-256/CCM"},
  238|      1|      {"2.16.840.1.101.3.4.1.5", "KeyWrap.AES-128"},
  239|      1|      {"2.16.840.1.101.3.4.1.6", "AES-128/GCM"},
  240|      1|      {"2.16.840.1.101.3.4.1.7", "AES-128/CCM"},
  241|      1|      {"2.16.840.1.101.3.4.2.1", "SHA-256"},
  242|      1|      {"2.16.840.1.101.3.4.2.10", "SHA-3(512)"},
  243|      1|      {"2.16.840.1.101.3.4.2.11", "SHAKE-128"},
  244|      1|      {"2.16.840.1.101.3.4.2.12", "SHAKE-256"},
  245|      1|      {"2.16.840.1.101.3.4.2.2", "SHA-384"},
  246|      1|      {"2.16.840.1.101.3.4.2.3", "SHA-512"},
  247|      1|      {"2.16.840.1.101.3.4.2.4", "SHA-224"},
  248|      1|      {"2.16.840.1.101.3.4.2.6", "SHA-512-256"},
  249|      1|      {"2.16.840.1.101.3.4.2.7", "SHA-3(224)"},
  250|      1|      {"2.16.840.1.101.3.4.2.8", "SHA-3(256)"},
  251|      1|      {"2.16.840.1.101.3.4.2.9", "SHA-3(384)"},
  252|      1|      {"2.16.840.1.101.3.4.3.1", "DSA/SHA-224"},
  253|      1|      {"2.16.840.1.101.3.4.3.10", "ECDSA/SHA-3(256)"},
  254|      1|      {"2.16.840.1.101.3.4.3.11", "ECDSA/SHA-3(384)"},
  255|      1|      {"2.16.840.1.101.3.4.3.12", "ECDSA/SHA-3(512)"},
  256|      1|      {"2.16.840.1.101.3.4.3.13", "RSA/EMSA3(SHA-3(224))"},
  257|      1|      {"2.16.840.1.101.3.4.3.14", "RSA/EMSA3(SHA-3(256))"},
  258|      1|      {"2.16.840.1.101.3.4.3.15", "RSA/EMSA3(SHA-3(384))"},
  259|      1|      {"2.16.840.1.101.3.4.3.16", "RSA/EMSA3(SHA-3(512))"},
  260|      1|      {"2.16.840.1.101.3.4.3.2", "DSA/SHA-256"},
  261|      1|      {"2.16.840.1.101.3.4.3.3", "DSA/SHA-384"},
  262|      1|      {"2.16.840.1.101.3.4.3.4", "DSA/SHA-512"},
  263|      1|      {"2.16.840.1.101.3.4.3.5", "DSA/SHA-3(224)"},
  264|      1|      {"2.16.840.1.101.3.4.3.6", "DSA/SHA-3(256)"},
  265|      1|      {"2.16.840.1.101.3.4.3.7", "DSA/SHA-3(384)"},
  266|      1|      {"2.16.840.1.101.3.4.3.8", "DSA/SHA-3(512)"},
  267|      1|      {"2.16.840.1.101.3.4.3.9", "ECDSA/SHA-3(224)"},
  268|      1|      {"2.16.840.1.113730.1.13", "Certificate Comment"},
  269|      1|      {"2.5.29.14", "X509v3.SubjectKeyIdentifier"},
  270|      1|      {"2.5.29.15", "X509v3.KeyUsage"},
  271|      1|      {"2.5.29.16", "X509v3.PrivateKeyUsagePeriod"},
  272|      1|      {"2.5.29.17", "X509v3.SubjectAlternativeName"},
  273|      1|      {"2.5.29.18", "X509v3.IssuerAlternativeName"},
  274|      1|      {"2.5.29.19", "X509v3.BasicConstraints"},
  275|      1|      {"2.5.29.20", "X509v3.CRLNumber"},
  276|      1|      {"2.5.29.21", "X509v3.ReasonCode"},
  277|      1|      {"2.5.29.23", "X509v3.HoldInstructionCode"},
  278|      1|      {"2.5.29.24", "X509v3.InvalidityDate"},
  279|      1|      {"2.5.29.28", "X509v3.CRLIssuingDistributionPoint"},
  280|      1|      {"2.5.29.30", "X509v3.NameConstraints"},
  281|      1|      {"2.5.29.31", "X509v3.CRLDistributionPoints"},
  282|      1|      {"2.5.29.32", "X509v3.CertificatePolicies"},
  283|      1|      {"2.5.29.32.0", "X509v3.AnyPolicy"},
  284|      1|      {"2.5.29.35", "X509v3.AuthorityKeyIdentifier"},
  285|      1|      {"2.5.29.36", "X509v3.PolicyConstraints"},
  286|      1|      {"2.5.29.37", "X509v3.ExtendedKeyUsage"},
  287|      1|      {"2.5.4.10", "X520.Organization"},
  288|      1|      {"2.5.4.11", "X520.OrganizationalUnit"},
  289|      1|      {"2.5.4.12", "X520.Title"},
  290|      1|      {"2.5.4.3", "X520.CommonName"},
  291|      1|      {"2.5.4.4", "X520.Surname"},
  292|      1|      {"2.5.4.42", "X520.GivenName"},
  293|      1|      {"2.5.4.43", "X520.Initials"},
  294|      1|      {"2.5.4.44", "X520.GenerationalQualifier"},
  295|      1|      {"2.5.4.46", "X520.DNQualifier"},
  296|      1|      {"2.5.4.5", "X520.SerialNumber"},
  297|      1|      {"2.5.4.6", "X520.Country"},
  298|      1|      {"2.5.4.65", "X520.Pseudonym"},
  299|      1|      {"2.5.4.7", "X520.Locality"},
  300|      1|      {"2.5.4.8", "X520.State"},
  301|      1|      {"2.5.4.9", "X520.StreetAddress"},
  302|      1|      {"2.5.8.1.1", "RSA"}};
  303|      1|}
_ZN5Botan7OID_Map16load_str2oid_mapEv:
  305|      1|std::unordered_map<std::string, OID> OID_Map::load_str2oid_map() {
  306|      1|   return std::unordered_map<std::string, OID>{
  307|       |
  308|      1|      {"AES-128/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 2})},
  309|      1|      {"AES-128/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 7})},
  310|      1|      {"AES-128/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 6})},
  311|      1|      {"AES-128/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 1})},
  312|      1|      {"AES-128/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 1})},
  313|      1|      {"AES-192/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 22})},
  314|      1|      {"AES-192/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 27})},
  315|      1|      {"AES-192/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 26})},
  316|      1|      {"AES-192/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 2})},
  317|      1|      {"AES-192/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 2})},
  318|      1|      {"AES-256/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 42})},
  319|      1|      {"AES-256/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 47})},
  320|      1|      {"AES-256/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 46})},
  321|      1|      {"AES-256/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 3})},
  322|      1|      {"AES-256/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 3})},
  323|      1|      {"CAST-128/CBC", OID({1, 2, 840, 113533, 7, 66, 10})},
  324|      1|      {"Camellia-128/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 2})},
  325|      1|      {"Camellia-128/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 6})},
  326|      1|      {"Camellia-128/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 6})},
  327|      1|      {"Camellia-128/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 6})},
  328|      1|      {"Camellia-192/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 3})},
  329|      1|      {"Camellia-192/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 26})},
  330|      1|      {"Camellia-192/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 7})},
  331|      1|      {"Camellia-192/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 7})},
  332|      1|      {"Camellia-256/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 4})},
  333|      1|      {"Camellia-256/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 46})},
  334|      1|      {"Camellia-256/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 8})},
  335|      1|      {"Camellia-256/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 8})},
  336|      1|      {"Certificate Comment", OID({2, 16, 840, 1, 113730, 1, 13})},
  337|      1|      {"ChaCha20Poly1305", OID({1, 2, 840, 113549, 1, 9, 16, 3, 18})},
  338|      1|      {"Compression.Zlib", OID({1, 2, 840, 113549, 1, 9, 16, 3, 8})},
  339|      1|      {"Curve25519", OID({1, 3, 101, 110})},
  340|      1|      {"DES/CBC", OID({1, 3, 14, 3, 2, 7})},
  341|      1|      {"DH", OID({1, 2, 840, 10046, 2, 1})},
  342|      1|      {"DSA", OID({1, 2, 840, 10040, 4, 1})},
  343|      1|      {"DSA/SHA-1", OID({1, 2, 840, 10040, 4, 3})},
  344|      1|      {"DSA/SHA-224", OID({2, 16, 840, 1, 101, 3, 4, 3, 1})},
  345|      1|      {"DSA/SHA-256", OID({2, 16, 840, 1, 101, 3, 4, 3, 2})},
  346|      1|      {"DSA/SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 3, 5})},
  347|      1|      {"DSA/SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 3, 6})},
  348|      1|      {"DSA/SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 3, 7})},
  349|      1|      {"DSA/SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 3, 8})},
  350|      1|      {"DSA/SHA-384", OID({2, 16, 840, 1, 101, 3, 4, 3, 3})},
  351|      1|      {"DSA/SHA-512", OID({2, 16, 840, 1, 101, 3, 4, 3, 4})},
  352|      1|      {"Dilithium-4x4-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 1})},
  353|      1|      {"Dilithium-4x4-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 1})},
  354|      1|      {"Dilithium-6x5-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 2})},
  355|      1|      {"Dilithium-6x5-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 2})},
  356|      1|      {"Dilithium-8x7-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 3})},
  357|      1|      {"Dilithium-8x7-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 3})},
  358|      1|      {"ECDH", OID({1, 3, 132, 1, 12})},
  359|      1|      {"ECDSA", OID({1, 2, 840, 10045, 2, 1})},
  360|      1|      {"ECDSA/SHA-1", OID({1, 2, 840, 10045, 4, 1})},
  361|      1|      {"ECDSA/SHA-224", OID({1, 2, 840, 10045, 4, 3, 1})},
  362|      1|      {"ECDSA/SHA-256", OID({1, 2, 840, 10045, 4, 3, 2})},
  363|      1|      {"ECDSA/SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 3, 9})},
  364|      1|      {"ECDSA/SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 3, 10})},
  365|      1|      {"ECDSA/SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 3, 11})},
  366|      1|      {"ECDSA/SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 3, 12})},
  367|      1|      {"ECDSA/SHA-384", OID({1, 2, 840, 10045, 4, 3, 3})},
  368|      1|      {"ECDSA/SHA-512", OID({1, 2, 840, 10045, 4, 3, 4})},
  369|      1|      {"ECGDSA", OID({1, 3, 36, 3, 3, 2, 5, 2, 1})},
  370|      1|      {"ECGDSA/RIPEMD-160", OID({1, 3, 36, 3, 3, 2, 5, 4, 1})},
  371|      1|      {"ECGDSA/SHA-1", OID({1, 3, 36, 3, 3, 2, 5, 4, 2})},
  372|      1|      {"ECGDSA/SHA-224", OID({1, 3, 36, 3, 3, 2, 5, 4, 3})},
  373|      1|      {"ECGDSA/SHA-256", OID({1, 3, 36, 3, 3, 2, 5, 4, 4})},
  374|      1|      {"ECGDSA/SHA-384", OID({1, 3, 36, 3, 3, 2, 5, 4, 5})},
  375|      1|      {"ECGDSA/SHA-512", OID({1, 3, 36, 3, 3, 2, 5, 4, 6})},
  376|      1|      {"ECKCDSA", OID({1, 0, 14888, 3, 0, 5})},
  377|      1|      {"ECKCDSA/SHA-1", OID({1, 2, 410, 200004, 1, 100, 4, 3})},
  378|      1|      {"ECKCDSA/SHA-224", OID({1, 2, 410, 200004, 1, 100, 4, 4})},
  379|      1|      {"ECKCDSA/SHA-256", OID({1, 2, 410, 200004, 1, 100, 4, 5})},
  380|      1|      {"Ed25519", OID({1, 3, 101, 112})},
  381|      1|      {"ElGamal", OID({1, 3, 6, 1, 4, 1, 3029, 1, 2, 1})},
  382|      1|      {"FrodoKEM-1344-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 3})},
  383|      1|      {"FrodoKEM-1344-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 3})},
  384|      1|      {"FrodoKEM-640-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 1})},
  385|      1|      {"FrodoKEM-640-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 1})},
  386|      1|      {"FrodoKEM-976-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 2})},
  387|      1|      {"FrodoKEM-976-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 2})},
  388|      1|      {"GOST-34.10", OID({1, 2, 643, 2, 2, 19})},
  389|      1|      {"GOST-34.10-2012-256", OID({1, 2, 643, 7, 1, 1, 1, 1})},
  390|      1|      {"GOST-34.10-2012-256/SHA-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 6, 1})},
  391|      1|      {"GOST-34.10-2012-256/Streebog-256", OID({1, 2, 643, 7, 1, 1, 3, 2})},
  392|      1|      {"GOST-34.10-2012-512", OID({1, 2, 643, 7, 1, 1, 1, 2})},
  393|      1|      {"GOST-34.10-2012-512/Streebog-512", OID({1, 2, 643, 7, 1, 1, 3, 3})},
  394|      1|      {"GOST-34.10/GOST-R-34.11-94", OID({1, 2, 643, 2, 2, 3})},
  395|      1|      {"GOST.INN", OID({1, 2, 643, 3, 131, 1, 1})},
  396|      1|      {"GOST.IssuerSigningTool", OID({1, 2, 643, 100, 112})},
  397|      1|      {"GOST.OGRN", OID({1, 2, 643, 100, 1})},
  398|      1|      {"GOST.SubjectSigningTool", OID({1, 2, 643, 100, 111})},
  399|      1|      {"HMAC(SHA-1)", OID({1, 2, 840, 113549, 2, 7})},
  400|      1|      {"HMAC(SHA-224)", OID({1, 2, 840, 113549, 2, 8})},
  401|      1|      {"HMAC(SHA-256)", OID({1, 2, 840, 113549, 2, 9})},
  402|      1|      {"HMAC(SHA-384)", OID({1, 2, 840, 113549, 2, 10})},
  403|      1|      {"HMAC(SHA-512)", OID({1, 2, 840, 113549, 2, 11})},
  404|      1|      {"HMAC(SHA-512-256)", OID({1, 2, 840, 113549, 2, 13})},
  405|      1|      {"KeyWrap.AES-128", OID({2, 16, 840, 1, 101, 3, 4, 1, 5})},
  406|      1|      {"KeyWrap.AES-192", OID({2, 16, 840, 1, 101, 3, 4, 1, 25})},
  407|      1|      {"KeyWrap.AES-256", OID({2, 16, 840, 1, 101, 3, 4, 1, 45})},
  408|      1|      {"KeyWrap.CAST-128", OID({1, 2, 840, 113533, 7, 66, 15})},
  409|      1|      {"KeyWrap.TripleDES", OID({1, 2, 840, 113549, 1, 9, 16, 3, 6})},
  410|      1|      {"Kyber-1024-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 3})},
  411|      1|      {"Kyber-1024-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 3})},
  412|      1|      {"Kyber-512-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 1})},
  413|      1|      {"Kyber-512-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 1})},
  414|      1|      {"Kyber-768-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 2})},
  415|      1|      {"Kyber-768-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 2})},
  416|      1|      {"MD5", OID({1, 2, 840, 113549, 2, 5})},
  417|      1|      {"MGF1", OID({1, 2, 840, 113549, 1, 1, 8})},
  418|      1|      {"McEliece", OID({1, 3, 6, 1, 4, 1, 25258, 1, 3})},
  419|      1|      {"Microsoft SmartcardLogon", OID({1, 3, 6, 1, 4, 1, 311, 20, 2, 2})},
  420|      1|      {"Microsoft UPN", OID({1, 3, 6, 1, 4, 1, 311, 20, 2, 3})},
  421|      1|      {"OpenPGP.Curve25519", OID({1, 3, 6, 1, 4, 1, 3029, 1, 5, 1})},
  422|      1|      {"OpenPGP.Ed25519", OID({1, 3, 6, 1, 4, 1, 11591, 15, 1})},
  423|      1|      {"PBE-PKCS5v20", OID({1, 2, 840, 113549, 1, 5, 13})},
  424|      1|      {"PBES2", OID({1, 2, 840, 113549, 1, 5, 13})},
  425|      1|      {"PKCS5.PBKDF2", OID({1, 2, 840, 113549, 1, 5, 12})},
  426|      1|      {"PKCS9.ChallengePassword", OID({1, 2, 840, 113549, 1, 9, 7})},
  427|      1|      {"PKCS9.ContentType", OID({1, 2, 840, 113549, 1, 9, 3})},
  428|      1|      {"PKCS9.EmailAddress", OID({1, 2, 840, 113549, 1, 9, 1})},
  429|      1|      {"PKCS9.ExtensionRequest", OID({1, 2, 840, 113549, 1, 9, 14})},
  430|      1|      {"PKCS9.MessageDigest", OID({1, 2, 840, 113549, 1, 9, 4})},
  431|      1|      {"PKCS9.UnstructuredName", OID({1, 2, 840, 113549, 1, 9, 2})},
  432|      1|      {"PKIX.AuthorityInformationAccess", OID({1, 3, 6, 1, 5, 5, 7, 1, 1})},
  433|      1|      {"PKIX.CertificateAuthorityIssuers", OID({1, 3, 6, 1, 5, 5, 7, 48, 2})},
  434|      1|      {"PKIX.ClientAuth", OID({1, 3, 6, 1, 5, 5, 7, 3, 2})},
  435|      1|      {"PKIX.CodeSigning", OID({1, 3, 6, 1, 5, 5, 7, 3, 3})},
  436|      1|      {"PKIX.EmailProtection", OID({1, 3, 6, 1, 5, 5, 7, 3, 4})},
  437|      1|      {"PKIX.IPsecEndSystem", OID({1, 3, 6, 1, 5, 5, 7, 3, 5})},
  438|      1|      {"PKIX.IPsecTunnel", OID({1, 3, 6, 1, 5, 5, 7, 3, 6})},
  439|      1|      {"PKIX.IPsecUser", OID({1, 3, 6, 1, 5, 5, 7, 3, 7})},
  440|      1|      {"PKIX.OCSP", OID({1, 3, 6, 1, 5, 5, 7, 48, 1})},
  441|      1|      {"PKIX.OCSP.BasicResponse", OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 1})},
  442|      1|      {"PKIX.OCSP.NoCheck", OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 5})},
  443|      1|      {"PKIX.OCSPSigning", OID({1, 3, 6, 1, 5, 5, 7, 3, 9})},
  444|      1|      {"PKIX.ServerAuth", OID({1, 3, 6, 1, 5, 5, 7, 3, 1})},
  445|      1|      {"PKIX.TimeStamping", OID({1, 3, 6, 1, 5, 5, 7, 3, 8})},
  446|      1|      {"PKIX.XMPPAddr", OID({1, 3, 6, 1, 5, 5, 7, 8, 5})},
  447|      1|      {"RIPEMD-160", OID({1, 3, 36, 3, 2, 1})},
  448|      1|      {"RSA", OID({1, 2, 840, 113549, 1, 1, 1})},
  449|      1|      {"RSA/EMSA3(MD5)", OID({1, 2, 840, 113549, 1, 1, 4})},
  450|      1|      {"RSA/EMSA3(RIPEMD-160)", OID({1, 3, 36, 3, 3, 1, 2})},
  451|      1|      {"RSA/EMSA3(SHA-1)", OID({1, 2, 840, 113549, 1, 1, 5})},
  452|      1|      {"RSA/EMSA3(SHA-224)", OID({1, 2, 840, 113549, 1, 1, 14})},
  453|      1|      {"RSA/EMSA3(SHA-256)", OID({1, 2, 840, 113549, 1, 1, 11})},
  454|      1|      {"RSA/EMSA3(SHA-3(224))", OID({2, 16, 840, 1, 101, 3, 4, 3, 13})},
  455|      1|      {"RSA/EMSA3(SHA-3(256))", OID({2, 16, 840, 1, 101, 3, 4, 3, 14})},
  456|      1|      {"RSA/EMSA3(SHA-3(384))", OID({2, 16, 840, 1, 101, 3, 4, 3, 15})},
  457|      1|      {"RSA/EMSA3(SHA-3(512))", OID({2, 16, 840, 1, 101, 3, 4, 3, 16})},
  458|      1|      {"RSA/EMSA3(SHA-384)", OID({1, 2, 840, 113549, 1, 1, 12})},
  459|      1|      {"RSA/EMSA3(SHA-512)", OID({1, 2, 840, 113549, 1, 1, 13})},
  460|      1|      {"RSA/EMSA3(SHA-512-256)", OID({1, 2, 840, 113549, 1, 1, 16})},
  461|      1|      {"RSA/EMSA3(SM3)", OID({1, 2, 156, 10197, 1, 504})},
  462|      1|      {"RSA/EMSA4", OID({1, 2, 840, 113549, 1, 1, 10})},
  463|      1|      {"RSA/OAEP", OID({1, 2, 840, 113549, 1, 1, 7})},
  464|      1|      {"SEED/CBC", OID({1, 2, 410, 200004, 1, 4})},
  465|      1|      {"SHA-1", OID({1, 3, 14, 3, 2, 26})},
  466|      1|      {"SHA-224", OID({2, 16, 840, 1, 101, 3, 4, 2, 4})},
  467|      1|      {"SHA-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 1})},
  468|      1|      {"SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 2, 7})},
  469|      1|      {"SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 2, 8})},
  470|      1|      {"SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 2, 9})},
  471|      1|      {"SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 2, 10})},
  472|      1|      {"SHA-384", OID({2, 16, 840, 1, 101, 3, 4, 2, 2})},
  473|      1|      {"SHA-512", OID({2, 16, 840, 1, 101, 3, 4, 2, 3})},
  474|      1|      {"SHA-512-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 6})},
  475|      1|      {"SHAKE-128", OID({2, 16, 840, 1, 101, 3, 4, 2, 11})},
  476|      1|      {"SHAKE-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 12})},
  477|      1|      {"SM2", OID({1, 2, 156, 10197, 1, 301, 1})},
  478|      1|      {"SM2_Enc", OID({1, 2, 156, 10197, 1, 301, 3})},
  479|      1|      {"SM2_Kex", OID({1, 2, 156, 10197, 1, 301, 2})},
  480|      1|      {"SM2_Sig", OID({1, 2, 156, 10197, 1, 301, 1})},
  481|      1|      {"SM2_Sig/SM3", OID({1, 2, 156, 10197, 1, 501})},
  482|      1|      {"SM3", OID({1, 2, 156, 10197, 1, 401})},
  483|      1|      {"SM4/CBC", OID({1, 2, 156, 10197, 1, 104, 2})},
  484|      1|      {"SM4/GCM", OID({1, 2, 156, 10197, 1, 104, 8})},
  485|      1|      {"SM4/OCB", OID({1, 2, 156, 10197, 1, 104, 100})},
  486|      1|      {"SM4/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 9})},
  487|      1|      {"Scrypt", OID({1, 3, 6, 1, 4, 1, 11591, 4, 11})},
  488|      1|      {"Serpent/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 1})},
  489|      1|      {"Serpent/GCM", OID({1, 3, 6, 1, 4, 1, 25258, 3, 101})},
  490|      1|      {"Serpent/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 4})},
  491|      1|      {"Serpent/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 4})},
  492|      1|      {"SphincsPlus-haraka-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 2})},
  493|      1|      {"SphincsPlus-haraka-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 1})},
  494|      1|      {"SphincsPlus-haraka-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 4})},
  495|      1|      {"SphincsPlus-haraka-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 3})},
  496|      1|      {"SphincsPlus-haraka-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 6})},
  497|      1|      {"SphincsPlus-haraka-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 5})},
  498|      1|      {"SphincsPlus-sha2-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 2})},
  499|      1|      {"SphincsPlus-sha2-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 1})},
  500|      1|      {"SphincsPlus-sha2-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 4})},
  501|      1|      {"SphincsPlus-sha2-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 3})},
  502|      1|      {"SphincsPlus-sha2-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 6})},
  503|      1|      {"SphincsPlus-sha2-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 5})},
  504|      1|      {"SphincsPlus-shake-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 2})},
  505|      1|      {"SphincsPlus-shake-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 1})},
  506|      1|      {"SphincsPlus-shake-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 4})},
  507|      1|      {"SphincsPlus-shake-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 3})},
  508|      1|      {"SphincsPlus-shake-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 6})},
  509|      1|      {"SphincsPlus-shake-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 5})},
  510|      1|      {"Streebog-256", OID({1, 2, 643, 7, 1, 1, 2, 2})},
  511|      1|      {"Streebog-512", OID({1, 2, 643, 7, 1, 1, 2, 3})},
  512|      1|      {"Threefish-512/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2})},
  513|      1|      {"TripleDES/CBC", OID({1, 2, 840, 113549, 3, 7})},
  514|      1|      {"Twofish/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 3})},
  515|      1|      {"Twofish/GCM", OID({1, 3, 6, 1, 4, 1, 25258, 3, 102})},
  516|      1|      {"Twofish/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 5})},
  517|      1|      {"Twofish/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 5})},
  518|      1|      {"X509v3.AnyPolicy", OID({2, 5, 29, 32, 0})},
  519|      1|      {"X509v3.AuthorityKeyIdentifier", OID({2, 5, 29, 35})},
  520|      1|      {"X509v3.BasicConstraints", OID({2, 5, 29, 19})},
  521|      1|      {"X509v3.CRLDistributionPoints", OID({2, 5, 29, 31})},
  522|      1|      {"X509v3.CRLIssuingDistributionPoint", OID({2, 5, 29, 28})},
  523|      1|      {"X509v3.CRLNumber", OID({2, 5, 29, 20})},
  524|      1|      {"X509v3.CertificatePolicies", OID({2, 5, 29, 32})},
  525|      1|      {"X509v3.ExtendedKeyUsage", OID({2, 5, 29, 37})},
  526|      1|      {"X509v3.HoldInstructionCode", OID({2, 5, 29, 23})},
  527|      1|      {"X509v3.InvalidityDate", OID({2, 5, 29, 24})},
  528|      1|      {"X509v3.IssuerAlternativeName", OID({2, 5, 29, 18})},
  529|      1|      {"X509v3.KeyUsage", OID({2, 5, 29, 15})},
  530|      1|      {"X509v3.NameConstraints", OID({2, 5, 29, 30})},
  531|      1|      {"X509v3.PolicyConstraints", OID({2, 5, 29, 36})},
  532|      1|      {"X509v3.PrivateKeyUsagePeriod", OID({2, 5, 29, 16})},
  533|      1|      {"X509v3.ReasonCode", OID({2, 5, 29, 21})},
  534|      1|      {"X509v3.SubjectAlternativeName", OID({2, 5, 29, 17})},
  535|      1|      {"X509v3.SubjectKeyIdentifier", OID({2, 5, 29, 14})},
  536|      1|      {"X520.CommonName", OID({2, 5, 4, 3})},
  537|      1|      {"X520.Country", OID({2, 5, 4, 6})},
  538|      1|      {"X520.DNQualifier", OID({2, 5, 4, 46})},
  539|      1|      {"X520.GenerationalQualifier", OID({2, 5, 4, 44})},
  540|      1|      {"X520.GivenName", OID({2, 5, 4, 42})},
  541|      1|      {"X520.Initials", OID({2, 5, 4, 43})},
  542|      1|      {"X520.Locality", OID({2, 5, 4, 7})},
  543|      1|      {"X520.Organization", OID({2, 5, 4, 10})},
  544|      1|      {"X520.OrganizationalUnit", OID({2, 5, 4, 11})},
  545|      1|      {"X520.Pseudonym", OID({2, 5, 4, 65})},
  546|      1|      {"X520.SerialNumber", OID({2, 5, 4, 5})},
  547|      1|      {"X520.State", OID({2, 5, 4, 8})},
  548|      1|      {"X520.StreetAddress", OID({2, 5, 4, 9})},
  549|      1|      {"X520.Surname", OID({2, 5, 4, 4})},
  550|      1|      {"X520.Title", OID({2, 5, 4, 12})},
  551|      1|      {"XMSS", OID({0, 4, 0, 127, 0, 15, 1, 1, 13, 0})},
  552|      1|      {"XMSS-draft12", OID({1, 3, 6, 1, 4, 1, 25258, 1, 8})},
  553|      1|      {"XMSS-draft6", OID({1, 3, 6, 1, 4, 1, 25258, 1, 5})},
  554|      1|      {"brainpool160r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 1})},
  555|      1|      {"brainpool192r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 3})},
  556|      1|      {"brainpool224r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 5})},
  557|      1|      {"brainpool256r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 7})},
  558|      1|      {"brainpool320r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 9})},
  559|      1|      {"brainpool384r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 11})},
  560|      1|      {"brainpool512r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 13})},
  561|      1|      {"eFrodoKEM-1344-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 3})},
  562|      1|      {"eFrodoKEM-1344-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 3})},
  563|      1|      {"eFrodoKEM-640-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 1})},
  564|      1|      {"eFrodoKEM-640-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 1})},
  565|      1|      {"eFrodoKEM-976-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 2})},
  566|      1|      {"eFrodoKEM-976-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 2})},
  567|      1|      {"frp256v1", OID({1, 2, 250, 1, 223, 101, 256, 1})},
  568|      1|      {"gost_256A", OID({1, 2, 643, 7, 1, 2, 1, 1, 1})},
  569|      1|      {"gost_256B", OID({1, 2, 643, 7, 1, 2, 1, 1, 2})},
  570|      1|      {"gost_512A", OID({1, 2, 643, 7, 1, 2, 1, 2, 1})},
  571|      1|      {"gost_512B", OID({1, 2, 643, 7, 1, 2, 1, 2, 2})},
  572|      1|      {"secp160k1", OID({1, 3, 132, 0, 9})},
  573|      1|      {"secp160r1", OID({1, 3, 132, 0, 8})},
  574|      1|      {"secp160r2", OID({1, 3, 132, 0, 30})},
  575|      1|      {"secp192k1", OID({1, 3, 132, 0, 31})},
  576|      1|      {"secp192r1", OID({1, 2, 840, 10045, 3, 1, 1})},
  577|      1|      {"secp224k1", OID({1, 3, 132, 0, 32})},
  578|      1|      {"secp224r1", OID({1, 3, 132, 0, 33})},
  579|      1|      {"secp256k1", OID({1, 3, 132, 0, 10})},
  580|      1|      {"secp256r1", OID({1, 2, 840, 10045, 3, 1, 7})},
  581|      1|      {"secp384r1", OID({1, 3, 132, 0, 34})},
  582|      1|      {"secp521r1", OID({1, 3, 132, 0, 35})},
  583|      1|      {"sm2p256v1", OID({1, 2, 156, 10197, 1, 301})},
  584|      1|      {"x962_p192v2", OID({1, 2, 840, 10045, 3, 1, 2})},
  585|      1|      {"x962_p192v3", OID({1, 2, 840, 10045, 3, 1, 3})},
  586|      1|      {"x962_p239v1", OID({1, 2, 840, 10045, 3, 1, 4})},
  587|      1|      {"x962_p239v2", OID({1, 2, 840, 10045, 3, 1, 5})},
  588|      1|      {"x962_p239v3", OID({1, 2, 840, 10045, 3, 1, 6})}};
  589|      1|}

_ZN5Botan6BigIntC2EPKhm:
   91|  1.07k|BigInt::BigInt(const uint8_t input[], size_t length) {
   92|  1.07k|   binary_decode(input, length);
   93|  1.07k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  198|    635|size_t BigInt::Data::calc_sig_words() const {
  199|    635|   const size_t sz = m_reg.size();
  200|    635|   size_t sig = sz;
  201|       |
  202|    635|   word sub = 1;
  203|       |
  204|  14.0k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (204:22): [True: 13.4k, False: 635]
  ------------------
  205|  13.4k|      const word w = m_reg[sz - i - 1];
  206|  13.4k|      sub &= ct_is_zero(w);
  207|  13.4k|      sig -= sub;
  208|  13.4k|   }
  209|       |
  210|       |   /*
  211|       |   * This depends on the data so is poisoned, but unpoison it here as
  212|       |   * later conditionals are made on the size.
  213|       |   */
  214|    635|   CT::unpoison(sig);
  215|       |
  216|    635|   return sig;
  217|    635|}
_ZN5Botan6BigInt13binary_decodeEPKhm:
  403|  1.07k|void BigInt::binary_decode(const uint8_t buf[], size_t length) {
  404|  1.07k|   clear();
  405|       |
  406|  1.07k|   const size_t full_words = length / sizeof(word);
  407|  1.07k|   const size_t extra_bytes = length % sizeof(word);
  408|       |
  409|  1.07k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (409:52): [True: 861, False: 212]
  ------------------
  410|       |
  411|  11.3k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (411:22): [True: 10.3k, False: 1.07k]
  ------------------
  412|  10.3k|      reg[i] = load_be<word>(buf + length - sizeof(word) * (i + 1), 0);
  413|  10.3k|   }
  414|       |
  415|  1.07k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (415:7): [True: 861, False: 212]
  ------------------
  416|  2.19k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (416:25): [True: 1.33k, False: 861]
  ------------------
  417|  1.33k|         reg[full_words] = (reg[full_words] << 8) | buf[i];
  418|  1.33k|      }
  419|    861|   }
  420|       |
  421|  1.07k|   m_data.swap(reg);
  422|  1.07k|}

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

_ZN5Botan22throw_invalid_argumentEPKcS1_S1_:
   21|    849|void throw_invalid_argument(const char* message, const char* func, const char* file) {
   22|    849|   throw Invalid_Argument(fmt("{} in {}:{}", message, func, file));
   23|    849|}

_ZN5Botan12ucs2_to_utf8EPKhm:
   54|  1.05k|std::string ucs2_to_utf8(const uint8_t ucs2[], size_t len) {
   55|  1.05k|   if(len % 2 != 0) {
  ------------------
  |  Branch (55:7): [True: 197, False: 856]
  ------------------
   56|    197|      throw Decoding_Error("Invalid length for UCS-2 string");
   57|    197|   }
   58|       |
   59|    856|   const size_t chars = len / 2;
   60|       |
   61|    856|   std::string s;
   62|  14.7k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (62:22): [True: 13.8k, False: 856]
  ------------------
   63|  13.8k|      const uint32_t c = load_be<uint16_t>(ucs2, i);
   64|  13.8k|      append_utf8_for(s, c);
   65|  13.8k|   }
   66|       |
   67|    856|   return s;
   68|  1.05k|}
_ZN5Botan12ucs4_to_utf8EPKhm:
   70|  1.22k|std::string ucs4_to_utf8(const uint8_t ucs4[], size_t len) {
   71|  1.22k|   if(len % 4 != 0) {
  ------------------
  |  Branch (71:7): [True: 197, False: 1.02k]
  ------------------
   72|    197|      throw Decoding_Error("Invalid length for UCS-4 string");
   73|    197|   }
   74|       |
   75|  1.02k|   const size_t chars = len / 4;
   76|       |
   77|  1.02k|   std::string s;
   78|  3.37k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (78:22): [True: 2.35k, False: 1.02k]
  ------------------
   79|  2.35k|      const uint32_t c = load_be<uint32_t>(ucs4, i);
   80|  2.35k|      append_utf8_for(s, c);
   81|  2.35k|   }
   82|       |
   83|  1.02k|   return s;
   84|  1.22k|}
_ZN5Botan14latin1_to_utf8EPKhm:
   89|    728|std::string latin1_to_utf8(const uint8_t chars[], size_t len) {
   90|    728|   std::string s;
   91|  11.9k|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (91:22): [True: 11.2k, False: 728]
  ------------------
   92|  11.2k|      const uint32_t c = static_cast<uint8_t>(chars[i]);
   93|  11.2k|      append_utf8_for(s, c);
   94|  11.2k|   }
   95|    728|   return s;
   96|    728|}
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   18|  27.5k|void append_utf8_for(std::string& s, uint32_t c) {
   19|  27.5k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (19:7): [True: 3.05k, False: 24.4k]
  |  Branch (19:22): [True: 406, False: 2.64k]
  ------------------
   20|    406|      throw Decoding_Error("Invalid Unicode character");
   21|    406|   }
   22|       |
   23|  27.0k|   if(c <= 0x7F) {
  ------------------
  |  Branch (23:7): [True: 9.46k, False: 17.6k]
  ------------------
   24|  9.46k|      const uint8_t b0 = static_cast<uint8_t>(c);
   25|  9.46k|      s.push_back(static_cast<char>(b0));
   26|  17.6k|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (26:14): [True: 4.58k, False: 13.0k]
  ------------------
   27|  4.58k|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   28|  4.58k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   29|  4.58k|      s.push_back(static_cast<char>(b0));
   30|  4.58k|      s.push_back(static_cast<char>(b1));
   31|  13.0k|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (31:14): [True: 11.1k, False: 1.93k]
  ------------------
   32|  11.1k|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   33|  11.1k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   34|  11.1k|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   35|  11.1k|      s.push_back(static_cast<char>(b0));
   36|  11.1k|      s.push_back(static_cast<char>(b1));
   37|  11.1k|      s.push_back(static_cast<char>(b2));
   38|  11.1k|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (38:14): [True: 1.48k, False: 458]
  ------------------
   39|  1.48k|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   40|  1.48k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   41|  1.48k|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   42|  1.48k|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   43|  1.48k|      s.push_back(static_cast<char>(b0));
   44|  1.48k|      s.push_back(static_cast<char>(b1));
   45|  1.48k|      s.push_back(static_cast<char>(b2));
   46|  1.48k|      s.push_back(static_cast<char>(b3));
   47|  1.48k|   } else {
   48|    458|      throw Decoding_Error("Invalid Unicode character");
   49|    458|   }
   50|  27.0k|}

_ZN5Botan10DataSource9read_byteERh:
   26|   768k|size_t DataSource::read_byte(uint8_t& out) {
   27|   768k|   return read(&out, 1);
   28|   768k|}
_ZN5Botan10DataSource12discard_nextEm:
   40|   249k|size_t DataSource::discard_next(size_t n) {
   41|   249k|   uint8_t buf[64] = {0};
   42|   249k|   size_t discarded = 0;
   43|       |
   44|   507k|   while(n) {
  ------------------
  |  Branch (44:10): [True: 258k, False: 248k]
  ------------------
   45|   258k|      const size_t got = this->read(buf, std::min(n, sizeof(buf)));
   46|   258k|      discarded += got;
   47|   258k|      n -= got;
   48|       |
   49|   258k|      if(got == 0) {
  ------------------
  |  Branch (49:10): [True: 326, False: 258k]
  ------------------
   50|    326|         break;
   51|    326|      }
   52|   258k|   }
   53|       |
   54|   249k|   return discarded;
   55|   249k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   60|  1.12M|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   61|  1.12M|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   62|  1.12M|   copy_mem(out, m_source.data() + m_offset, got);
   63|  1.12M|   m_offset += got;
   64|  1.12M|   return got;
   65|  1.12M|}
_ZN5Botan17DataSource_Memory15check_availableEm:
   67|  95.6k|bool DataSource_Memory::check_available(size_t n) {
   68|  95.6k|   return (n <= (m_source.size() - m_offset));
   69|  95.6k|}
_ZNK5Botan17DataSource_Memory4peekEPhmm:
   74|   105k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   75|   105k|   const size_t bytes_left = m_source.size() - m_offset;
   76|   105k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (76:7): [True: 52.9k, False: 52.1k]
  ------------------
   77|  52.9k|      return 0;
   78|  52.9k|   }
   79|       |
   80|  52.1k|   const size_t got = std::min(bytes_left - peek_offset, length);
   81|  52.1k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   82|  52.1k|   return got;
   83|   105k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  12.4k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|  3.63k|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  8.77k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}

_ZN5Botan19secure_scrub_memoryEPvm:
   87|   294k|void secure_scrub_memory(void* ptr, size_t n) {
   88|       |#if defined(BOTAN_TARGET_OS_HAS_RTLSECUREZEROMEMORY)
   89|       |   ::RtlSecureZeroMemory(ptr, n);
   90|       |
   91|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_BZERO)
   92|   294k|   ::explicit_bzero(ptr, n);
   93|       |
   94|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_MEMSET)
   95|       |   (void)::explicit_memset(ptr, 0, n);
   96|       |
   97|       |#elif defined(BOTAN_USE_VOLATILE_MEMSET_FOR_ZERO) && (BOTAN_USE_VOLATILE_MEMSET_FOR_ZERO == 1)
   98|       |   /*
   99|       |   Call memset through a static volatile pointer, which the compiler
  100|       |   should not elide. This construct should be safe in conforming
  101|       |   compilers, but who knows. I did confirm that on x86-64 GCC 6.1 and
  102|       |   Clang 3.8 both create code that saves the memset address in the
  103|       |   data segment and unconditionally loads and jumps to that address.
  104|       |   */
  105|       |   static void* (*const volatile memset_ptr)(void*, int, size_t) = std::memset;
  106|       |   (memset_ptr)(ptr, 0, n);
  107|       |#else
  108|       |
  109|       |   volatile uint8_t* p = reinterpret_cast<volatile uint8_t*>(ptr);
  110|       |
  111|       |   for(size_t i = 0; i != n; ++i)
  112|       |      p[i] = 0;
  113|       |#endif
  114|   294k|}

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