_ZN5Botan14expand_top_bitIhEET_S1_:
   25|   241k|{
   26|   241k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|   241k|}
_ZN5Botan10ct_is_zeroImEET_S1_:
   35|   116k|{
   36|   116k|   return expand_top_bit<T>(~x & (x - 1));
   37|   116k|}
_ZN5Botan14expand_top_bitImEET_S1_:
   25|   116k|{
   26|   116k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|   116k|}
_ZN5Botan6chooseIhEET_S1_S1_S1_:
  180|   241k|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   241k|   return (b ^ (mask & (a ^ b)));
  183|   241k|}
_ZN5Botan8high_bitImEEmT_:
   60|  8.76k|{
   61|  8.76k|   size_t hb = 0;
   62|       |
   63|  61.3k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 52.5k, False: 8.76k]
  ------------------
   64|  52.5k|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|  52.5k|      hb += z;
   66|  52.5k|      n >>= z;
   67|  52.5k|   }
   68|       |
   69|  8.76k|   hb += n;
   70|       |
   71|  8.76k|   return hb;
   72|  8.76k|}
_ZN5Botan10ct_is_zeroIhEET_S1_:
   35|   103k|{
   36|   103k|   return expand_top_bit<T>(~x & (x - 1));
   37|   103k|}

_ZN5Botan13reverse_bytesEt:
   19|  4.07k|inline constexpr uint16_t reverse_bytes(uint16_t x) {
   20|  4.07k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   21|  4.07k|   return __builtin_bswap16(x);
   22|       |#else
   23|       |   return static_cast<uint16_t>((x << 8) | (x >> 8));
   24|       |#endif
   25|  4.07k|}
_ZN5Botan13reverse_bytesEj:
   33|  2.26k|inline constexpr uint32_t reverse_bytes(uint32_t x) {
   34|  2.26k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   35|  2.26k|   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.26k|}
_ZN5Botan13reverse_bytesEm:
   48|  23.1k|inline constexpr uint64_t reverse_bytes(uint64_t x) {
   49|  23.1k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   50|  23.1k|   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|  23.1k|}

base64.cpp:_ZN5Botan11base_decodeIRNS_12_GLOBAL__N_16Base64EEEmOT_PhPKcmRmbb:
  118|    216|                   bool ignore_ws = true) {
  119|    216|   const size_t decoding_bytes_in = base.decoding_bytes_in();
  120|    216|   const size_t decoding_bytes_out = base.decoding_bytes_out();
  121|       |
  122|    216|   uint8_t* out_ptr = output;
  123|    216|   std::vector<uint8_t> decode_buf(decoding_bytes_in, 0);
  124|    216|   size_t decode_buf_pos = 0;
  125|    216|   size_t final_truncate = 0;
  126|       |
  127|    216|   clear_mem(output, base.decode_max_output(input_length));
  128|       |
  129|  32.6k|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (129:22): [True: 32.3k, False: 216]
  ------------------
  130|  32.3k|      const uint8_t bin = base.lookup_binary_value(input[i]);
  131|       |
  132|       |      // This call might throw Invalid_Argument
  133|  32.3k|      if(base.check_bad_char(bin, input[i], ignore_ws)) {
  ------------------
  |  Branch (133:10): [True: 19.8k, False: 12.5k]
  ------------------
  134|  19.8k|         decode_buf[decode_buf_pos] = bin;
  135|  19.8k|         ++decode_buf_pos;
  136|  19.8k|      }
  137|       |
  138|       |      /*
  139|       |      * If we're at the end of the input, pad with 0s and truncate
  140|       |      */
  141|  32.3k|      if(final_inputs && (i == input_length - 1)) {
  ------------------
  |  Branch (141:10): [True: 32.3k, False: 37]
  |  Branch (141:26): [True: 94, False: 32.2k]
  ------------------
  142|     94|         if(decode_buf_pos) {
  ------------------
  |  Branch (142:13): [True: 38, False: 56]
  ------------------
  143|    117|            for(size_t j = decode_buf_pos; j < decoding_bytes_in; ++j) {
  ------------------
  |  Branch (143:44): [True: 79, False: 38]
  ------------------
  144|     79|               decode_buf[j] = 0;
  145|     79|            }
  146|       |
  147|     38|            final_truncate = decoding_bytes_in - decode_buf_pos;
  148|     38|            decode_buf_pos = decoding_bytes_in;
  149|     38|         }
  150|     94|      }
  151|       |
  152|  32.3k|      if(decode_buf_pos == decoding_bytes_in) {
  ------------------
  |  Branch (152:10): [True: 4.99k, False: 27.4k]
  ------------------
  153|  4.99k|         base.decode(out_ptr, decode_buf.data());
  154|       |
  155|  4.99k|         out_ptr += decoding_bytes_out;
  156|  4.99k|         decode_buf_pos = 0;
  157|  4.99k|         input_consumed = i + 1;
  158|  4.99k|      }
  159|  32.3k|   }
  160|       |
  161|  2.29k|   while(input_consumed < input_length && base.lookup_binary_value(input[input_consumed]) == 0x80) {
  ------------------
  |  Branch (161:10): [True: 2.11k, False: 188]
  |  Branch (161:43): [True: 2.08k, False: 28]
  ------------------
  162|  2.08k|      ++input_consumed;
  163|  2.08k|   }
  164|       |
  165|    216|   size_t written = (out_ptr - output) - base.bytes_to_remove(final_truncate);
  166|       |
  167|    216|   return written;
  168|    216|}
base64.cpp:_ZN5Botan18base_decode_to_vecINSt3__16vectorIhNS_16secure_allocatorIhEEEENS_12_GLOBAL__N_16Base64EEET_OT0_PKcmb:
  183|    216|Vector base_decode_to_vec(Base&& base, const char input[], size_t input_length, bool ignore_ws) {
  184|    216|   const size_t output_length = base.decode_max_output(input_length);
  185|    216|   Vector bin(output_length);
  186|       |
  187|    216|   const size_t written = base_decode_full(base, bin.data(), input, input_length, ignore_ws);
  188|       |
  189|    216|   bin.resize(written);
  190|    216|   return bin;
  191|    216|}
base64.cpp:_ZN5Botan16base_decode_fullIRNS_12_GLOBAL__N_16Base64EEEmOT_PhPKcmb:
  171|    216|size_t base_decode_full(Base&& base, uint8_t output[], const char input[], size_t input_length, bool ignore_ws) {
  172|    216|   size_t consumed = 0;
  173|    216|   const size_t written = base_decode(base, output, input, input_length, consumed, true, ignore_ws);
  174|       |
  175|    216|   if(consumed != input_length) {
  ------------------
  |  Branch (175:7): [True: 28, False: 188]
  ------------------
  176|     28|      throw Invalid_Argument(base.name() + " decoding failed, input did not have full bytes");
  177|     28|   }
  178|       |
  179|    188|   return written;
  180|    216|}

_ZN5Botan2CT4MaskIhE3setEv:
   99|  4.09k|      static Mask<T> set() { return Mask<T>(static_cast<T>(~0)); }
_ZN5Botan2CT4MaskIhEC2Eh:
  280|   349k|      Mask(T m) : m_mask(m) {}
_ZN5Botan2CT4MaskIhE15is_within_rangeEhhh:
  150|   103k|      static Mask<T> is_within_range(T v, T l, T u) {
  151|       |         //return Mask<T>::is_gte(v, l) & Mask<T>::is_lte(v, u);
  152|       |
  153|   103k|         const T v_lt_l = v ^ ((v ^ l) | ((v - l) ^ v));
  154|   103k|         const T v_gt_u = u ^ ((u ^ v) | ((u - v) ^ u));
  155|   103k|         const T either = v_lt_l | v_gt_u;
  156|   103k|         return ~Mask<T>(expand_top_bit(either));
  157|   103k|      }
_ZNK5Botan2CT4MaskIhEcoEv:
  213|   103k|      Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskIhE5valueEv:
  277|   349k|      T value() const { return m_mask; }
_ZN5Botan2CT4MaskIhE9is_any_ofEhSt16initializer_listIhE:
  159|  34.5k|      static Mask<T> is_any_of(T v, std::initializer_list<T> accepted) {
  160|  34.5k|         T accept = 0;
  161|       |
  162|   138k|         for(auto a : accepted) {
  ------------------
  |  Branch (162:21): [True: 138k, False: 34.5k]
  ------------------
  163|   138k|            const T diff = a ^ v;
  164|   138k|            const T eq_zero = ~diff & (diff - 1);
  165|   138k|            accept |= eq_zero;
  166|   138k|         }
  167|       |
  168|  34.5k|         return Mask<T>(expand_top_bit(accept));
  169|  34.5k|      }
_ZNK5Botan2CT4MaskIhE7as_boolEv:
  272|  4.09k|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskIhE16unpoisoned_valueEv:
  263|  4.09k|      T unpoisoned_value() const {
  264|  4.09k|         T r = value();
  265|  4.09k|         CT::unpoison(r);
  266|  4.09k|         return r;
  267|  4.09k|      }
_ZN5Botan2CT8unpoisonIhEEvRT_:
   64|  4.09k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  4.09k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  4.09k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  4.09k|#endif
   70|  4.09k|}
_ZNK5Botan2CT4MaskIhE6selectEhh:
  228|   241k|      T select(T x, T y) const { return choose(value(), x, y); }
_ZN5Botan2CT8unpoisonImEEvRT_:
   64|  5.80k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  5.80k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  5.80k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  5.80k|#endif
   70|  5.80k|}
_ZN5Botan2CT8unpoisonIKmEEvRT_:
   64|  8.76k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  8.76k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  8.76k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  8.76k|#endif
   70|  8.76k|}
_ZN5Botan2CT4MaskIhE7is_zeroEh:
  123|   103k|      static Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(x)); }
_ZN5Botan2CT4MaskIhE8is_equalEhh:
  128|   103k|      static Mask<T> is_equal(T x, T y) { return Mask<T>::is_zero(static_cast<T>(x ^ y)); }

_ZN5Botan8FE_25519C2ESt16initializer_listIiE:
   37|  1.53k|      FE_25519(std::initializer_list<int32_t> x) {
   38|  1.53k|         if(x.size() != 10) {
  ------------------
  |  Branch (38:13): [True: 0, False: 1.53k]
  ------------------
   39|      0|            throw Invalid_Argument("Invalid FE_25519 initializer list");
   40|      0|         }
   41|  1.53k|         copy_mem(m_fe, x.begin(), 10);
   42|  1.53k|      }

_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  18.2k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  18.2k|   oss << format;
   22|  18.2k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  14.2k|std::string fmt(std::string_view format, const T&... args) {
   54|  14.2k|   std::ostringstream oss;
   55|  14.2k|   oss.imbue(std::locale::classic());
   56|  14.2k|   fmt_detail::do_fmt(oss, format, args...);
   57|  14.2k|   return oss.str();
   58|  14.2k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  14.2k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  14.2k|   size_t i = 0;
   27|       |
   28|   108k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 108k, False: 0]
  ------------------
   29|   108k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 14.2k, False: 94.0k]
  |  Branch (29:30): [True: 14.2k, False: 0]
  |  Branch (29:59): [True: 14.2k, False: 0]
  ------------------
   30|  14.2k|         oss << val;
   31|  14.2k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  94.0k|      } else {
   33|  94.0k|         oss << format[i];
   34|  94.0k|      }
   35|       |
   36|  94.0k|      i += 1;
   37|  94.0k|   }
   38|  14.2k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKcEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  2.96k|std::string fmt(std::string_view format, const T&... args) {
   54|  2.96k|   std::ostringstream oss;
   55|  2.96k|   oss.imbue(std::locale::classic());
   56|  2.96k|   fmt_detail::do_fmt(oss, format, args...);
   57|  2.96k|   return oss.str();
   58|  2.96k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJPKcEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  2.96k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  2.96k|   size_t i = 0;
   27|       |
   28|  2.96k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 2.96k, False: 0]
  ------------------
   29|  2.96k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 2.96k, False: 0]
  |  Branch (29:30): [True: 2.96k, False: 0]
  |  Branch (29:59): [True: 2.96k, False: 0]
  ------------------
   30|  2.96k|         oss << val;
   31|  2.96k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  2.96k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  2.96k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  3.17k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.17k|   size_t i = 0;
   27|       |
   28|  41.8k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 41.8k, False: 0]
  ------------------
   29|  41.8k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.17k, False: 38.6k]
  |  Branch (29:30): [True: 3.17k, False: 0]
  |  Branch (29:59): [True: 3.17k, False: 0]
  ------------------
   30|  3.17k|         oss << val;
   31|  3.17k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  38.6k|      } else {
   33|  38.6k|         oss << format[i];
   34|  38.6k|      }
   35|       |
   36|  38.6k|      i += 1;
   37|  38.6k|   }
   38|  3.17k|}
_ZN5Botan3fmtIJPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEENS3_12basic_stringIcS6_NS3_9allocatorIcEEEES7_DpRKT_:
   53|     14|std::string fmt(std::string_view format, const T&... args) {
   54|     14|   std::ostringstream oss;
   55|     14|   oss.imbue(std::locale::classic());
   56|     14|   fmt_detail::do_fmt(oss, format, args...);
   57|     14|   return oss.str();
   58|     14|}
_ZN5Botan10fmt_detail6do_fmtIPKcJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEvRNS4_19basic_ostringstreamIcS7_NS4_9allocatorIcEEEES8_RKT_DpRKT0_:
   25|     14|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     14|   size_t i = 0;
   27|       |
   28|     14|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 14, False: 0]
  ------------------
   29|     14|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 14, False: 0]
  |  Branch (29:30): [True: 14, False: 0]
  |  Branch (29:59): [True: 14, False: 0]
  ------------------
   30|     14|         oss << val;
   31|     14|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     14|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|     14|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|    348|std::string fmt(std::string_view format, const T&... args) {
   54|    348|   std::ostringstream oss;
   55|    348|   oss.imbue(std::locale::classic());
   56|    348|   fmt_detail::do_fmt(oss, format, args...);
   57|    348|   return oss.str();
   58|    348|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|    348|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    348|   size_t i = 0;
   27|       |
   28|    348|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 348, False: 0]
  ------------------
   29|    348|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 348, False: 0]
  |  Branch (29:30): [True: 348, False: 0]
  |  Branch (29:59): [True: 348, False: 0]
  ------------------
   30|    348|         oss << val;
   31|    348|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    348|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    348|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    447|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    447|   size_t i = 0;
   27|       |
   28|  4.41k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.41k, False: 0]
  ------------------
   29|  4.41k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 447, False: 3.96k]
  |  Branch (29:30): [True: 447, False: 0]
  |  Branch (29:59): [True: 447, False: 0]
  ------------------
   30|    447|         oss << val;
   31|    447|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.96k|      } else {
   33|  3.96k|         oss << format[i];
   34|  3.96k|      }
   35|       |
   36|  3.96k|      i += 1;
   37|  3.96k|   }
   38|    447|}
_ZN5Botan3fmtIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|     99|std::string fmt(std::string_view format, const T&... args) {
   54|     99|   std::ostringstream oss;
   55|     99|   oss.imbue(std::locale::classic());
   56|     99|   fmt_detail::do_fmt(oss, format, args...);
   57|     99|   return oss.str();
   58|     99|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    337|std::string fmt(std::string_view format, const T&... args) {
   54|    337|   std::ostringstream oss;
   55|    337|   oss.imbue(std::locale::classic());
   56|    337|   fmt_detail::do_fmt(oss, format, args...);
   57|    337|   return oss.str();
   58|    337|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    337|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    337|   size_t i = 0;
   27|       |
   28|  4.29k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.29k, False: 0]
  ------------------
   29|  4.29k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 337, False: 3.95k]
  |  Branch (29:30): [True: 337, False: 0]
  |  Branch (29:59): [True: 337, False: 0]
  ------------------
   30|    337|         oss << val;
   31|    337|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.95k|      } else {
   33|  3.95k|         oss << format[i];
   34|  3.95k|      }
   35|       |
   36|  3.95k|      i += 1;
   37|  3.95k|   }
   38|    337|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|    212|std::string fmt(std::string_view format, const T&... args) {
   54|    212|   std::ostringstream oss;
   55|    212|   oss.imbue(std::locale::classic());
   56|    212|   fmt_detail::do_fmt(oss, format, args...);
   57|    212|   return oss.str();
   58|    212|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    212|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    212|   size_t i = 0;
   27|       |
   28|    212|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 212, False: 0]
  ------------------
   29|    212|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 212, False: 0]
  |  Branch (29:30): [True: 212, False: 0]
  |  Branch (29:59): [True: 212, False: 0]
  ------------------
   30|    212|         oss << val;
   31|    212|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    212|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    212|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    212|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    212|   size_t i = 0;
   27|       |
   28|  1.06k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.06k, False: 0]
  ------------------
   29|  1.06k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 212, False: 848]
  |  Branch (29:30): [True: 212, False: 0]
  |  Branch (29:59): [True: 212, False: 0]
  ------------------
   30|    212|         oss << val;
   31|    212|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    848|      } else {
   33|    848|         oss << format[i];
   34|    848|      }
   35|       |
   36|    848|      i += 1;
   37|    848|   }
   38|    212|}

_ZN5Botan11make_uint16Ehh:
   50|    148|inline constexpr uint16_t make_uint16(uint8_t i0, uint8_t i1) {
   51|    148|   return static_cast<uint16_t>((static_cast<uint16_t>(i0) << 8) | i1);
   52|    148|}
_ZN5Botan8get_byteILm0EmEEhT0_:
   39|  15.0k|{
   40|  15.0k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  15.0k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  15.0k|}
_ZN5Botan12get_byte_varImEEhmT_:
   27|  15.4k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   28|  15.4k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   29|  15.4k|}
_ZN5Botan8store_beImEEvT_Ph:
  408|  4.12k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|  4.12k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|  4.12k|}
_ZN5Botan8store_beImNSt3__14spanIhLm8EEEEEvT_OT0_:
  358|  4.12k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|  4.12k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|  4.12k|   std::span out{out_range};
  361|  4.12k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|  4.12k|      out[0] = static_cast<uint8_t>(in);
  363|  4.12k|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|  4.12k|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|  4.12k|   }
  375|  4.12k|}
_ZN5Botan8store_beIjEEvT_Ph:
  408|    889|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|    889|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|    889|}
_ZN5Botan8store_beIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  358|    889|inline constexpr void store_be(T in, OutR&& out_range) {
  359|    889|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|    889|   std::span out{out_range};
  361|    889|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|    889|      out[0] = static_cast<uint8_t>(in);
  363|    889|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|    889|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|    889|   }
  375|    889|}
_ZN5Botan7load_beIjEET_PKhm:
  226|  1.37k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  1.37k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  1.37k|}
_ZN5Botan7load_beIjNSt3__14spanIKhLm4EEEEET_OT0_:
   92|  1.37k|inline constexpr T load_be(InR&& in_range) {
   93|  1.37k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  1.37k|   std::span in{in_range};
   95|  1.37k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  1.37k|      return static_cast<T>(in[0]);
   97|  1.37k|   } 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|  1.37k|      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|  1.37k|   }
  109|  1.37k|}
_ZN5Botan7load_beImEET_PKhm:
  226|  19.0k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  19.0k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  19.0k|}
_ZN5Botan7load_beImNSt3__14spanIKhLm8EEEEET_OT0_:
   92|  19.0k|inline constexpr T load_be(InR&& in_range) {
   93|  19.0k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  19.0k|   std::span in{in_range};
   95|  19.0k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  19.0k|      return static_cast<T>(in[0]);
   97|  19.0k|   } 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|  19.0k|      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|  19.0k|   }
  109|  19.0k|}
_ZN5Botan7load_beItEET_PKhm:
  226|  4.07k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  4.07k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  4.07k|}
_ZN5Botan7load_beItNSt3__14spanIKhLm2EEEEET_OT0_:
   92|  4.07k|inline constexpr T load_be(InR&& in_range) {
   93|  4.07k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  4.07k|   std::span in{in_range};
   95|  4.07k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  4.07k|      return static_cast<T>(in[0]);
   97|  4.07k|   } 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|  4.07k|      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|  4.07k|   }
  109|  4.07k|}

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

_ZN5Botan11checked_mulEmm:
   47|   259k|inline std::optional<size_t> checked_mul(size_t x, size_t y) {
   48|   259k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   49|   259k|   size_t z;
   50|   259k|   if(__builtin_mul_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (50:7): [True: 0, False: 259k]
  ------------------
   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|   259k|   return z;
   62|   259k|}
_ZN5Botan11checked_addEmmPKci:
   30|   192k|inline size_t checked_add(size_t x, size_t y, const char* file, int line) {
   31|   192k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   32|   192k|   size_t z;
   33|   192k|   if(__builtin_add_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (33:7): [True: 0, False: 192k]
  ------------------
   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|   192k|   return z;
   45|   192k|}

_ZN5Botan9SIMD_4x32C2EDv2_x:
  597|      2|      explicit SIMD_4x32(native_simd_type x) noexcept : m_simd(x) {}
_ZN5Botan9SIMD_4x32C2Ejjjj:
  113|     96|      SIMD_4x32(uint32_t B0, uint32_t B1, uint32_t B2, uint32_t B3) noexcept {
  114|     96|#if defined(BOTAN_SIMD_USE_SSE2)
  115|     96|         m_simd = _mm_set_epi32(B3, B2, B1, B0);
  116|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  117|       |         __vector unsigned int val = {B0, B1, B2, B3};
  118|       |         m_simd = val;
  119|       |#elif defined(BOTAN_SIMD_USE_NEON)
  120|       |         // Better way to do this?
  121|       |         const uint32_t B[4] = {B0, B1, B2, B3};
  122|       |         m_simd = vld1q_u32(B);
  123|       |#endif
  124|     96|      }
_ZN5Botan9SIMD_4x328splat_u8Eh:
  142|      2|      static SIMD_4x32 splat_u8(uint8_t B) noexcept {
  143|      2|#if defined(BOTAN_SIMD_USE_SSE2)
  144|      2|         return SIMD_4x32(_mm_set1_epi8(B));
  145|       |#elif defined(BOTAN_SIMD_USE_NEON)
  146|       |         return SIMD_4x32(vreinterpretq_u32_u8(vdupq_n_u8(B)));
  147|       |#else
  148|       |         const uint32_t B4 = make_uint32(B, B, B, B);
  149|       |         return SIMD_4x32(B4, B4, B4, B4);
  150|       |#endif
  151|      2|      }

_ZN5Botan15multimap_insertINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEvRNS1_8multimapIT_T0_NS1_4lessIS9_EENS5_INS1_4pairIKS9_SA_EEEEEERSE_RKSA_:
  109|  1.17k|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|  1.17k|   multimap.insert(std::make_pair(key, value));
  111|  1.17k|}
_ZN5Botan15multimap_insertINS_3OIDENS_11ASN1_StringEEEvRNSt3__18multimapIT_T0_NS3_4lessIS5_EENS3_9allocatorINS3_4pairIKS5_S6_EEEEEERSB_RKS6_:
  109|  1.60k|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|  1.60k|   multimap.insert(std::make_pair(key, value));
  111|  1.60k|}

_ZN5Botan11ASN1_ObjectD2Ev:
  120|   361k|      virtual ~ASN1_Object() = default;
_ZN5Botan10BER_ObjectC2Ev:
  128|   292k|      BER_Object() : m_type_tag(ASN1_Type::NoObject), m_class_tag(ASN1_Class::Universal) {}
_ZNK5Botan10BER_Object6is_setEv:
  138|   445k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|   220k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|   220k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|   220k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  19.8k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|  1.83k|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|  2.13M|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|  4.62M|      size_t length() const { return m_value.size(); }
_ZN5Botan10BER_Object12mutable_bitsEm:
  169|   189k|      uint8_t* mutable_bits(size_t length) {
  170|   189k|         m_value.resize(length);
  171|   189k|         return m_value.data();
  172|   189k|      }
_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|      }
_ZNK5Botan3OID9has_valueEv:
  271|  1.26k|      bool has_value() const { return (m_id.empty() == false); }
_ZNK5Botan3OID14get_componentsEv:
  277|   142k|      const std::vector<uint32_t>& get_components() const { return m_id; }
_ZNK5Botan3OIDeqERKS0_:
  309|   159k|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan11ASN1_String5valueEv:
  415|  2.59k|      const std::string& value() const { return m_utf8_str; }
_ZNK5Botan11ASN1_String5emptyEv:
  419|  3.68k|      bool empty() const { return m_utf8_str.empty(); }
_ZNK5Botan19AlgorithmIdentifier3oidEv:
  455|  4.59k|      const OID& oid() const { return m_oid; }
_ZNK5Botan19AlgorithmIdentifier10parametersEv:
  457|    376|      const std::vector<uint8_t>& parameters() const { return m_parameters; }
_ZNK5Botan19AlgorithmIdentifier20parameters_are_emptyEv:
  469|  4.36k|      bool parameters_are_empty() const { return m_parameters.empty(); }
_ZNK5Botan19AlgorithmIdentifier28parameters_are_null_or_emptyEv:
  471|  4.36k|      bool parameters_are_null_or_empty() const { return parameters_are_empty() || parameters_are_null(); }
  ------------------
  |  Branch (471:58): [True: 3.52k, False: 834]
  |  Branch (471:84): [True: 646, False: 188]
  ------------------
_ZN5BotanorENS_10ASN1_ClassES0_:
   78|  88.9k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   79|  88.9k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   80|  88.9k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|   220k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|   220k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|   220k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  30.5k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  30.5k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  30.5k|}
_ZN5BotanneERKNS_3OIDES2_:
  326|  2.29k|inline bool operator!=(const OID& a, const OID& b) {
  327|  2.29k|   return !(a == b);
  328|  2.29k|}
_ZN5Botan11ASN1_ObjectC2Ev:
  117|   249k|      ASN1_Object() = default;
_ZN5Botan19AlgorithmIdentifierC2Ev:
  447|  6.42k|      AlgorithmIdentifier() = default;
_ZN5Botan3OIDC2Ev:
  218|  32.5k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectaSERKS0_:
  119|    860|      ASN1_Object& operator=(const ASN1_Object&) = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|   112k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan9ASN1_TimeC2Ev:
  362|  10.0k|      ASN1_Time() = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  136|  70.5k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  134|  89.2k|      BER_Object(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectaSERKS0_:
  132|  2.29k|      BER_Object& operator=(const BER_Object& other) = default;

_ZN5Botan12ignore_paramIRmEEvOT_:
  111|  5.80k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRhEEEvDpOT_:
  114|  4.09k|void ignore_params(T&&... args) {
  115|  4.09k|   (ignore_param(args), ...);
  116|  4.09k|}
_ZN5Botan12ignore_paramIRhEEvOT_:
  111|  4.09k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRmEEEvDpOT_:
  114|  5.80k|void ignore_params(T&&... args) {
  115|  5.80k|   (ignore_param(args), ...);
  116|  5.80k|}
_ZN5Botan13ignore_paramsIJRKmEEEvDpOT_:
  114|  8.76k|void ignore_params(T&&... args) {
  115|  8.76k|   (ignore_param(args), ...);
  116|  8.76k|}
_ZN5Botan12ignore_paramIRKmEEvOT_:
  111|  8.76k|void ignore_param(T&&) {}

_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  4.63k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  4.63k|   BER_Object obj = get_next_object();
  319|       |
  320|  4.63k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 1.30k, False: 3.33k]
  ------------------
  321|  1.30k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 0, False: 1.30k]
  ------------------
  322|      0|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|  1.30k|      } else {
  324|  1.30k|         push_back(std::move(obj));
  325|  1.30k|         decode(out, type_tag, class_tag);
  326|  1.30k|      }
  327|  3.33k|   } else {
  328|  3.33k|      out = default_value;
  329|  3.33k|      push_back(std::move(obj));
  330|  3.33k|   }
  331|       |
  332|  4.63k|   return (*this);
  333|  4.63k|}
_ZN5Botan11BER_Decoder6decodeERm:
  181|    900|      BER_Decoder& decode(size_t& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectE:
   57|  1.66k|      BER_Decoder(BER_Object&& obj) : BER_Decoder(std::move(obj), nullptr) {}
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectE:
   52|  6.74k|      BER_Decoder(const BER_Object& obj) : BER_Decoder(obj.bits(), obj.length()) {}
_ZN5Botan11BER_Decoder14start_sequenceEv:
  113|  59.2k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9start_setEv:
  115|  4.19k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder22start_context_specificEj:
  117|  2.19k|      BER_Decoder start_context_specific(uint32_t tag) {
  118|  2.19k|         return start_cons(ASN1_Type(tag), ASN1_Class::ContextSpecific);
  119|  2.19k|      }
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  186|  4.40k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  198|  19.8k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  199|  19.8k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  200|  19.8k|      }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EE:
  162|  12.3k|      BER_Decoder& raw_bytes(std::vector<uint8_t, Alloc>& out) {
  163|  12.3k|         out.clear();
  164|  12.3k|         uint8_t buf;
  165|  1.54M|         while(m_source->read_byte(buf)) {
  ------------------
  |  Branch (165:16): [True: 1.53M, False: 12.3k]
  ------------------
  166|  1.53M|            out.push_back(buf);
  167|  1.53M|         }
  168|  12.3k|         return (*this);
  169|  12.3k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  17.1k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  17.1k|   BER_Object obj = get_next_object();
  319|       |
  320|  17.1k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 294, False: 16.8k]
  ------------------
  321|    294|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 0, False: 294]
  ------------------
  322|      0|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|    294|      } else {
  324|    294|         push_back(std::move(obj));
  325|    294|         decode(out, type_tag, class_tag);
  326|    294|      }
  327|  16.8k|   } else {
  328|  16.8k|      out = default_value;
  329|  16.8k|      push_back(std::move(obj));
  330|  16.8k|   }
  331|       |
  332|  17.1k|   return (*this);
  333|  17.1k|}
_ZN5Botan11BER_Decoder22decode_optional_stringINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeEjNS_10ASN1_ClassE:
  275|    359|                                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  276|    359|         BER_Object obj = get_next_object();
  277|       |
  278|    359|         ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
  279|       |
  280|    359|         if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (280:13): [True: 83, False: 276]
  ------------------
  281|     83|            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (281:16): [True: 0, False: 83]
  ------------------
  282|      0|               BER_Decoder(std::move(obj)).decode(out, real_type).verify_end();
  283|     83|            } else {
  284|     83|               push_back(std::move(obj));
  285|     83|               decode(out, real_type, type_tag, class_tag);
  286|     83|            }
  287|    276|         } else {
  288|    276|            out.clear();
  289|    276|            push_back(std::move(obj));
  290|    276|         }
  291|       |
  292|    359|         return (*this);
  293|    359|      }
_ZN5Botan11BER_Decoder11decode_listINS_3OIDEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    641|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    641|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  1.59k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 953, False: 641]
  ------------------
  368|    953|      T value;
  369|    953|      list.decode(value);
  370|    953|      vec.push_back(std::move(value));
  371|    953|   }
  372|       |
  373|    641|   list.end_cons();
  374|       |
  375|    641|   return (*this);
  376|    641|}
_ZN5Botan11BER_Decoder11decode_listINS_14GeneralSubtreeEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|  1.28k|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|  1.28k|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  3.36k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 2.07k, False: 1.28k]
  ------------------
  368|  2.07k|      T value;
  369|  2.07k|      list.decode(value);
  370|  2.07k|      vec.push_back(std::move(value));
  371|  2.07k|   }
  372|       |
  373|  1.28k|   list.end_cons();
  374|       |
  375|  1.28k|   return (*this);
  376|  1.28k|}
x509_ext.cpp:_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension12_GLOBAL__N_118Policy_InformationEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|  1.10k|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|  1.10k|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  1.69k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 593, False: 1.10k]
  ------------------
  368|    593|      T value;
  369|    593|      list.decode(value);
  370|    593|      vec.push_back(std::move(value));
  371|    593|   }
  372|       |
  373|  1.10k|   list.end_cons();
  374|       |
  375|  1.10k|   return (*this);
  376|  1.10k|}
_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension23CRL_Distribution_Points18Distribution_PointEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|  1.49k|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|  1.49k|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  3.35k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 1.86k, False: 1.49k]
  ------------------
  368|  1.86k|      T value;
  369|  1.86k|      list.decode(value);
  370|  1.86k|      vec.push_back(std::move(value));
  371|  1.86k|   }
  372|       |
  373|  1.49k|   list.end_cons();
  374|       |
  375|  1.49k|   return (*this);
  376|  1.49k|}
_ZN5Botan11BER_Decoder24decode_optional_implicitINS_15AlternativeNameEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassES6_S7_RKS4_:
  344|  1.97k|                                                   const T& default_value) {
  345|  1.97k|   BER_Object obj = get_next_object();
  346|       |
  347|  1.97k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (347:7): [True: 1.11k, False: 863]
  ------------------
  348|  1.11k|      obj.set_tagging(real_type, real_class);
  349|  1.11k|      push_back(std::move(obj));
  350|  1.11k|      decode(out, real_type, real_class);
  351|  1.11k|   } else {
  352|       |      // Not what we wanted, push it back on the stream
  353|    863|      out = default_value;
  354|    863|      push_back(std::move(obj));
  355|    863|   }
  356|       |
  357|  1.97k|   return (*this);
  358|  1.97k|}

_ZN5Botan6BigIntC2Ev:
   40|  7.94k|      BigInt() = default;
_ZNK5Botan6BigInt11is_negativeEv:
  528|  2.02k|      bool is_negative() const { return (sign() == Negative); }
_ZNK5Botan6BigInt4signEv:
  540|  3.28k|      Sign sign() const { return (m_signedness); }
_ZN5Botan6BigInt6encodeERKS0_:
  753|  4.32k|      static std::vector<uint8_t> encode(const BigInt& n) {
  754|  4.32k|         std::vector<uint8_t> output(n.bytes());
  755|  4.32k|         n.binary_encode(output.data());
  756|  4.32k|         return output;
  757|  4.32k|      }
_ZN5Botan6BigIntD2Ev:
  148|  13.7k|      ~BigInt() { const_time_unpoison(); }
_ZNK5Botan6BigInt19const_time_unpoisonEv:
  726|  13.7k|      void const_time_unpoison() const {}
_ZN5Botan6BigIntaSEOS0_:
  153|  5.83k|      BigInt& operator=(BigInt&& other) {
  154|  5.83k|         if(this != &other) {
  ------------------
  |  Branch (154:13): [True: 5.83k, False: 0]
  ------------------
  155|  5.83k|            this->swap(other);
  156|  5.83k|         }
  157|       |
  158|  5.83k|         return (*this);
  159|  5.83k|      }
_ZN5Botan6BigInt4swapERS0_:
  170|  5.83k|      void swap(BigInt& other) {
  171|  5.83k|         m_data.swap(other.m_data);
  172|  5.83k|         std::swap(m_signedness, other.m_signedness);
  173|  5.83k|      }
_ZN5Botan6BigInt5clearEv:
  370|  6.40k|      void clear() {
  371|  6.40k|         m_data.set_to_zero();
  372|  6.40k|         m_signedness = Positive;
  373|  6.40k|      }
_ZNK5Botan6BigInt7is_zeroEv:
  428|  1.26k|      bool is_zero() const { return (sig_words() == 0); }
_ZNK5Botan6BigInt7word_atEm:
  518|  21.9k|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZNK5Botan6BigInt12reverse_signEv:
  545|  1.26k|      Sign reverse_sign() const {
  546|  1.26k|         if(sign() == Positive) {
  ------------------
  |  Branch (546:13): [True: 1.26k, False: 0]
  ------------------
  547|  1.26k|            return Negative;
  548|  1.26k|         }
  549|      0|         return Positive;
  550|  1.26k|      }
_ZN5Botan6BigInt9flip_signEv:
  555|  1.26k|      void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  561|  1.26k|      void set_sign(Sign sign) {
  562|  1.26k|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (562:13): [True: 1.26k, False: 0]
  |  Branch (562:33): [True: 0, False: 1.26k]
  ------------------
  563|      0|            sign = Positive;
  564|      0|         }
  565|       |
  566|  1.26k|         m_signedness = sign;
  567|  1.26k|      }
_ZNK5Botan6BigInt9sig_wordsEv:
  584|  20.3k|      size_t sig_words() const { return m_data.sig_words(); }
_ZNK5Botan6BigInt4Data11get_word_atEm:
  848|  21.9k|            word get_word_at(size_t n) const {
  849|  21.9k|               if(n < m_reg.size()) {
  ------------------
  |  Branch (849:19): [True: 21.1k, False: 804]
  ------------------
  850|  21.1k|                  return m_reg[n];
  851|  21.1k|               }
  852|    804|               return 0;
  853|  21.9k|            }
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  871|  6.40k|            void set_to_zero() {
  872|  6.40k|               m_reg.resize(m_reg.capacity());
  873|  6.40k|               clear_mem(m_reg.data(), m_reg.size());
  874|  6.40k|               m_sig_words = 0;
  875|  6.40k|            }
_ZN5Botan6BigInt4Data4swapERS1_:
  921|  5.83k|            void swap(Data& other) {
  922|  5.83k|               m_reg.swap(other.m_reg);
  923|  5.83k|               std::swap(m_sig_words, other.m_sig_words);
  924|  5.83k|            }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  926|  5.83k|            void swap(secure_vector<word>& reg) {
  927|  5.83k|               m_reg.swap(reg);
  928|  5.83k|               invalidate_sig_words();
  929|  5.83k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
  931|  5.83k|            void invalidate_sig_words() const { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
  933|  20.3k|            size_t sig_words() const {
  934|  20.3k|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (934:19): [True: 5.80k, False: 14.5k]
  ------------------
  935|  5.80k|                  m_sig_words = calc_sig_words();
  936|  14.5k|               } else {
  937|  14.5k|                  BOTAN_DEBUG_ASSERT(m_sig_words == calc_sig_words());
  ------------------
  |  |   99|  14.5k|      do {                          \
  |  |  100|  14.5k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  938|  14.5k|               }
  939|  20.3k|               return m_sig_words;
  940|  20.3k|            }

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

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

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

_ZN5Botan11clear_bytesEPvm:
  103|  6.62k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  6.62k|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 131, False: 6.49k]
  ------------------
  105|    131|      std::memset(ptr, 0, bytes);
  106|    131|   }
  107|  6.62k|}
_ZN5Botan22cast_uint8_ptr_to_charEPKh:
  276|  19.0k|inline const char* cast_uint8_ptr_to_char(const uint8_t* b) {
  277|  19.0k|   return reinterpret_cast<const char*>(b);
  278|  19.0k|}
_ZN5Botan8copy_memIhEEvPT_PKS1_m:
  146|  2.60M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  2.60M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  2.60M|   do {                                                                                          \
  |  |   79|  5.08M|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 2.54M, False: 61.4k]
  |  |  |  Branch (79:23): [True: 2.54M, False: 0]
  |  |  |  Branch (79:23): [True: 2.54M, False: 0]
  |  |  ------------------
  |  |   80|  2.60M|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  2.60M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  2.60M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 2.59M, False: 5.10k]
  |  Branch (149:24): [True: 2.57M, False: 22.9k]
  |  Branch (149:42): [True: 2.54M, False: 33.4k]
  ------------------
  150|  2.54M|      std::memmove(out, in, sizeof(T) * n);
  151|  2.54M|   }
  152|  2.60M|}
_ZN5Botan9clear_memImEEvPT_m:
  120|  6.40k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  6.40k|   clear_bytes(ptr, sizeof(T) * n);
  122|  6.40k|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|    216|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|    216|   clear_bytes(ptr, sizeof(T) * n);
  122|    216|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEET_OT0_:
  209|  1.37k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  1.37k|   ToT dst;
  211|  1.37k|   typecast_copy(dst, src);
  212|  1.37k|   return dst;
  213|  1.37k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEEvRT_OT0_:
  188|  1.37k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  1.37k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.37k|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm1EEERNS2_IKhLm4EEEEEvOT_OT0_:
  176|  1.37k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  1.37k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.37k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.37k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEEmEEvOT_RKT0_:
  199|  4.12k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|  4.12k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|  4.12k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEENS2_IKmLm1EEEEEvOT_OT0_:
  176|  4.12k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  4.12k|   ranges::assert_equal_byte_lengths(out, in);
  178|  4.12k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  4.12k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEEjEEvOT_RKT0_:
  199|    889|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|    889|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|    889|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEENS2_IKjLm1EEEEEvOT_OT0_:
  176|    889|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|    889|   ranges::assert_equal_byte_lengths(out, in);
  178|    889|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|    889|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEET_OT0_:
  209|  19.0k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  19.0k|   ToT dst;
  211|  19.0k|   typecast_copy(dst, src);
  212|  19.0k|   return dst;
  213|  19.0k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEEvRT_OT0_:
  188|  19.0k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  19.0k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  19.0k|}
_ZN5Botan13typecast_copyINSt3__14spanImLm1EEERNS2_IKhLm8EEEEEvOT_OT0_:
  176|  19.0k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  19.0k|   ranges::assert_equal_byte_lengths(out, in);
  178|  19.0k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  19.0k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEET_OT0_:
  209|  4.07k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  4.07k|   ToT dst;
  211|  4.07k|   typecast_copy(dst, src);
  212|  4.07k|   return dst;
  213|  4.07k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEEvRT_OT0_:
  188|  4.07k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  4.07k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  4.07k|}
_ZN5Botan13typecast_copyINSt3__14spanItLm1EEERNS2_IKhLm2EEEEEvOT_OT0_:
  176|  4.07k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  4.07k|   ranges::assert_equal_byte_lengths(out, in);
  178|  4.07k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  4.07k|}
_ZN5Botan8copy_memIiEEvPT_PKS1_m:
  146|  1.53k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  1.53k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  1.53k|   do {                                                                                          \
  |  |   79|  3.07k|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  ------------------
  |  |   80|  1.53k|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  1.53k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  1.53k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 1.53k, False: 0]
  |  Branch (149:24): [True: 1.53k, False: 0]
  |  Branch (149:42): [True: 1.53k, False: 0]
  ------------------
  150|  1.53k|      std::memmove(out, in, sizeof(T) * n);
  151|  1.53k|   }
  152|  1.53k|}

_ZN5Botan15Key_ConstraintsC2ENS0_4BitsE:
  139|    824|      Key_Constraints(Key_Constraints::Bits bits) : m_value(bits) {}
_ZN5Botan15Key_ConstraintsC2Ej:
  141|    148|      explicit Key_Constraints(uint32_t bits) : m_value(bits) {}

_ZN5Botan7X509_DNC2Ev:
   39|  4.89k|      X509_DN() = default;
_ZN5Botan10ExtensionsC2Ev:
  517|  7.31k|      Extensions() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension10CRL_NumberEEEPKT_RKNS_3OIDE:
  397|    658|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|    658|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 17, False: 641]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     17|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 11, False: 6]
  ------------------
  401|     11|               return nullptr;
  402|     11|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 6, False: 0]
  ------------------
  403|      6|               return extn_as_T;
  404|      6|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     17|         }
  408|       |
  409|    641|         return nullptr;
  410|    658|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Authority_Key_IDEEEPKT_RKNS_3OIDE:
  397|    658|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|    658|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 20, False: 638]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     20|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 15, False: 5]
  ------------------
  401|     15|               return nullptr;
  402|     15|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 5, False: 0]
  ------------------
  403|      5|               return extn_as_T;
  404|      5|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     20|         }
  408|       |
  409|    638|         return nullptr;
  410|    658|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension30CRL_Issuing_Distribution_PointEEEPKT_RKNS_3OIDE:
  397|    658|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|    658|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 228, False: 430]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    228|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 35, False: 193]
  ------------------
  401|     35|               return nullptr;
  402|    193|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 193, False: 0]
  ------------------
  403|    193|               return extn_as_T;
  404|    193|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    228|         }
  408|       |
  409|    430|         return nullptr;
  410|    658|      }
_ZNK5Botan7X509_DN7dn_infoEv:
   70|  1.59k|      const std::vector<std::pair<OID, ASN1_String>>& dn_info() const { return m_rdn; }
_ZN5Botan14GeneralSubtreeC2Ev:
  246|  2.07k|      GeneralSubtree() : m_base(), m_minimum(0), m_maximum(std::numeric_limits<std::size_t>::max()) {}
_ZN5Botan15NameConstraintsC2Ev:
  299|  2.13k|      NameConstraints() : m_permitted_subtrees(), m_excluded_subtrees() {}
_ZN5Botan15NameConstraintsC2EONSt3__16vectorINS_14GeneralSubtreeENS1_9allocatorIS3_EEEES7_:
  308|    302|            m_permitted_subtrees(permitted_subtrees), m_excluded_subtrees(excluded_subtrees) {}
_ZN5Botan10Extensions15Extensions_InfoC2EbRKNSt3__16vectorIhNS2_9allocatorIhEEEENS2_10unique_ptrINS_21Certificate_ExtensionENS2_14default_deleteISA_EEEE:
  538|  16.5k|                  m_obj(std::move(ext)), m_bits(encoding), m_critical(critical) {}
_ZNK5Botan10Extensions15Extensions_Info3objEv:
  544|  1.11k|            const Certificate_Extension& obj() const {
  545|  1.11k|               BOTAN_ASSERT_NONNULL(m_obj.get());
  ------------------
  |  |   87|  1.11k|   do {                                                                                   \
  |  |   88|  1.11k|      if((ptr) == nullptr)                                                                \
  |  |  ------------------
  |  |  |  Branch (88:10): [True: 0, False: 1.11k]
  |  |  ------------------
  |  |   89|  1.11k|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |   90|  1.11k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  546|  1.11k|               return *m_obj;
  547|  1.11k|            }
_ZN5Botan21Certificate_ExtensionD2Ev:
  371|  25.9k|      virtual ~Certificate_Extension() = default;
_ZN5Botan11GeneralNameC2Ev:
  194|  2.07k|      GeneralName() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension14CRL_ReasonCodeEEEPKT_RKNS_3OIDE:
  397|  3.00k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.00k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 846, False: 2.15k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    846|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 664, False: 182]
  ------------------
  401|    664|               return nullptr;
  402|    664|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 182, False: 0]
  ------------------
  403|    182|               return extn_as_T;
  404|    182|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    846|         }
  408|       |
  409|  2.15k|         return nullptr;
  410|  3.00k|      }

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

_ZN5Botan9CRL_EntryC2Ev:
   59|  4.53k|      CRL_Entry() = default;

_ZN5Botan14Cert_Extension10CRL_Number10static_oidEv:
  349|  14.0k|      static OID static_oid() { return OID("2.5.29.20"); }
_ZN5Botan14Cert_Extension16Authority_Key_ID10static_oidEv:
  128|  11.9k|      static OID static_oid() { return OID("2.5.29.35"); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID10get_key_idEv:
  126|      5|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point10static_oidEv:
  457|  7.52k|      static OID static_oid() { return OID("2.5.29.28"); }
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point9get_pointEv:
  455|    193|      const AlternativeName& get_point() const { return m_distribution_point.point(); }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_Point5pointEv:
  406|    927|            const AlternativeName& point() const { return m_point; }
_ZN5Botan14Cert_Extension17Basic_ConstraintsC2Ebm:
   31|    778|      Basic_Constraints(bool ca = false, size_t limit = 0) : m_is_ca(ca), m_path_limit(limit) {}
_ZN5Botan14Cert_Extension17Basic_Constraints10static_oidEv:
   37|  14.1k|      static OID static_oid() { return OID("2.5.29.19"); }
_ZN5Botan14Cert_Extension9Key_UsageC2Ev:
   62|    824|      explicit Key_Usage() : m_constraints(Key_Constraints::None) {}
_ZN5Botan14Cert_Extension9Key_Usage10static_oidEv:
   66|  16.1k|      static OID static_oid() { return OID("2.5.29.15"); }
_ZN5Botan14Cert_Extension14Subject_Key_ID10static_oidEv:
   98|  16.5k|      static OID static_oid() { return OID("2.5.29.14"); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID8oid_nameEv:
  133|      5|      std::string oid_name() const override { return "X509v3.AuthorityKeyIdentifier"; }
_ZN5Botan14Cert_Extension24Subject_Alternative_Name10static_oidEv:
  150|  15.3k|      static OID static_oid() { return OID("2.5.29.17"); }
_ZN5Botan14Cert_Extension24Subject_Alternative_NameC2ERKNS_15AlternativeNameE:
  158|    657|      explicit Subject_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name10static_oidEv:
  178|  14.7k|      static OID static_oid() { return OID("2.5.29.18"); }
_ZN5Botan14Cert_Extension23Issuer_Alternative_NameC2ERKNS_15AlternativeNameE:
  186|    522|      explicit Issuer_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZN5Botan14Cert_Extension18Extended_Key_Usage10static_oidEv:
  214|  5.11k|      static OID static_oid() { return OID("2.5.29.37"); }
_ZN5Botan14Cert_Extension16Name_Constraints10static_oidEv:
  250|  10.5k|      static OID static_oid() { return OID("2.5.29.30"); }
_ZN5Botan14Cert_Extension20Certificate_Policies10static_oidEv:
  280|  6.21k|      static OID static_oid() { return OID("2.5.29.32"); }
_ZN5Botan14Cert_Extension28Authority_Information_Access10static_oidEv:
  318|  4.46k|      static OID static_oid() { return OID("1.3.6.1.5.5.7.1.1"); }
_ZN5Botan14Cert_Extension10CRL_NumberC2Ev:
  343|    900|      CRL_Number() : m_has_value(false), m_crl_number(0) {}
_ZNK5Botan14Cert_Extension10CRL_Number8oid_nameEv:
  354|      6|      std::string oid_name() const override { return "X509v3.CRLNumber"; }
_ZN5Botan14Cert_Extension14CRL_ReasonCodeC2ENS_8CRL_CodeE:
  374|  1.20k|      explicit CRL_ReasonCode(CRL_Code r = CRL_Code::Unspecified) : m_reason(r) {}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode10get_reasonEv:
  376|    182|      CRL_Code get_reason() const { return m_reason; }
_ZN5Botan14Cert_Extension14CRL_ReasonCode10static_oidEv:
  378|  15.5k|      static OID static_oid() { return OID("2.5.29.21"); }
_ZNK5Botan14Cert_Extension14CRL_ReasonCode8oid_nameEv:
  383|    182|      std::string oid_name() const override { return "X509v3.ReasonCode"; }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_PointC2ERKNS_15AlternativeNameE:
  404|  2.51k|            explicit Distribution_Point(const AlternativeName& name = AlternativeName()) : m_point(name) {}
_ZN5Botan14Cert_Extension23CRL_Distribution_Points10static_oidEv:
  424|  8.36k|      static OID static_oid() { return OID("2.5.29.31"); }
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point8oid_nameEv:
  462|    193|      std::string oid_name() const override { return "X509v3.CRLIssuingDistributionPoint"; }
_ZN5Botan14Cert_Extension17Unknown_ExtensionC2ERKNS_3OIDEb:
  509|  13.6k|      Unknown_Extension(const OID& oid, bool critical) : m_oid(oid), m_critical(critical) {}
_ZNK5Botan14Cert_Extension17Unknown_Extension8oid_nameEv:
  543|    725|      std::string oid_name() const override { return ""; }
_ZN5Botan14Cert_Extension14Subject_Key_IDC2Ev:
   86|    365|      Subject_Key_ID() = default;
_ZN5Botan14Cert_Extension16Authority_Key_IDC2Ev:
  122|    794|      Authority_Key_ID() = default;
_ZN5Botan14Cert_Extension16Name_ConstraintsC2Ev:
  238|  2.13k|      Name_Constraints() = default;
_ZN5Botan14Cert_Extension23CRL_Distribution_PointsC2Ev:
  416|  1.49k|      CRL_Distribution_Points() = default;
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_PointC2Ev:
  446|    652|      CRL_Issuing_Distribution_Point() = default;
_ZN5Botan14Cert_Extension20Certificate_PoliciesC2Ev:
  274|  1.10k|      Certificate_Policies() = default;
_ZN5Botan14Cert_Extension18Extended_Key_UsageC2Ev:
  208|    641|      Extended_Key_Usage() = default;
_ZN5Botan14Cert_Extension28Authority_Information_AccessC2Ev:
  310|    212|      Authority_Information_Access() = default;

_ZN5Botan11X509_ObjectD2Ev:
  103|  4.00k|      ~X509_Object() override = default;
_ZNK5Botan11X509_Object11signed_bodyEv:
   42|  2.78k|      const std::vector<uint8_t>& signed_body() const { return m_tbs_bits; }
_ZNK5Botan11X509_Object19signature_algorithmEv:
   47|  2.78k|      const AlgorithmIdentifier& signature_algorithm() const { return m_sig_algo; }
_ZN5Botan11X509_ObjectC2Ev:
  121|  4.00k|      X509_Object() = default;

_Z4fuzzPKhm:
   12|  4.00k|void fuzz(const uint8_t in[], size_t len) {
   13|  4.00k|   try {
   14|  4.00k|      Botan::DataSource_Memory input(in, len);
   15|  4.00k|      Botan::X509_CRL crl(input);
   16|  4.00k|   } catch(Botan::Exception& e) {}
   17|  4.00k|}

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|  4.01k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t in[], size_t len) {
   35|  4.01k|   if(len <= max_fuzzer_input_size) {
  ------------------
  |  Branch (35:7): [True: 4.00k, False: 9]
  ------------------
   36|  4.00k|      fuzz(in, len);
   37|  4.00k|   }
   38|  4.01k|   return 0;
   39|  4.01k|}

_ZNK5Botan19AlgorithmIdentifier19parameters_are_nullEv:
   50|    834|bool AlgorithmIdentifier::parameters_are_null() const {
   51|    834|   return (m_parameters.size() == 2 && (m_parameters[0] == 0x05) && (m_parameters[1] == 0x00));
  ------------------
  |  Branch (51:12): [True: 707, False: 127]
  |  Branch (51:40): [True: 665, False: 42]
  |  Branch (51:69): [True: 646, False: 19]
  ------------------
   52|    834|}
_ZN5BotaneqERKNS_19AlgorithmIdentifierES2_:
   54|  2.29k|bool operator==(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   55|  2.29k|   if(a1.oid() != a2.oid()) {
  ------------------
  |  Branch (55:7): [True: 30, False: 2.26k]
  ------------------
   56|     30|      return false;
   57|     30|   }
   58|       |
   59|       |   /*
   60|       |   * Treat NULL and empty as equivalent
   61|       |   */
   62|  2.26k|   if(a1.parameters_are_null_or_empty() && a2.parameters_are_null_or_empty()) {
  ------------------
  |  Branch (62:7): [True: 2.09k, False: 168]
  |  Branch (62:44): [True: 2.07k, False: 20]
  ------------------
   63|  2.07k|      return true;
   64|  2.07k|   }
   65|       |
   66|    188|   return (a1.parameters() == a2.parameters());
   67|  2.26k|}
_ZN5BotanneERKNS_19AlgorithmIdentifierES2_:
   69|  2.29k|bool operator!=(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   70|  2.29k|   return !(a1 == a2);
   71|  2.29k|}
_ZN5Botan19AlgorithmIdentifier11decode_fromERNS_11BER_DecoderE:
   83|  5.49k|void AlgorithmIdentifier::decode_from(BER_Decoder& codec) {
   84|  5.49k|   codec.start_sequence().decode(m_oid).raw_bytes(m_parameters).end_cons();
   85|  5.49k|}

_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   29|  96.8k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   30|  96.8k|   if(this->is_a(expected_type_tag, expected_class_tag) == false) {
  ------------------
  |  Branch (30:7): [True: 5.49k, False: 91.3k]
  ------------------
   31|  5.49k|      std::stringstream msg;
   32|       |
   33|  5.49k|      msg << "Tag mismatch when decoding " << descr << " got ";
   34|       |
   35|  5.49k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (35:10): [True: 617, False: 4.87k]
  |  Branch (35:49): [True: 617, False: 0]
  ------------------
   36|    617|         msg << "EOF";
   37|  4.87k|      } else {
   38|  4.87k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (38:13): [True: 1.65k, False: 3.21k]
  |  Branch (38:53): [True: 2.28k, False: 934]
  ------------------
   39|  3.94k|            msg << asn1_tag_to_string(m_type_tag);
   40|  3.94k|         } else {
   41|    934|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   42|    934|         }
   43|       |
   44|  4.87k|         msg << "/" << asn1_class_to_string(m_class_tag);
   45|  4.87k|      }
   46|       |
   47|  5.49k|      msg << " expected ";
   48|       |
   49|  5.49k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (49:10): [True: 1.64k, False: 3.84k]
  |  Branch (49:57): [True: 3.68k, False: 161]
  ------------------
   50|  5.33k|         msg << asn1_tag_to_string(expected_type_tag);
   51|  5.33k|      } else {
   52|    161|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   53|    161|      }
   54|       |
   55|  5.49k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   56|       |
   57|  5.49k|      throw BER_Decoding_Error(msg.str());
   58|  5.49k|   }
   59|  96.8k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   61|   224k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   62|   224k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (62:12): [True: 115k, False: 109k]
  |  Branch (62:47): [True: 112k, False: 3.36k]
  ------------------
   63|   224k|}
_ZNK5Botan10BER_Object4is_aEiNS_10ASN1_ClassE:
   65|   102k|bool BER_Object::is_a(int expected_type_tag, ASN1_Class expected_class_tag) const {
   66|   102k|   return is_a(ASN1_Type(expected_type_tag), expected_class_tag);
   67|   102k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   69|   198k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   70|   198k|   m_type_tag = type_tag;
   71|   198k|   m_class_tag = class_tag;
   72|   198k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   74|  10.3k|std::string asn1_class_to_string(ASN1_Class type) {
   75|  10.3k|   switch(type) {
   76|  3.29k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (76:7): [True: 3.29k, False: 7.06k]
  ------------------
   77|  3.29k|         return "UNIVERSAL";
   78|  5.97k|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (78:7): [True: 5.97k, False: 4.39k]
  ------------------
   79|  5.97k|         return "CONSTRUCTED";
   80|    354|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (80:7): [True: 354, False: 10.0k]
  ------------------
   81|    354|         return "CONTEXT_SPECIFIC";
   82|    169|      case ASN1_Class::Application:
  ------------------
  |  Branch (82:7): [True: 169, False: 10.1k]
  ------------------
   83|    169|         return "APPLICATION";
   84|    182|      case ASN1_Class::Private:
  ------------------
  |  Branch (84:7): [True: 182, False: 10.1k]
  ------------------
   85|    182|         return "PRIVATE";
   86|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (86:7): [True: 0, False: 10.3k]
  ------------------
   87|      0|         return "NO_OBJECT";
   88|    390|      default:
  ------------------
  |  Branch (88:7): [True: 390, False: 9.97k]
  ------------------
   89|    390|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   90|  10.3k|   }
   91|  10.3k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   93|  9.27k|std::string asn1_tag_to_string(ASN1_Type type) {
   94|  9.27k|   switch(type) {
   95|  3.78k|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (95:7): [True: 3.78k, False: 5.48k]
  ------------------
   96|  3.78k|         return "SEQUENCE";
   97|       |
   98|    289|      case ASN1_Type::Set:
  ------------------
  |  Branch (98:7): [True: 289, False: 8.98k]
  ------------------
   99|    289|         return "SET";
  100|       |
  101|    201|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (101:7): [True: 201, False: 9.07k]
  ------------------
  102|    201|         return "PRINTABLE STRING";
  103|       |
  104|    227|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (104:7): [True: 227, False: 9.04k]
  ------------------
  105|    227|         return "NUMERIC STRING";
  106|       |
  107|    179|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (107:7): [True: 179, False: 9.09k]
  ------------------
  108|    179|         return "IA5 STRING";
  109|       |
  110|    193|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (110:7): [True: 193, False: 9.07k]
  ------------------
  111|    193|         return "T61 STRING";
  112|       |
  113|    108|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (113:7): [True: 108, False: 9.16k]
  ------------------
  114|    108|         return "UTF8 STRING";
  115|       |
  116|    200|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (116:7): [True: 200, False: 9.07k]
  ------------------
  117|    200|         return "VISIBLE STRING";
  118|       |
  119|    185|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (119:7): [True: 185, False: 9.08k]
  ------------------
  120|    185|         return "BMP STRING";
  121|       |
  122|     90|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (122:7): [True: 90, False: 9.18k]
  ------------------
  123|     90|         return "UNIVERSAL STRING";
  124|       |
  125|    158|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (125:7): [True: 158, False: 9.11k]
  ------------------
  126|    158|         return "UTC TIME";
  127|       |
  128|    151|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (128:7): [True: 151, False: 9.12k]
  ------------------
  129|    151|         return "GENERALIZED TIME";
  130|       |
  131|    331|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (131:7): [True: 331, False: 8.94k]
  ------------------
  132|    331|         return "OCTET STRING";
  133|       |
  134|    448|      case ASN1_Type::BitString:
  ------------------
  |  Branch (134:7): [True: 448, False: 8.82k]
  ------------------
  135|    448|         return "BIT STRING";
  136|       |
  137|    723|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (137:7): [True: 723, False: 8.54k]
  ------------------
  138|    723|         return "ENUMERATED";
  139|       |
  140|    512|      case ASN1_Type::Integer:
  ------------------
  |  Branch (140:7): [True: 512, False: 8.76k]
  ------------------
  141|    512|         return "INTEGER";
  142|       |
  143|    171|      case ASN1_Type::Null:
  ------------------
  |  Branch (143:7): [True: 171, False: 9.10k]
  ------------------
  144|    171|         return "NULL";
  145|       |
  146|    180|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (146:7): [True: 180, False: 9.09k]
  ------------------
  147|    180|         return "OBJECT";
  148|       |
  149|    210|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (149:7): [True: 210, False: 9.06k]
  ------------------
  150|    210|         return "BOOLEAN";
  151|       |
  152|     48|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (152:7): [True: 48, False: 9.22k]
  ------------------
  153|     48|         return "NO_OBJECT";
  154|       |
  155|    880|      default:
  ------------------
  |  Branch (155:7): [True: 880, False: 8.39k]
  ------------------
  156|    880|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  157|  9.27k|   }
  158|  9.27k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  163|  10.5k|BER_Decoding_Error::BER_Decoding_Error(std::string_view str) : Decoding_Error(fmt("BER: {}", str)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  165|    348|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  185|  19.0k|std::string to_string(const BER_Object& obj) {
  186|  19.0k|   return std::string(cast_uint8_ptr_to_char(obj.bits()), obj.length());
  187|  19.0k|}
_ZN5Botan4ASN19maybe_BERERNS_10DataSourceE:
  192|  4.00k|bool maybe_BER(DataSource& source) {
  193|  4.00k|   uint8_t first_u8;
  194|  4.00k|   if(!source.peek_byte(first_u8)) {
  ------------------
  |  Branch (194:7): [True: 0, False: 4.00k]
  ------------------
  195|      0|      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
  ------------------
  |  |   69|      0|   do {                                                                                                \
  |  |   70|      0|      if((expr1) != (expr2))                                                                           \
  |  |  ------------------
  |  |  |  Branch (70:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   72|      0|   } while(0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  196|      0|      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
  197|      0|   }
  198|       |
  199|  4.00k|   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
  200|  4.00k|   if(first_u8 == cons_seq) {
  ------------------
  |  Branch (200:7): [True: 3.63k, False: 368]
  ------------------
  201|  3.63k|      return true;
  202|  3.63k|   }
  203|    368|   return false;
  204|  4.00k|}

_ZN5Botan3OID11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   74|  1.26k|OID OID::from_string(std::string_view str) {
   75|  1.26k|   if(str.empty()) {
  ------------------
  |  Branch (75:7): [True: 0, False: 1.26k]
  ------------------
   76|      0|      throw Invalid_Argument("OID::from_string argument must be non-empty");
   77|      0|   }
   78|       |
   79|  1.26k|   OID o = OID_Map::global_registry().str2oid(str);
   80|  1.26k|   if(o.has_value()) {
  ------------------
  |  Branch (80:7): [True: 1.26k, False: 0]
  ------------------
   81|  1.26k|      return o;
   82|  1.26k|   }
   83|       |
   84|      0|   std::vector<uint32_t> raw = parse_oid_str(str);
   85|       |
   86|      0|   if(!raw.empty()) {
  ------------------
  |  Branch (86:7): [True: 0, False: 0]
  ------------------
   87|      0|      return OID(std::move(raw));
   88|      0|   }
   89|       |
   90|      0|   throw Lookup_Error(fmt("No OID associated with name '{}'", str));
   91|      0|}
_ZN5Botan3OIDC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   96|   160k|OID::OID(std::string_view oid_str) {
   97|   160k|   if(!oid_str.empty()) {
  ------------------
  |  Branch (97:7): [True: 160k, False: 0]
  ------------------
   98|   160k|      m_id = parse_oid_str(oid_str);
   99|   160k|      if(m_id.size() < 2 || m_id[0] > 2 || (m_id[0] < 2 && m_id[1] > 39)) {
  ------------------
  |  Branch (99:10): [True: 0, False: 160k]
  |  Branch (99:29): [True: 0, False: 160k]
  |  Branch (99:45): [True: 4.46k, False: 156k]
  |  Branch (99:60): [True: 0, False: 4.46k]
  ------------------
  100|      0|         throw Decoding_Error(fmt("Invalid OID '{}'", oid_str));
  101|      0|      }
  102|   160k|   }
  103|   160k|}
_ZNK5Botan3OID9to_stringEv:
  108|  21.2k|std::string OID::to_string() const {
  109|  21.2k|   std::ostringstream out;
  110|  21.2k|   out << (*this);
  111|  21.2k|   return out.str();
  112|  21.2k|}
_ZNK5Botan3OID19to_formatted_stringEv:
  114|  2.59k|std::string OID::to_formatted_string() const {
  115|  2.59k|   std::string s = this->human_name_or_empty();
  116|  2.59k|   if(!s.empty()) {
  ------------------
  |  Branch (116:7): [True: 522, False: 2.07k]
  ------------------
  117|    522|      return s;
  118|    522|   }
  119|  2.07k|   return this->to_string();
  120|  2.59k|}
_ZNK5Botan3OID19human_name_or_emptyEv:
  122|  2.59k|std::string OID::human_name_or_empty() const {
  123|  2.59k|   return OID_Map::global_registry().oid2str(*this);
  124|  2.59k|}
_ZN5BotanltERKNS_3OIDES2_:
  133|  60.6k|bool operator<(const OID& a, const OID& b) {
  134|  60.6k|   const std::vector<uint32_t>& oid1 = a.get_components();
  135|  60.6k|   const std::vector<uint32_t>& oid2 = b.get_components();
  136|       |
  137|  60.6k|   return std::lexicographical_compare(oid1.begin(), oid1.end(), oid2.begin(), oid2.end());
  138|  60.6k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_3OIDE:
  140|  21.2k|std::ostream& operator<<(std::ostream& out, const OID& oid) {
  141|  21.2k|   const auto& val = oid.get_components();
  142|       |
  143|   120k|   for(size_t i = 0; i != val.size(); ++i) {
  ------------------
  |  Branch (143:22): [True: 99.7k, False: 21.2k]
  ------------------
  144|       |      // avoid locale issues with integer formatting
  145|  99.7k|      out << std::to_string(val[i]);
  146|  99.7k|      if(i != val.size() - 1) {
  ------------------
  |  Branch (146:10): [True: 78.5k, False: 21.2k]
  ------------------
  147|  78.5k|         out << ".";
  148|  78.5k|      }
  149|  99.7k|   }
  150|       |
  151|  21.2k|   return out;
  152|  21.2k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  191|  30.7k|void OID::decode_from(BER_Decoder& decoder) {
  192|  30.7k|   BER_Object obj = decoder.get_next_object();
  193|  30.7k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (193:7): [True: 348, False: 30.3k]
  ------------------
  194|    348|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  195|    348|   }
  196|       |
  197|  30.3k|   const size_t length = obj.length();
  198|  30.3k|   const uint8_t* bits = obj.bits();
  199|       |
  200|  30.3k|   if(length < 2 && !(length == 1 && bits[0] == 0)) {
  ------------------
  |  Branch (200:7): [True: 2.68k, False: 27.6k]
  |  Branch (200:23): [True: 2.63k, False: 53]
  |  Branch (200:38): [True: 2.53k, False: 92]
  ------------------
  201|    145|      throw BER_Decoding_Error("OID encoding is too short");
  202|    145|   }
  203|       |
  204|  30.2k|   m_id.clear();
  205|  30.2k|   m_id.push_back(bits[0] / 40);
  206|  30.2k|   m_id.push_back(bits[0] % 40);
  207|       |
  208|  30.2k|   size_t i = 0;
  209|   145k|   while(i != length - 1) {
  ------------------
  |  Branch (209:10): [True: 115k, False: 30.1k]
  ------------------
  210|   115k|      uint32_t component = 0;
  211|   142k|      while(i != length - 1) {
  ------------------
  |  Branch (211:13): [True: 131k, False: 11.5k]
  ------------------
  212|   131k|         ++i;
  213|       |
  214|   131k|         if(component >> (32 - 7)) {
  ------------------
  |  Branch (214:13): [True: 72, False: 131k]
  ------------------
  215|     72|            throw Decoding_Error("OID component overflow");
  216|     72|         }
  217|       |
  218|   131k|         component = (component << 7) + (bits[i] & 0x7F);
  219|       |
  220|   131k|         if(!(bits[i] & 0x80)) {
  ------------------
  |  Branch (220:13): [True: 103k, False: 27.8k]
  ------------------
  221|   103k|            break;
  222|   103k|         }
  223|   131k|      }
  224|   115k|      m_id.push_back(component);
  225|   115k|   }
  226|  30.2k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_113parse_oid_strENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   24|   160k|std::vector<uint32_t> parse_oid_str(std::string_view oid) {
   25|   160k|   try {
   26|   160k|      std::string elem;
   27|   160k|      std::vector<uint32_t> oid_elems;
   28|       |
   29|  1.48M|      for(char c : oid) {
  ------------------
  |  Branch (29:18): [True: 1.48M, False: 160k]
  ------------------
   30|  1.48M|         if(c == '.') {
  ------------------
  |  Branch (30:13): [True: 504k, False: 977k]
  ------------------
   31|   504k|            if(elem.empty()) {
  ------------------
  |  Branch (31:16): [True: 0, False: 504k]
  ------------------
   32|      0|               return std::vector<uint32_t>();
   33|      0|            }
   34|   504k|            oid_elems.push_back(to_u32bit(elem));
   35|   504k|            elem.clear();
   36|   977k|         } else {
   37|   977k|            elem += c;
   38|   977k|         }
   39|  1.48M|      }
   40|       |
   41|   160k|      if(!elem.empty()) {
  ------------------
  |  Branch (41:10): [True: 160k, False: 0]
  ------------------
   42|   160k|         oid_elems.push_back(to_u32bit(elem));
   43|   160k|      }
   44|       |
   45|   160k|      return oid_elems;
   46|   160k|   } catch(Invalid_Argument&)  // thrown by to_u32bit
   47|   160k|   {
   48|      0|      return std::vector<uint32_t>();
   49|      0|   }
   50|   160k|}

_ZN5Botan11ASN1_String14is_string_typeENS_9ASN1_TypeE:
   60|  2.08k|bool ASN1_String::is_string_type(ASN1_Type tag) {
   61|  2.08k|   return is_asn1_string_type(tag);
   62|  2.08k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
   64|  5.70k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
   65|  5.70k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (65:7): [True: 8, False: 5.70k]
  ------------------
   66|      8|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
   67|      8|   }
   68|  5.70k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   70|  4.09k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
   88|  4.01k|void ASN1_String::decode_from(BER_Decoder& source) {
   89|  4.01k|   BER_Object obj = source.get_next_object();
   90|       |
   91|  4.01k|   if(!is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (91:7): [True: 99, False: 3.91k]
  ------------------
   92|     99|      auto typ = static_cast<uint32_t>(obj.type());
   93|     99|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}", typ));
   94|     99|   }
   95|       |
   96|  3.91k|   m_tag = obj.type();
   97|  3.91k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
   98|       |
   99|  3.91k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (99:7): [True: 762, False: 3.15k]
  ------------------
  100|    762|      m_utf8_str = ucs2_to_utf8(m_data.data(), m_data.size());
  101|  3.15k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (101:14): [True: 263, False: 2.89k]
  ------------------
  102|    263|      m_utf8_str = ucs4_to_utf8(m_data.data(), m_data.size());
  103|  2.89k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (103:14): [True: 720, False: 2.17k]
  ------------------
  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|    720|      m_utf8_str = latin1_to_utf8(m_data.data(), m_data.size());
  109|  2.17k|   } else {
  110|       |      // All other supported string types are UTF-8 or some subset thereof
  111|  2.17k|      m_utf8_str = ASN1::to_string(obj);
  112|  2.17k|   }
  113|  3.91k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   52|  6.09k|bool is_asn1_string_type(ASN1_Type tag) {
   53|  6.09k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (53:12): [True: 3.81k, False: 2.27k]
  |  Branch (53:47): [True: 854, False: 1.42k]
  |  Branch (53:82): [True: 806, False: 616]
  ------------------
   54|  6.09k|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (54:12): [True: 265, False: 351]
  ------------------
   55|  6.09k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   47|  11.8k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   48|  11.8k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (48:12): [True: 721, False: 11.0k]
  |  Branch (48:47): [True: 5.11k, False: 5.96k]
  |  Branch (48:84): [True: 1.13k, False: 4.83k]
  ------------------
   49|  11.8k|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (49:12): [True: 1.26k, False: 3.57k]
  |  Branch (49:43): [True: 1.28k, False: 2.28k]
  ------------------
   50|  11.8k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   23|  4.09k|ASN1_Type choose_encoding(std::string_view str) {
   24|  4.09k|   auto all_printable = CT::Mask<uint8_t>::set();
   25|       |
   26|  4.09k|   for(size_t i = 0; i != str.size(); ++i) {
  ------------------
  |  Branch (26:22): [True: 0, False: 4.09k]
  ------------------
   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.09k|   if(all_printable.as_bool()) {
  ------------------
  |  Branch (40:7): [True: 4.09k, False: 0]
  ------------------
   41|  4.09k|      return ASN1_Type::PrintableString;
   42|  4.09k|   } else {
   43|      0|      return ASN1_Type::Utf8String;
   44|      0|   }
   45|  4.09k|}

_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   53|  8.05k|void ASN1_Time::decode_from(BER_Decoder& source) {
   54|  8.05k|   BER_Object ber_time = source.get_next_object();
   55|       |
   56|  8.05k|   set_to(ASN1::to_string(ber_time), ber_time.type());
   57|  8.05k|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  157|  8.03k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  158|  8.03k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   30|  8.03k|   do {                                                          \
  |  |   31|  8.78k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 7.27k, False: 755]
  |  |  |  Branch (31:12): [True: 604, False: 151]
  |  |  ------------------
  |  |   32|  8.03k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  8.03k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  159|  8.03k|                   "Invalid tag for ASN1_Time");
  160|       |
  161|  8.03k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (161:7): [True: 604, False: 7.42k]
  ------------------
  162|    604|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   30|    604|   do {                                                          \
  |  |   31|    604|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 15, False: 589]
  |  |  ------------------
  |  |   32|    604|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    604|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  7.42k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (163:14): [True: 7.27k, False: 151]
  ------------------
  164|  7.27k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   30|  7.27k|   do {                                                          \
  |  |   31|  7.27k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 31, False: 7.24k]
  |  |  ------------------
  |  |   32|  7.27k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  7.27k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  7.27k|   }
  166|       |
  167|  8.03k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   30|  8.03k|   do {                                                          \
  |  |   31|  8.03k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 15, False: 8.01k]
  |  |  ------------------
  |  |   32|  8.03k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  8.03k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  168|       |
  169|  8.03k|   const size_t field_len = 2;
  170|       |
  171|  8.03k|   const size_t year_start = 0;
  172|  8.03k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (172:28): [True: 7.23k, False: 800]
  ------------------
  173|  8.03k|   const size_t month_start = year_start + year_len;
  174|  8.03k|   const size_t day_start = month_start + field_len;
  175|  8.03k|   const size_t hour_start = day_start + field_len;
  176|  8.03k|   const size_t min_start = hour_start + field_len;
  177|  8.03k|   const size_t sec_start = min_start + field_len;
  178|       |
  179|  8.03k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  180|  8.03k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  181|  8.03k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  182|  8.03k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  183|  8.03k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  184|  8.03k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  185|  8.03k|   m_tag = spec_tag;
  186|       |
  187|  8.03k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (187:7): [True: 7.21k, False: 818]
  ------------------
  188|  7.21k|      if(m_year >= 50) {
  ------------------
  |  Branch (188:10): [True: 1.75k, False: 5.46k]
  ------------------
  189|  1.75k|         m_year += 1900;
  190|  5.46k|      } else {
  191|  5.46k|         m_year += 2000;
  192|  5.46k|      }
  193|  7.21k|   }
  194|       |
  195|  8.03k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (195:7): [True: 65, False: 7.96k]
  ------------------
  196|     65|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  197|     65|   }
  198|  8.03k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  203|  7.79k|bool ASN1_Time::passes_sanity_check() const {
  204|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  205|  7.79k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (205:7): [True: 10, False: 7.78k]
  |  Branch (205:24): [True: 6, False: 7.77k]
  ------------------
  206|     16|      return false;
  207|     16|   }
  208|  7.77k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (208:7): [True: 3, False: 7.77k]
  |  Branch (208:23): [True: 12, False: 7.76k]
  ------------------
  209|     15|      return false;
  210|     15|   }
  211|       |
  212|  7.76k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  213|       |
  214|  7.76k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (214:7): [True: 1, False: 7.76k]
  |  Branch (214:21): [True: 13, False: 7.75k]
  ------------------
  215|     14|      return false;
  216|     14|   }
  217|       |
  218|  7.75k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (218:7): [True: 1.93k, False: 5.81k]
  |  Branch (218:23): [True: 433, False: 1.50k]
  ------------------
  219|    433|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (219:10): [True: 3, False: 430]
  ------------------
  220|      3|         return false;  // not a leap year
  221|      3|      }
  222|       |
  223|    430|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (223:10): [True: 144, False: 286]
  |  Branch (223:31): [True: 2, False: 142]
  ------------------
  224|      2|         return false;
  225|      2|      }
  226|    430|   }
  227|       |
  228|  7.74k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (228:7): [True: 7, False: 7.73k]
  |  Branch (228:23): [True: 4, False: 7.73k]
  |  Branch (228:41): [True: 3, False: 7.73k]
  ------------------
  229|     14|      return false;
  230|     14|   }
  231|       |
  232|  7.73k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (232:7): [True: 7.17k, False: 556]
  ------------------
  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|  7.17k|      if(m_second > 59) {
  ------------------
  |  Branch (240:10): [True: 1, False: 7.17k]
  ------------------
  241|      1|         return false;
  242|      1|      }
  243|  7.17k|   }
  244|       |
  245|  7.73k|   return true;
  246|  7.73k|}

_ZNK5Botan11BER_Decoder10more_itemsEv:
  195|  75.5k|bool BER_Decoder::more_items() const {
  196|  75.5k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (196:7): [True: 14.5k, False: 60.9k]
  |  Branch (196:34): [True: 14.5k, False: 0]
  ------------------
  197|  14.5k|      return false;
  198|  14.5k|   }
  199|  60.9k|   return true;
  200|  75.5k|}
_ZN5Botan11BER_Decoder10verify_endEv:
  205|  10.0k|BER_Decoder& BER_Decoder::verify_end() {
  206|  10.0k|   return verify_end("BER_Decoder::verify_end called, but data remains");
  207|  10.0k|}
_ZN5Botan11BER_Decoder10verify_endENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  212|  10.0k|BER_Decoder& BER_Decoder::verify_end(std::string_view err) {
  213|  10.0k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (213:7): [True: 171, False: 9.91k]
  |  Branch (213:35): [True: 0, False: 9.91k]
  ------------------
  214|    171|      throw Decoding_Error(err);
  215|    171|   }
  216|  9.91k|   return (*this);
  217|  10.0k|}
_ZN5Botan11BER_Decoder17discard_remainingEv:
  222|    438|BER_Decoder& BER_Decoder::discard_remaining() {
  223|    438|   uint8_t buf;
  224|  2.32k|   while(m_source->read_byte(buf)) {}
  ------------------
  |  Branch (224:10): [True: 1.88k, False: 438]
  ------------------
  225|    438|   return (*this);
  226|    438|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  231|   196k|BER_Object BER_Decoder::get_next_object() {
  232|   196k|   BER_Object next;
  233|       |
  234|   196k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (234:7): [True: 23.0k, False: 173k]
  ------------------
  235|  23.0k|      std::swap(next, m_pushed);
  236|  23.0k|      return next;
  237|  23.0k|   }
  238|       |
  239|   197k|   for(;;) {
  240|   197k|      ASN1_Type type_tag;
  241|   197k|      ASN1_Class class_tag;
  242|   197k|      decode_tag(m_source, type_tag, class_tag);
  243|   197k|      next.set_tagging(type_tag, class_tag);
  244|   197k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (244:10): [True: 4.12k, False: 193k]
  ------------------
  245|  4.12k|         return next;
  246|  4.12k|      }
  247|       |
  248|   193k|      size_t field_size;
  249|   193k|      const size_t length = decode_length(m_source, field_size, ALLOWED_EOC_NESTINGS);
  250|   193k|      if(!m_source->check_available(length)) {
  ------------------
  |  Branch (250:10): [True: 1.87k, False: 191k]
  ------------------
  251|  1.87k|         throw BER_Decoding_Error("Value truncated");
  252|  1.87k|      }
  253|       |
  254|   191k|      uint8_t* out = next.mutable_bits(length);
  255|   191k|      if(m_source->read(out, length) != length) {
  ------------------
  |  Branch (255:10): [True: 0, False: 191k]
  ------------------
  256|      0|         throw BER_Decoding_Error("Value truncated");
  257|      0|      }
  258|       |
  259|   191k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (259:10): [True: 23.3k, False: 167k]
  ------------------
  260|  23.3k|         continue;
  261|   167k|      } else {
  262|   167k|         break;
  263|   167k|      }
  264|   191k|   }
  265|       |
  266|   167k|   return next;
  267|   173k|}
_ZN5Botan11BER_Decoder9push_backERKNS_10BER_ObjectE:
  272|  2.29k|void BER_Decoder::push_back(const BER_Object& obj) {
  273|  2.29k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (273:7): [True: 0, False: 2.29k]
  ------------------
  274|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  275|      0|   }
  276|  2.29k|   m_pushed = obj;
  277|  2.29k|}
_ZN5Botan11BER_Decoder9push_backEONS_10BER_ObjectE:
  279|  23.8k|void BER_Decoder::push_back(BER_Object&& obj) {
  280|  23.8k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (280:7): [True: 0, False: 23.8k]
  ------------------
  281|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  282|      0|   }
  283|  23.8k|   m_pushed = std::move(obj);
  284|  23.8k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  286|  70.2k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  287|  70.2k|   BER_Object obj = get_next_object();
  288|  70.2k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  289|  70.2k|   return BER_Decoder(std::move(obj), this);
  290|  70.2k|}
_ZN5Botan11BER_Decoder8end_consEv:
  295|  46.5k|BER_Decoder& BER_Decoder::end_cons() {
  296|  46.5k|   if(!m_parent) {
  ------------------
  |  Branch (296:7): [True: 0, False: 46.5k]
  ------------------
  297|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  298|      0|   }
  299|  46.5k|   if(!m_source->end_of_data()) {
  ------------------
  |  Branch (299:7): [True: 439, False: 46.0k]
  ------------------
  300|    439|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  301|    439|   }
  302|  46.0k|   return (*m_parent);
  303|  46.5k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  305|  66.2k|BER_Decoder::BER_Decoder(BER_Object&& obj, BER_Decoder* parent) {
  306|  66.2k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  307|  66.2k|   m_source = m_data_src.get();
  308|  66.2k|   m_parent = parent;
  309|  66.2k|}
_ZN5Botan11BER_DecoderC2ERNS_10DataSourceE:
  314|  3.63k|BER_Decoder::BER_Decoder(DataSource& src) {
  315|  3.63k|   m_source = &src;
  316|  3.63k|}
_ZN5Botan11BER_DecoderC2EPKhm:
  321|  6.74k|BER_Decoder::BER_Decoder(const uint8_t data[], size_t length) {
  322|  6.74k|   m_data_src = std::make_unique<DataSource_Memory>(data, length);
  323|  6.74k|   m_source = m_data_src.get();
  324|  6.74k|}
_ZN5Botan11BER_DecoderC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  337|  19.1k|BER_Decoder::BER_Decoder(const std::vector<uint8_t>& data) {
  338|  19.1k|   m_data_src = std::make_unique<DataSource_Memory>(data.data(), data.size());
  339|  19.1k|   m_source = m_data_src.get();
  340|  19.1k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  356|  70.4k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  357|  70.4k|   obj.decode_from(*this);
  358|  70.4k|   return (*this);
  359|  70.4k|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  383|    294|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  384|    294|   BER_Object obj = get_next_object();
  385|    294|   obj.assert_is_a(type_tag, class_tag);
  386|       |
  387|    294|   if(obj.length() != 1) {
  ------------------
  |  Branch (387:7): [True: 79, False: 215]
  ------------------
  388|     79|      throw BER_Decoding_Error("BER boolean value had invalid size");
  389|     79|   }
  390|       |
  391|    215|   out = (obj.bits()[0]) ? true : false;
  ------------------
  |  Branch (391:10): [True: 210, False: 5]
  ------------------
  392|    215|   return (*this);
  393|    294|}
_ZN5Botan11BER_Decoder6decodeERmNS_9ASN1_TypeENS_10ASN1_ClassE:
  398|  3.41k|BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  399|  3.41k|   BigInt integer;
  400|  3.41k|   decode(integer, type_tag, class_tag);
  401|       |
  402|  3.41k|   if(integer.is_negative()) {
  ------------------
  |  Branch (402:7): [True: 329, False: 3.08k]
  ------------------
  403|    329|      throw BER_Decoding_Error("Decoded small integer value was negative");
  404|    329|   }
  405|       |
  406|  3.08k|   if(integer.bits() > 32) {
  ------------------
  |  Branch (406:7): [True: 237, False: 2.84k]
  ------------------
  407|    237|      throw BER_Decoding_Error("Decoded integer value larger than expected");
  408|    237|   }
  409|       |
  410|  2.84k|   out = 0;
  411|  8.68k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (411:22): [True: 5.83k, False: 2.84k]
  ------------------
  412|  5.83k|      out = (out << 8) | integer.byte_at(3 - i);
  413|  5.83k|   }
  414|       |
  415|  2.84k|   return (*this);
  416|  3.08k|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  444|  7.81k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  445|  7.81k|   BER_Object obj = get_next_object();
  446|  7.81k|   obj.assert_is_a(type_tag, class_tag);
  447|       |
  448|  7.81k|   if(obj.length() == 0) {
  ------------------
  |  Branch (448:7): [True: 570, False: 7.24k]
  ------------------
  449|    570|      out.clear();
  450|  7.24k|   } else {
  451|  7.24k|      const bool negative = (obj.bits()[0] & 0x80) ? true : false;
  ------------------
  |  Branch (451:29): [True: 1.26k, False: 5.98k]
  ------------------
  452|       |
  453|  7.24k|      if(negative) {
  ------------------
  |  Branch (453:10): [True: 1.26k, False: 5.98k]
  ------------------
  454|  1.26k|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  455|  1.84k|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (455:39): [True: 1.84k, False: 0]
  ------------------
  456|  1.84k|            if(vec[i - 1]--) {
  ------------------
  |  Branch (456:16): [True: 1.26k, False: 585]
  ------------------
  457|  1.26k|               break;
  458|  1.26k|            }
  459|  1.84k|         }
  460|  69.9k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (460:28): [True: 68.6k, False: 1.26k]
  ------------------
  461|  68.6k|            vec[i] = ~vec[i];
  462|  68.6k|         }
  463|  1.26k|         out = BigInt(vec.data(), vec.size());
  464|  1.26k|         out.flip_sign();
  465|  5.98k|      } else {
  466|  5.98k|         out = BigInt(obj.bits(), obj.length());
  467|  5.98k|      }
  468|  7.24k|   }
  469|       |
  470|  7.81k|   return (*this);
  471|  7.81k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  521|  19.9k|                                 ASN1_Class class_tag) {
  522|  19.9k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (522:7): [True: 2.90k, False: 17.0k]
  |  Branch (522:46): [True: 0, False: 2.90k]
  ------------------
  523|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  524|      0|   }
  525|       |
  526|  19.9k|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag);
  527|  19.9k|   return (*this);
  528|  19.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|   277k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|   277k|   uint8_t b;
   31|   277k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (31:7): [True: 19.3k, False: 258k]
  ------------------
   32|  19.3k|      type_tag = ASN1_Type::NoObject;
   33|  19.3k|      class_tag = ASN1_Class::NoObject;
   34|  19.3k|      return 0;
   35|  19.3k|   }
   36|       |
   37|   258k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (37:7): [True: 254k, False: 4.04k]
  ------------------
   38|   254k|      type_tag = ASN1_Type(b & 0x1F);
   39|   254k|      class_tag = ASN1_Class(b & 0xE0);
   40|   254k|      return 1;
   41|   254k|   }
   42|       |
   43|  4.04k|   size_t tag_bytes = 1;
   44|  4.04k|   class_tag = ASN1_Class(b & 0xE0);
   45|       |
   46|  4.04k|   size_t tag_buf = 0;
   47|  9.97k|   while(true) {
  ------------------
  |  Branch (47:10): [Folded - Ignored]
  ------------------
   48|  9.97k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (48:10): [True: 161, False: 9.81k]
  ------------------
   49|    161|         throw BER_Decoding_Error("Long-form tag truncated");
   50|    161|      }
   51|  9.81k|      if(tag_buf & 0xFF000000) {
  ------------------
  |  Branch (51:10): [True: 104, False: 9.71k]
  ------------------
   52|    104|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|    104|      }
   54|  9.71k|      ++tag_bytes;
   55|  9.71k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
   56|  9.71k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (56:10): [True: 3.77k, False: 5.93k]
  ------------------
   57|  3.77k|         break;
   58|  3.77k|      }
   59|  9.71k|   }
   60|  3.77k|   type_tag = ASN1_Type(tag_buf);
   61|  3.77k|   return tag_bytes;
   62|  4.04k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceERmm:
   72|   257k|size_t decode_length(DataSource* ber, size_t& field_size, size_t allow_indef) {
   73|   257k|   uint8_t b;
   74|   257k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (74:7): [True: 555, False: 257k]
  ------------------
   75|    555|      throw BER_Decoding_Error("Length field not found");
   76|    555|   }
   77|   257k|   field_size = 1;
   78|   257k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (78:7): [True: 225k, False: 31.8k]
  ------------------
   79|   225k|      return b;
   80|   225k|   }
   81|       |
   82|  31.8k|   field_size += (b & 0x7F);
   83|  31.8k|   if(field_size > 5) {
  ------------------
  |  Branch (83:7): [True: 756, False: 31.1k]
  ------------------
   84|    756|      throw BER_Decoding_Error("Length field is too large");
   85|    756|   }
   86|       |
   87|  31.1k|   if(field_size == 1) {
  ------------------
  |  Branch (87:7): [True: 21.1k, False: 9.91k]
  ------------------
   88|  21.1k|      if(allow_indef == 0) {
  ------------------
  |  Branch (88:10): [True: 30, False: 21.1k]
  ------------------
   89|     30|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
   90|  21.1k|      } else {
   91|  21.1k|         return find_eoc(ber, allow_indef - 1);
   92|  21.1k|      }
   93|  21.1k|   }
   94|       |
   95|  9.91k|   size_t length = 0;
   96|       |
   97|  24.7k|   for(size_t i = 0; i != field_size - 1; ++i) {
  ------------------
  |  Branch (97:22): [True: 15.0k, False: 9.75k]
  ------------------
   98|  15.0k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (98:10): [True: 0, False: 15.0k]
  ------------------
   99|      0|         throw BER_Decoding_Error("Field length overflow");
  100|      0|      }
  101|  15.0k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (101:10): [True: 154, False: 14.8k]
  ------------------
  102|    154|         throw BER_Decoding_Error("Corrupted length field");
  103|    154|      }
  104|  14.8k|      length = (length << 8) | b;
  105|  14.8k|   }
  106|  9.75k|   return length;
  107|  9.91k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEm:
  112|  21.1k|size_t find_eoc(DataSource* ber, size_t allow_indef) {
  113|  21.1k|   secure_vector<uint8_t> buffer(BOTAN_DEFAULT_BUFFER_SIZE), data;
  ------------------
  |  |  388|  21.1k|#define BOTAN_DEFAULT_BUFFER_SIZE 4096
  ------------------
  114|       |
  115|  41.0k|   while(true) {
  ------------------
  |  Branch (115:10): [Folded - Ignored]
  ------------------
  116|  41.0k|      const size_t got = ber->peek(buffer.data(), buffer.size(), data.size());
  117|  41.0k|      if(got == 0) {
  ------------------
  |  Branch (117:10): [True: 21.1k, False: 19.8k]
  ------------------
  118|  21.1k|         break;
  119|  21.1k|      }
  120|       |
  121|  19.8k|      data += std::make_pair(buffer.data(), got);
  122|  19.8k|   }
  123|       |
  124|  21.1k|   DataSource_Memory source(data);
  125|  21.1k|   data.clear();
  126|       |
  127|  21.1k|   size_t length = 0;
  128|  81.3k|   while(true) {
  ------------------
  |  Branch (128:10): [Folded - Ignored]
  ------------------
  129|  80.4k|      ASN1_Type type_tag;
  130|  80.4k|      ASN1_Class class_tag;
  131|  80.4k|      size_t tag_size = decode_tag(&source, type_tag, class_tag);
  132|  80.4k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (132:10): [True: 15.4k, False: 64.9k]
  ------------------
  133|  15.4k|         break;
  134|  15.4k|      }
  135|       |
  136|  64.9k|      size_t length_size = 0;
  137|  64.9k|      size_t item_size = decode_length(&source, length_size, allow_indef);
  138|  64.9k|      source.discard_next(item_size);
  139|       |
  140|  64.9k|      length = BOTAN_CHECKED_ADD(length, item_size);
  ------------------
  |  |   73|  64.9k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  141|  64.9k|      length = BOTAN_CHECKED_ADD(length, tag_size);
  ------------------
  |  |   73|  64.9k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  142|  64.9k|      length = BOTAN_CHECKED_ADD(length, length_size);
  ------------------
  |  |   73|  64.9k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  143|       |
  144|  64.9k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (144:10): [True: 11.0k, False: 53.9k]
  |  Branch (144:40): [True: 4.79k, False: 6.25k]
  ------------------
  145|  4.79k|         break;
  146|  4.79k|      }
  147|  64.9k|   }
  148|  21.1k|   return length;
  149|  21.1k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  183|  66.2k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)), m_offset(0) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  153|  2.01M|      size_t read(uint8_t out[], size_t length) override {
  154|  2.01M|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  2.01M|   do {                                                                     \
  |  |   61|  2.01M|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 2.01M]
  |  |  ------------------
  |  |   62|  2.01M|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  2.01M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  155|  2.01M|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  156|  2.01M|         copy_mem(out, m_obj.bits() + m_offset, got);
  157|  2.01M|         m_offset += got;
  158|  2.01M|         return got;
  159|  2.01M|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  174|   149k|      bool check_available(size_t n) override {
  175|   149k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|   149k|   do {                                                                     \
  |  |   61|   149k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 149k]
  |  |  ------------------
  |  |   62|   149k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|   149k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  176|   149k|         return (n <= (m_obj.length() - m_offset));
  177|   149k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject4peekEPhmm:
  161|  9.35k|      size_t peek(uint8_t out[], size_t length, size_t peek_offset) const override {
  162|  9.35k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  9.35k|   do {                                                                     \
  |  |   61|  9.35k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 9.35k]
  |  |  ------------------
  |  |   62|  9.35k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  9.35k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  9.35k|         const size_t bytes_left = m_obj.length() - m_offset;
  164|       |
  165|  9.35k|         if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (165:13): [True: 4.74k, False: 4.61k]
  ------------------
  166|  4.74k|            return 0;
  167|  4.74k|         }
  168|       |
  169|  4.61k|         const size_t got = std::min(bytes_left - peek_offset, length);
  170|  4.61k|         copy_mem(out, m_obj.bits() + m_offset + peek_offset, got);
  171|  4.61k|         return got;
  172|  9.35k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  179|   116k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  181|   116k|      size_t get_bytes_read() const override { return m_offset; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassE:
  480|  19.9k|                               ASN1_Class class_tag) {
  481|  19.9k|   obj.assert_is_a(type_tag, class_tag);
  482|       |
  483|  19.9k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (483:7): [True: 16.7k, False: 3.15k]
  ------------------
  484|  16.7k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  485|  16.7k|   } else {
  486|  3.15k|      if(obj.length() == 0) {
  ------------------
  |  Branch (486:10): [True: 1, False: 3.15k]
  ------------------
  487|      1|         throw BER_Decoding_Error("Invalid BIT STRING");
  488|      1|      }
  489|  3.15k|      if(obj.bits()[0] >= 8) {
  ------------------
  |  Branch (489:10): [True: 6, False: 3.15k]
  ------------------
  490|      6|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  491|      6|      }
  492|       |
  493|  3.15k|      buffer.resize(obj.length() - 1);
  494|       |
  495|  3.15k|      if(obj.length() > 1) {
  ------------------
  |  Branch (495:10): [True: 310, False: 2.84k]
  ------------------
  496|    310|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  497|    310|      }
  498|  3.15k|   }
  499|  19.9k|}

_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.86k|OID_Map& OID_Map::global_registry() {
   17|  3.86k|   static OID_Map g_map;
   18|  3.86k|   return g_map;
   19|  3.86k|}
_ZN5Botan7OID_Map7oid2strERKNS_3OIDE:
   56|  2.59k|std::string OID_Map::oid2str(const OID& oid) {
   57|  2.59k|   const std::string oid_str = oid.to_string();
   58|       |
   59|  2.59k|   lock_guard_type<mutex_type> lock(m_mutex);
   60|       |
   61|  2.59k|   auto i = m_oid2str.find(oid_str);
   62|  2.59k|   if(i != m_oid2str.end()) {
  ------------------
  |  Branch (62:7): [True: 522, False: 2.07k]
  ------------------
   63|    522|      return i->second;
   64|    522|   }
   65|       |
   66|  2.07k|   return "";
   67|  2.59k|}
_ZN5Botan7OID_Map7str2oidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   69|  1.26k|OID OID_Map::str2oid(std::string_view str) {
   70|  1.26k|   lock_guard_type<mutex_type> lock(m_mutex);
   71|  1.26k|   auto i = m_str2oid.find(std::string(str));
   72|  1.26k|   if(i != m_str2oid.end()) {
  ------------------
  |  Branch (72:7): [True: 1.26k, False: 0]
  ------------------
   73|  1.26k|      return i->second;
   74|  1.26k|   }
   75|       |
   76|      0|   return OID();
   77|  1.26k|}

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

_ZN5Botan13base64_decodeEPKcmb:
  174|    216|secure_vector<uint8_t> base64_decode(const char input[], size_t input_length, bool ignore_ws) {
  175|    216|   return base_decode_to_vec<secure_vector<uint8_t>>(Base64(), input, input_length, ignore_ws);
  176|    216|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6417decode_max_outputEm:
   41|    432|      static inline size_t decode_max_output(size_t input_length) {
   42|    432|         return (round_up(input_length, m_encoding_bytes_out) * m_encoding_bytes_in) / m_encoding_bytes_out;
   43|    432|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6417decoding_bytes_inEv:
   29|    216|      static inline size_t decoding_bytes_in() noexcept { return m_encoding_bytes_out; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6418decoding_bytes_outEv:
   31|    216|      static inline size_t decoding_bytes_out() noexcept { return m_encoding_bytes_in; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEc:
  103|  34.5k|uint8_t Base64::lookup_binary_value(char input) noexcept {
  104|  34.5k|   const uint8_t c = static_cast<uint8_t>(input);
  105|       |
  106|  34.5k|   const auto is_alpha_upper = CT::Mask<uint8_t>::is_within_range(c, uint8_t('A'), uint8_t('Z'));
  107|  34.5k|   const auto is_alpha_lower = CT::Mask<uint8_t>::is_within_range(c, uint8_t('a'), uint8_t('z'));
  108|  34.5k|   const auto is_decimal = CT::Mask<uint8_t>::is_within_range(c, uint8_t('0'), uint8_t('9'));
  109|       |
  110|  34.5k|   const auto is_plus = CT::Mask<uint8_t>::is_equal(c, uint8_t('+'));
  111|  34.5k|   const auto is_slash = CT::Mask<uint8_t>::is_equal(c, uint8_t('/'));
  112|  34.5k|   const auto is_equal = CT::Mask<uint8_t>::is_equal(c, uint8_t('='));
  113|       |
  114|  34.5k|   const auto is_whitespace =
  115|  34.5k|      CT::Mask<uint8_t>::is_any_of(c, {uint8_t(' '), uint8_t('\t'), uint8_t('\n'), uint8_t('\r')});
  116|       |
  117|  34.5k|   const uint8_t c_upper = c - uint8_t('A');
  118|  34.5k|   const uint8_t c_lower = c - uint8_t('a') + 26;
  119|  34.5k|   const uint8_t c_decim = c - uint8_t('0') + 2 * 26;
  120|       |
  121|  34.5k|   uint8_t ret = 0xFF;  // default value
  122|       |
  123|  34.5k|   ret = is_alpha_upper.select(c_upper, ret);
  124|  34.5k|   ret = is_alpha_lower.select(c_lower, ret);
  125|  34.5k|   ret = is_decimal.select(c_decim, ret);
  126|  34.5k|   ret = is_plus.select(62, ret);
  127|  34.5k|   ret = is_slash.select(63, ret);
  128|  34.5k|   ret = is_equal.select(0x81, ret);
  129|  34.5k|   ret = is_whitespace.select(0x80, ret);
  130|       |
  131|  34.5k|   return ret;
  132|  34.5k|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6414check_bad_charEhcb:
  135|  32.3k|bool Base64::check_bad_char(uint8_t bin, char input, bool ignore_ws) {
  136|  32.3k|   if(bin <= 0x3F) {
  ------------------
  |  Branch (136:7): [True: 19.8k, False: 12.5k]
  ------------------
  137|  19.8k|      return true;
  138|  19.8k|   } else if(!(bin == 0x81 || (bin == 0x80 && ignore_ws))) {
  ------------------
  |  Branch (138:16): [True: 250, False: 12.2k]
  |  Branch (138:32): [True: 12.2k, False: 37]
  |  Branch (138:47): [True: 12.2k, False: 0]
  ------------------
  139|     37|      throw Invalid_Argument(fmt("base64_decode: invalid character '{}'", format_char_for_display(input)));
  140|     37|   }
  141|  12.4k|   return false;
  142|  32.3k|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base646decodeEPhPKh:
   51|  4.99k|      static void decode(uint8_t* out_ptr, const uint8_t decode_buf[4]) {
   52|  4.99k|         out_ptr[0] = (decode_buf[0] << 2) | (decode_buf[1] >> 4);
   53|  4.99k|         out_ptr[1] = (decode_buf[1] << 4) | (decode_buf[2] >> 2);
   54|  4.99k|         out_ptr[2] = (decode_buf[2] << 6) | decode_buf[3];
   55|  4.99k|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6415bytes_to_removeEm:
   57|    179|      static inline size_t bytes_to_remove(size_t final_truncate) { return final_truncate; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base644nameEv:
   23|     28|      static inline std::string name() noexcept { return "base64"; }

_ZN5Botan6BigIntC2EPKhm:
   91|  5.83k|BigInt::BigInt(const uint8_t input[], size_t length) {
   92|  5.83k|   binary_decode(input, length);
   93|  5.83k|}
_ZNK5Botan6BigInt7byte_atEm:
  125|  5.83k|uint8_t BigInt::byte_at(size_t n) const {
  126|  5.83k|   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));
  127|  5.83k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  198|  5.80k|size_t BigInt::Data::calc_sig_words() const {
  199|  5.80k|   const size_t sz = m_reg.size();
  200|  5.80k|   size_t sig = sz;
  201|       |
  202|  5.80k|   word sub = 1;
  203|       |
  204|  69.4k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (204:22): [True: 63.6k, False: 5.80k]
  ------------------
  205|  63.6k|      const word w = m_reg[sz - i - 1];
  206|  63.6k|      sub &= ct_is_zero(w);
  207|  63.6k|      sig -= sub;
  208|  63.6k|   }
  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|  5.80k|   CT::unpoison(sig);
  215|       |
  216|  5.80k|   return sig;
  217|  5.80k|}
_ZNK5Botan6BigInt5bytesEv:
  277|  8.65k|size_t BigInt::bytes() const {
  278|  8.65k|   return round_up(bits(), 8) / 8;
  279|  8.65k|}
_ZNK5Botan6BigInt13top_bits_freeEv:
  281|  8.76k|size_t BigInt::top_bits_free() const {
  282|  8.76k|   const size_t words = sig_words();
  283|       |
  284|  8.76k|   const word top_word = word_at(words - 1);
  285|  8.76k|   const size_t bits_used = high_bit(top_word);
  286|  8.76k|   CT::unpoison(bits_used);
  287|  8.76k|   return BOTAN_MP_WORD_BITS - bits_used;
  ------------------
  |  |   50|  8.76k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  288|  8.76k|}
_ZNK5Botan6BigInt4bitsEv:
  290|  10.3k|size_t BigInt::bits() const {
  291|  10.3k|   const size_t words = sig_words();
  292|       |
  293|  10.3k|   if(words == 0) {
  ------------------
  |  Branch (293:7): [True: 1.58k, False: 8.76k]
  ------------------
  294|  1.58k|      return 0;
  295|  1.58k|   }
  296|       |
  297|  8.76k|   const size_t full_words = (words - 1) * BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  8.76k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  298|  8.76k|   const size_t top_bits = BOTAN_MP_WORD_BITS - top_bits_free();
  ------------------
  |  |   50|  8.76k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  299|       |
  300|  8.76k|   return full_words + top_bits;
  301|  10.3k|}
_ZNK5Botan6BigInt13binary_encodeEPh:
  375|  4.32k|void BigInt::binary_encode(uint8_t buf[]) const {
  376|  4.32k|   this->binary_encode(buf, bytes());
  377|  4.32k|}
_ZNK5Botan6BigInt13binary_encodeEPhm:
  382|  4.32k|void BigInt::binary_encode(uint8_t output[], size_t len) const {
  383|  4.32k|   const size_t full_words = len / sizeof(word);
  384|  4.32k|   const size_t extra_bytes = len % sizeof(word);
  385|       |
  386|  8.44k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (386:22): [True: 4.12k, False: 4.32k]
  ------------------
  387|  4.12k|      const word w = word_at(i);
  388|  4.12k|      store_be(w, output + (len - (i + 1) * sizeof(word)));
  389|  4.12k|   }
  390|       |
  391|  4.32k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (391:7): [True: 3.18k, False: 1.13k]
  ------------------
  392|  3.18k|      const word w = word_at(full_words);
  393|       |
  394|  12.8k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (394:25): [True: 9.61k, False: 3.18k]
  ------------------
  395|  9.61k|         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);
  396|  9.61k|      }
  397|  3.18k|   }
  398|  4.32k|}
_ZN5Botan6BigInt13binary_decodeEPKhm:
  403|  5.83k|void BigInt::binary_decode(const uint8_t buf[], size_t length) {
  404|  5.83k|   clear();
  405|       |
  406|  5.83k|   const size_t full_words = length / sizeof(word);
  407|  5.83k|   const size_t extra_bytes = length % sizeof(word);
  408|       |
  409|  5.83k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (409:52): [True: 5.32k, False: 510]
  ------------------
  410|       |
  411|  24.8k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (411:22): [True: 19.0k, False: 5.83k]
  ------------------
  412|  19.0k|      reg[i] = load_be<word>(buf + length - sizeof(word) * (i + 1), 0);
  413|  19.0k|   }
  414|       |
  415|  5.83k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (415:7): [True: 5.32k, False: 510]
  ------------------
  416|  18.6k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (416:25): [True: 13.3k, False: 5.32k]
  ------------------
  417|  13.3k|         reg[full_words] = (reg[full_words] << 8) | buf[i];
  418|  13.3k|      }
  419|  5.32k|   }
  420|       |
  421|  5.83k|   m_data.swap(reg);
  422|  5.83k|}

_ZN5Botan8PEM_Code6decodeERNS_10DataSourceERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   62|    375|secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   63|    375|   const size_t RANDOM_CHAR_LIMIT = 8;
   64|       |
   65|    375|   label.clear();
   66|       |
   67|    375|   const std::string PEM_HEADER1 = "-----BEGIN ";
   68|    375|   const std::string PEM_HEADER2 = "-----";
   69|    375|   size_t position = 0;
   70|       |
   71|  5.89k|   while(position != PEM_HEADER1.length()) {
  ------------------
  |  Branch (71:10): [True: 5.55k, False: 334]
  ------------------
   72|  5.55k|      uint8_t b;
   73|  5.55k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (73:10): [True: 40, False: 5.51k]
  ------------------
   74|     40|         throw Decoding_Error("PEM: No PEM header found");
   75|     40|      }
   76|  5.51k|      if(static_cast<char>(b) == PEM_HEADER1[position]) {
  ------------------
  |  Branch (76:10): [True: 3.92k, False: 1.59k]
  ------------------
   77|  3.92k|         ++position;
   78|  3.92k|      } else if(position >= RANDOM_CHAR_LIMIT) {
  ------------------
  |  Branch (78:17): [True: 1, False: 1.59k]
  ------------------
   79|      1|         throw Decoding_Error("PEM: Malformed PEM header");
   80|  1.59k|      } else {
   81|  1.59k|         position = 0;
   82|  1.59k|      }
   83|  5.51k|   }
   84|    334|   position = 0;
   85|  80.4k|   while(position != PEM_HEADER2.length()) {
  ------------------
  |  Branch (85:10): [True: 80.1k, False: 300]
  ------------------
   86|  80.1k|      uint8_t b;
   87|  80.1k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (87:10): [True: 29, False: 80.0k]
  ------------------
   88|     29|         throw Decoding_Error("PEM: No PEM header found");
   89|     29|      }
   90|  80.0k|      if(static_cast<char>(b) == PEM_HEADER2[position]) {
  ------------------
  |  Branch (90:10): [True: 1.51k, False: 78.5k]
  ------------------
   91|  1.51k|         ++position;
   92|  78.5k|      } else if(position) {
  ------------------
  |  Branch (92:17): [True: 5, False: 78.5k]
  ------------------
   93|      5|         throw Decoding_Error("PEM: Malformed PEM header");
   94|      5|      }
   95|       |
   96|  80.0k|      if(position == 0) {
  ------------------
  |  Branch (96:10): [True: 78.5k, False: 1.51k]
  ------------------
   97|  78.5k|         label += static_cast<char>(b);
   98|  78.5k|      }
   99|  80.0k|   }
  100|       |
  101|    300|   std::vector<char> b64;
  102|       |
  103|    300|   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
  104|    300|   position = 0;
  105|  85.2k|   while(position != PEM_TRAILER.length()) {
  ------------------
  |  Branch (105:10): [True: 85.0k, False: 216]
  ------------------
  106|  85.0k|      uint8_t b;
  107|  85.0k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (107:10): [True: 70, False: 84.9k]
  ------------------
  108|     70|         throw Decoding_Error("PEM: No PEM trailer found");
  109|     70|      }
  110|  84.9k|      if(static_cast<char>(b) == PEM_TRAILER[position]) {
  ------------------
  |  Branch (110:10): [True: 30.3k, False: 54.6k]
  ------------------
  111|  30.3k|         ++position;
  112|  54.6k|      } else if(position) {
  ------------------
  |  Branch (112:17): [True: 14, False: 54.6k]
  ------------------
  113|     14|         throw Decoding_Error("PEM: Malformed PEM trailer");
  114|     14|      }
  115|       |
  116|  84.9k|      if(position == 0) {
  ------------------
  |  Branch (116:10): [True: 54.6k, False: 30.3k]
  ------------------
  117|  54.6k|         b64.push_back(b);
  118|  54.6k|      }
  119|  84.9k|   }
  120|       |
  121|    216|   return base64_decode(b64.data(), b64.size());
  122|    300|}
_ZN5Botan8PEM_Code7matchesERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
  137|  3.63k|bool matches(DataSource& source, std::string_view extra, size_t search_range) {
  138|  3.63k|   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
  139|       |
  140|  3.63k|   secure_vector<uint8_t> search_buf(search_range);
  141|  3.63k|   const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);
  142|       |
  143|  3.63k|   if(got < PEM_HEADER.length()) {
  ------------------
  |  Branch (143:7): [True: 454, False: 3.18k]
  ------------------
  144|    454|      return false;
  145|    454|   }
  146|       |
  147|  3.18k|   size_t index = 0;
  148|       |
  149|  1.66M|   for(size_t j = 0; j != got; ++j) {
  ------------------
  |  Branch (149:22): [True: 1.66M, False: 3.17k]
  ------------------
  150|  1.66M|      if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
  ------------------
  |  Branch (150:10): [True: 4.36k, False: 1.65M]
  ------------------
  151|  4.36k|         ++index;
  152|  1.65M|      } else {
  153|  1.65M|         index = 0;
  154|  1.65M|      }
  155|       |
  156|  1.66M|      if(index == PEM_HEADER.size()) {
  ------------------
  |  Branch (156:10): [True: 7, False: 1.66M]
  ------------------
  157|      7|         return true;
  158|      7|      }
  159|  1.66M|   }
  160|       |
  161|  3.17k|   return false;
  162|  3.18k|}

_ZN5Botan15allocate_memoryEmm:
   20|   259k|BOTAN_MALLOC_FN void* allocate_memory(size_t elems, size_t elem_size) {
   21|   259k|   if(elems == 0 || elem_size == 0) {
  ------------------
  |  Branch (21:7): [True: 0, False: 259k]
  |  Branch (21:21): [True: 0, False: 259k]
  ------------------
   22|      0|      return nullptr;
   23|      0|   }
   24|       |
   25|       |   // Some calloc implementations do not check for overflow (?!?)
   26|       |
   27|   259k|   if(!BOTAN_CHECKED_MUL(elems, elem_size).has_value()) {
  ------------------
  |  |   74|   259k|#define BOTAN_CHECKED_MUL(x, y) checked_mul(x, y)
  ------------------
  |  Branch (27:7): [True: 0, False: 259k]
  ------------------
   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|   259k|   void* ptr = std::calloc(elems, elem_size);  // NOLINT(*-no-malloc)
   41|   259k|#endif
   42|   259k|   if(!ptr) {
  ------------------
  |  Branch (42:7): [True: 0, False: 259k]
  ------------------
   43|      0|      [[unlikely]] throw std::bad_alloc();
   44|      0|   }
   45|   259k|   return ptr;
   46|   259k|}
_ZN5Botan17deallocate_memoryEPvmm:
   48|   259k|void deallocate_memory(void* p, size_t elems, size_t elem_size) {
   49|   259k|   if(p == nullptr) {
  ------------------
  |  Branch (49:7): [True: 0, False: 259k]
  ------------------
   50|      0|      [[unlikely]] return;
   51|      0|   }
   52|       |
   53|   259k|   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|   259k|   std::free(p);  // NOLINT(*-no-malloc)
   62|   259k|}

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

_ZN5Botan12ucs2_to_utf8EPKhm:
   54|    762|std::string ucs2_to_utf8(const uint8_t ucs2[], size_t len) {
   55|    762|   if(len % 2 != 0) {
  ------------------
  |  Branch (55:7): [True: 19, False: 743]
  ------------------
   56|     19|      throw Decoding_Error("Invalid length for UCS-2 string");
   57|     19|   }
   58|       |
   59|    743|   const size_t chars = len / 2;
   60|       |
   61|    743|   std::string s;
   62|  4.81k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (62:22): [True: 4.07k, False: 743]
  ------------------
   63|  4.07k|      const uint32_t c = load_be<uint16_t>(ucs2, i);
   64|  4.07k|      append_utf8_for(s, c);
   65|  4.07k|   }
   66|       |
   67|    743|   return s;
   68|    762|}
_ZN5Botan12ucs4_to_utf8EPKhm:
   70|    263|std::string ucs4_to_utf8(const uint8_t ucs4[], size_t len) {
   71|    263|   if(len % 4 != 0) {
  ------------------
  |  Branch (71:7): [True: 20, False: 243]
  ------------------
   72|     20|      throw Decoding_Error("Invalid length for UCS-4 string");
   73|     20|   }
   74|       |
   75|    243|   const size_t chars = len / 4;
   76|       |
   77|    243|   std::string s;
   78|    728|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (78:22): [True: 485, False: 243]
  ------------------
   79|    485|      const uint32_t c = load_be<uint32_t>(ucs4, i);
   80|    485|      append_utf8_for(s, c);
   81|    485|   }
   82|       |
   83|    243|   return s;
   84|    263|}
_ZN5Botan14latin1_to_utf8EPKhm:
   89|    720|std::string latin1_to_utf8(const uint8_t chars[], size_t len) {
   90|    720|   std::string s;
   91|  8.35k|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (91:22): [True: 7.63k, False: 720]
  ------------------
   92|  7.63k|      const uint32_t c = static_cast<uint8_t>(chars[i]);
   93|  7.63k|      append_utf8_for(s, c);
   94|  7.63k|   }
   95|    720|   return s;
   96|    720|}
_ZN5Botan23format_char_for_displayEc:
   98|     37|std::string format_char_for_display(char c) {
   99|     37|   std::ostringstream oss;
  100|       |
  101|     37|   oss << "'";
  102|       |
  103|     37|   if(c == '\t') {
  ------------------
  |  Branch (103:7): [True: 0, False: 37]
  ------------------
  104|      0|      oss << "\\t";
  105|     37|   } else if(c == '\n') {
  ------------------
  |  Branch (105:14): [True: 0, False: 37]
  ------------------
  106|      0|      oss << "\\n";
  107|     37|   } else if(c == '\r') {
  ------------------
  |  Branch (107:14): [True: 0, False: 37]
  ------------------
  108|      0|      oss << "\\r";
  109|     37|   } else if(static_cast<unsigned char>(c) >= 128) {
  ------------------
  |  Branch (109:14): [True: 18, False: 19]
  ------------------
  110|     18|      unsigned char z = static_cast<unsigned char>(c);
  111|     18|      oss << "\\x" << std::hex << std::uppercase << static_cast<int>(z);
  112|     19|   } else {
  113|     19|      oss << c;
  114|     19|   }
  115|       |
  116|     37|   oss << "'";
  117|       |
  118|     37|   return oss.str();
  119|     37|}
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   18|  12.1k|void append_utf8_for(std::string& s, uint32_t c) {
   19|  12.1k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (19:7): [True: 1.17k, False: 11.0k]
  |  Branch (19:22): [True: 48, False: 1.12k]
  ------------------
   20|     48|      throw Decoding_Error("Invalid Unicode character");
   21|     48|   }
   22|       |
   23|  12.1k|   if(c <= 0x7F) {
  ------------------
  |  Branch (23:7): [True: 5.41k, False: 6.71k]
  ------------------
   24|  5.41k|      const uint8_t b0 = static_cast<uint8_t>(c);
   25|  5.41k|      s.push_back(static_cast<char>(b0));
   26|  6.71k|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (26:14): [True: 3.35k, False: 3.36k]
  ------------------
   27|  3.35k|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   28|  3.35k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   29|  3.35k|      s.push_back(static_cast<char>(b0));
   30|  3.35k|      s.push_back(static_cast<char>(b1));
   31|  3.36k|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (31:14): [True: 3.02k, False: 333]
  ------------------
   32|  3.02k|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   33|  3.02k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   34|  3.02k|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   35|  3.02k|      s.push_back(static_cast<char>(b0));
   36|  3.02k|      s.push_back(static_cast<char>(b1));
   37|  3.02k|      s.push_back(static_cast<char>(b2));
   38|  3.02k|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (38:14): [True: 237, False: 96]
  ------------------
   39|    237|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   40|    237|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   41|    237|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   42|    237|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   43|    237|      s.push_back(static_cast<char>(b0));
   44|    237|      s.push_back(static_cast<char>(b1));
   45|    237|      s.push_back(static_cast<char>(b2));
   46|    237|      s.push_back(static_cast<char>(b3));
   47|    237|   } else {
   48|     96|      throw Decoding_Error("Invalid Unicode character");
   49|     96|   }
   50|  12.1k|}

_ZN5Botan10DataSource9read_byteERh:
   26|  2.27M|size_t DataSource::read_byte(uint8_t& out) {
   27|  2.27M|   return read(&out, 1);
   28|  2.27M|}
_ZNK5Botan10DataSource9peek_byteERh:
   33|  4.00k|size_t DataSource::peek_byte(uint8_t& out) const {
   34|  4.00k|   return peek(&out, 1, 0);
   35|  4.00k|}
_ZN5Botan10DataSource12discard_nextEm:
   40|  64.0k|size_t DataSource::discard_next(size_t n) {
   41|  64.0k|   uint8_t buf[64] = {0};
   42|  64.0k|   size_t discarded = 0;
   43|       |
   44|   171k|   while(n) {
  ------------------
  |  Branch (44:10): [True: 107k, False: 63.7k]
  ------------------
   45|   107k|      const size_t got = this->read(buf, std::min(n, sizeof(buf)));
   46|   107k|      discarded += got;
   47|   107k|      n -= got;
   48|       |
   49|   107k|      if(got == 0) {
  ------------------
  |  Branch (49:10): [True: 307, False: 107k]
  ------------------
   50|    307|         break;
   51|    307|      }
   52|   107k|   }
   53|       |
   54|  64.0k|   return discarded;
   55|  64.0k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   60|   563k|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   61|   563k|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   62|   563k|   copy_mem(out, m_source.data() + m_offset, got);
   63|   563k|   m_offset += got;
   64|   563k|   return got;
   65|   563k|}
_ZN5Botan17DataSource_Memory15check_availableEm:
   67|  41.6k|bool DataSource_Memory::check_available(size_t n) {
   68|  41.6k|   return (n <= (m_source.size() - m_offset));
   69|  41.6k|}
_ZNK5Botan17DataSource_Memory4peekEPhmm:
   74|  39.3k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   75|  39.3k|   const size_t bytes_left = m_source.size() - m_offset;
   76|  39.3k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (76:7): [True: 16.4k, False: 22.8k]
  ------------------
   77|  16.4k|      return 0;
   78|  16.4k|   }
   79|       |
   80|  22.8k|   const size_t got = std::min(bytes_left - peek_offset, length);
   81|  22.8k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   82|  22.8k|   return got;
   83|  39.3k|}
_ZNK5Botan17DataSource_Memory11end_of_dataEv:
   88|  15.9k|bool DataSource_Memory::end_of_data() const {
   89|  15.9k|   return (m_offset == m_source.size());
   90|  15.9k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  12.7k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
   73|  2.96k|Exception::Exception(std::string_view msg, const std::exception& e) : m_msg(fmt("{} failed with {}", msg, e.what())) {}
_ZN5Botan9ExceptionC2EPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   75|     14|Exception::Exception(const char* prefix, std::string_view msg) : m_msg(fmt("{} {}", prefix, msg)) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|    374|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan14Encoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  123|     14|Encoding_Error::Encoding_Error(std::string_view name) : Exception("Encoding error:", name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  12.3k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
  130|  2.96k|Decoding_Error::Decoding_Error(std::string_view msg, const std::exception& e) : Exception(msg, e) {}

_ZN5Botan19secure_scrub_memoryEPvm:
   87|   259k|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|   259k|   ::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|   259k|}

_ZN5Botan9to_u32bitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   32|   711k|uint32_t to_u32bit(std::string_view str_view) {
   33|   711k|   const std::string str(str_view);
   34|       |
   35|       |   // std::stoul is not strict enough. Ensure that str is digit only [0-9]*
   36|  1.07M|   for(const char chr : str) {
  ------------------
  |  Branch (36:23): [True: 1.07M, False: 711k]
  ------------------
   37|  1.07M|      if(chr < '0' || chr > '9') {
  ------------------
  |  Branch (37:10): [True: 18, False: 1.07M]
  |  Branch (37:23): [True: 6, False: 1.07M]
  ------------------
   38|     24|         throw Invalid_Argument("to_u32bit invalid decimal string '" + str + "'");
   39|     24|      }
   40|  1.07M|   }
   41|       |
   42|   711k|   const unsigned long int x = std::stoul(str);
   43|       |
   44|   711k|   if constexpr(sizeof(unsigned long int) > 4) {
  ------------------
  |  Branch (44:17): [Folded - Ignored]
  ------------------
   45|       |      // x might be uint64
   46|   711k|      if(x > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (46:10): [True: 0, False: 711k]
  ------------------
   47|      0|         throw Invalid_Argument("Integer value of " + str + " exceeds 32 bit range");
   48|      0|      }
   49|   711k|   }
   50|       |
   51|   711k|   return static_cast<uint32_t>(x);
   52|   711k|}
_ZN5Botan14ipv4_to_stringEj:
  181|    889|std::string ipv4_to_string(uint32_t ip) {
  182|    889|   std::string str;
  183|    889|   uint8_t bits[4];
  184|    889|   store_be(ip, bits);
  185|       |
  186|  4.44k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (186:22): [True: 3.55k, False: 889]
  ------------------
  187|  3.55k|      if(i > 0) {
  ------------------
  |  Branch (187:10): [True: 2.66k, False: 889]
  ------------------
  188|  2.66k|         str += ".";
  189|  2.66k|      }
  190|  3.55k|      str += std::to_string(bits[i]);
  191|  3.55k|   }
  192|       |
  193|    889|   return str;
  194|    889|}

_ZN5Botan15AlternativeNameC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_S5_S5_:
   27|  5.67k|                                 std::string_view ip) {
   28|  5.67k|   add_attribute("RFC822", email_addr);
   29|  5.67k|   add_attribute("DNS", dns);
   30|  5.67k|   add_attribute("URI", uri);
   31|  5.67k|   add_attribute("IP", ip);
   32|  5.67k|}
_ZN5Botan15AlternativeName13add_attributeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   37|  30.4k|void AlternativeName::add_attribute(std::string_view type, std::string_view value) {
   38|  30.4k|   if(type.empty() || value.empty()) {
  ------------------
  |  Branch (38:7): [True: 0, False: 30.4k]
  |  Branch (38:23): [True: 23.3k, False: 7.11k]
  ------------------
   39|  23.3k|      return;
   40|  23.3k|   }
   41|       |
   42|  7.11k|   auto range = m_alt_info.equal_range(type);
   43|  42.4k|   for(auto j = range.first; j != range.second; ++j) {
  ------------------
  |  Branch (43:30): [True: 36.8k, False: 5.63k]
  ------------------
   44|  36.8k|      if(j->second == value) {
  ------------------
  |  Branch (44:10): [True: 1.48k, False: 35.3k]
  ------------------
   45|  1.48k|         return;
   46|  1.48k|      }
   47|  36.8k|   }
   48|       |
   49|  5.63k|   m_alt_info.emplace(type, value);
   50|  5.63k|}
_ZN5Botan15AlternativeName13add_othernameERKNS_3OIDENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS_9ASN1_TypeE:
   55|  1.69k|void AlternativeName::add_othername(const OID& oid, std::string_view value, ASN1_Type type) {
   56|  1.69k|   if(value.empty()) {
  ------------------
  |  Branch (56:7): [True: 86, False: 1.61k]
  ------------------
   57|     86|      return;
   58|     86|   }
   59|  1.61k|   multimap_insert(m_othernames, oid, ASN1_String(value, type));
   60|  1.61k|}
_ZNK5Botan15AlternativeName8contentsEv:
   65|    927|std::multimap<std::string, std::string> AlternativeName::contents() const {
   66|    927|   std::multimap<std::string, std::string> names;
   67|       |
   68|  2.50k|   for(const auto& name : m_alt_info) {
  ------------------
  |  Branch (68:25): [True: 2.50k, False: 927]
  ------------------
   69|  2.50k|      names.emplace(name.first, name.second);
   70|  2.50k|   }
   71|       |
   72|  1.17k|   for(const auto& othername : m_othernames) {
  ------------------
  |  Branch (72:30): [True: 1.17k, False: 927]
  ------------------
   73|  1.17k|      multimap_insert(names, othername.first.to_formatted_string(), othername.second.value());
   74|  1.17k|   }
   75|       |
   76|    927|   return names;
   77|    927|}
_ZN5Botan15AlternativeName11decode_fromERNS_11BER_DecoderE:
  179|  2.29k|void AlternativeName::decode_from(BER_Decoder& source) {
  180|  2.29k|   BER_Decoder names = source.start_sequence();
  181|       |
  182|       |   // FIXME this is largely a duplication of GeneralName::decode_from
  183|       |
  184|  21.5k|   while(names.more_items()) {
  ------------------
  |  Branch (184:10): [True: 19.3k, False: 2.24k]
  ------------------
  185|  19.3k|      BER_Object obj = names.get_next_object();
  186|       |
  187|  19.3k|      if(obj.is_a(0, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (187:10): [True: 2.48k, False: 16.8k]
  ------------------
  188|  2.48k|         BER_Decoder othername(obj);
  189|       |
  190|  2.48k|         OID oid;
  191|  2.48k|         othername.decode(oid);
  192|  2.48k|         if(othername.more_items()) {
  ------------------
  |  Branch (192:13): [True: 2.29k, False: 189]
  ------------------
  193|  2.29k|            BER_Object othername_value_outer = othername.get_next_object();
  194|  2.29k|            othername.verify_end();
  195|       |
  196|  2.29k|            if(othername_value_outer.is_a(0, ASN1_Class::ExplicitContextSpecific) == false) {
  ------------------
  |  Branch (196:16): [True: 51, False: 2.24k]
  ------------------
  197|     51|               throw Decoding_Error("Invalid tags on otherName value");
  198|     51|            }
  199|       |
  200|  2.24k|            BER_Decoder othername_value_inner(othername_value_outer);
  201|       |
  202|  2.24k|            BER_Object value = othername_value_inner.get_next_object();
  203|  2.24k|            othername_value_inner.verify_end();
  204|       |
  205|  2.24k|            if(ASN1_String::is_string_type(value.type()) && value.get_class() == ASN1_Class::Universal) {
  ------------------
  |  Branch (205:16): [True: 1.83k, False: 405]
  |  Branch (205:61): [True: 1.69k, False: 139]
  ------------------
  206|  1.69k|               add_othername(oid, ASN1::to_string(value), value.type());
  207|  1.69k|            }
  208|  2.24k|         }
  209|  2.48k|      }
  210|  19.2k|      if(obj.is_a(1, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (210:10): [True: 2.99k, False: 16.2k]
  ------------------
  211|  2.99k|         add_attribute("RFC822", ASN1::to_string(obj));
  212|  16.2k|      } else if(obj.is_a(2, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (212:17): [True: 1.80k, False: 14.4k]
  ------------------
  213|  1.80k|         add_attribute("DNS", ASN1::to_string(obj));
  214|  14.4k|      } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (214:17): [True: 1.15k, False: 13.2k]
  ------------------
  215|  1.15k|         add_attribute("URI", ASN1::to_string(obj));
  216|  13.2k|      } else if(obj.is_a(4, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (216:17): [True: 1.71k, False: 11.5k]
  ------------------
  217|  1.71k|         BER_Decoder dec(obj);
  218|  1.71k|         X509_DN dn;
  219|  1.71k|         std::stringstream ss;
  220|       |
  221|  1.71k|         dec.decode(dn);
  222|  1.71k|         ss << dn;
  223|       |
  224|  1.71k|         add_attribute("DN", ss.str());
  225|  11.5k|      } else if(obj.is_a(7, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (225:17): [True: 785, False: 10.7k]
  ------------------
  226|    785|         if(obj.length() == 4) {
  ------------------
  |  Branch (226:13): [True: 415, False: 370]
  ------------------
  227|    415|            const uint32_t ip = load_be<uint32_t>(obj.bits(), 0);
  228|    415|            add_attribute("IP", ipv4_to_string(ip));
  229|    415|         }
  230|    785|      }
  231|  19.2k|   }
  232|  2.29k|}

_ZN5Botan9CRL_Entry11decode_fromERNS_11BER_DecoderE:
   78|  4.53k|void CRL_Entry::decode_from(BER_Decoder& source) {
   79|  4.53k|   BigInt serial_number_bn;
   80|       |
   81|  4.53k|   auto data = std::make_unique<CRL_Entry_Data>();
   82|       |
   83|  4.53k|   BER_Decoder entry = source.start_sequence();
   84|       |
   85|  4.53k|   entry.decode(serial_number_bn).decode(data->m_time);
   86|  4.53k|   data->m_serial = BigInt::encode(serial_number_bn);
   87|       |
   88|  4.53k|   if(entry.more_items()) {
  ------------------
  |  Branch (88:7): [True: 3.04k, False: 1.48k]
  ------------------
   89|  3.04k|      entry.decode(data->m_extensions);
   90|  3.04k|      if(auto ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_ReasonCode>()) {
  ------------------
  |  Branch (90:15): [True: 182, False: 2.86k]
  ------------------
   91|    182|         data->m_reason = ext->get_reason();
   92|  2.86k|      } else {
   93|  2.86k|         data->m_reason = CRL_Code::Unspecified;
   94|  2.86k|      }
   95|  3.04k|   }
   96|       |
   97|  4.53k|   entry.end_cons();
   98|       |
   99|  4.53k|   m_data = std::move(data);
  100|  4.53k|}

_ZN5Botan11GeneralName11decode_fromERNS_11BER_DecoderE:
   36|  1.90k|void GeneralName::decode_from(BER_Decoder& ber) {
   37|  1.90k|   BER_Object obj = ber.get_next_object();
   38|       |
   39|  1.90k|   if(obj.is_a(1, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (39:7): [True: 263, False: 1.64k]
  ------------------
   40|    263|      m_type = "RFC822";
   41|    263|      m_name = ASN1::to_string(obj);
   42|  1.64k|   } else if(obj.is_a(2, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (42:14): [True: 318, False: 1.32k]
  ------------------
   43|    318|      m_type = "DNS";
   44|    318|      m_name = ASN1::to_string(obj);
   45|  1.32k|   } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (45:14): [True: 411, False: 913]
  ------------------
   46|    411|      m_type = "URI";
   47|    411|      m_name = ASN1::to_string(obj);
   48|    913|   } else if(obj.is_a(4, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (48:14): [True: 401, False: 512]
  ------------------
   49|    401|      m_type = "DN";
   50|    401|      X509_DN dn;
   51|    401|      BER_Decoder dec(obj);
   52|    401|      std::stringstream ss;
   53|       |
   54|    401|      dn.decode_from(dec);
   55|    401|      ss << dn;
   56|       |
   57|    401|      m_name = ss.str();
   58|    512|   } else if(obj.is_a(7, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (58:14): [True: 355, False: 157]
  ------------------
   59|    355|      if(obj.length() == 8) {
  ------------------
  |  Branch (59:10): [True: 237, False: 118]
  ------------------
   60|    237|         m_type = "IP";
   61|    237|         m_name =
   62|    237|            ipv4_to_string(load_be<uint32_t>(obj.bits(), 0)) + "/" + ipv4_to_string(load_be<uint32_t>(obj.bits(), 1));
   63|    237|      } else if(obj.length() == 32) {
  ------------------
  |  Branch (63:17): [True: 20, False: 98]
  ------------------
   64|     20|         throw Decoding_Error("Unsupported IPv6 name constraint");
   65|     98|      } else {
   66|     98|         throw Decoding_Error("Invalid IP name constraint size " + std::to_string(obj.length()));
   67|     98|      }
   68|    355|   } else {
   69|    157|      throw Decoding_Error("Found unknown GeneralName type");
   70|    157|   }
   71|  1.90k|}
_ZN5Botan14GeneralSubtree11decode_fromERNS_11BER_DecoderE:
  204|  2.07k|void GeneralSubtree::decode_from(BER_Decoder& ber) {
  205|  2.07k|   ber.start_sequence()
  206|  2.07k|      .decode(m_base)
  207|  2.07k|      .decode_optional(m_minimum, ASN1_Type(0), ASN1_Class::ContextSpecific, size_t(0))
  208|  2.07k|      .end_cons();
  209|       |
  210|  2.07k|   if(m_minimum != 0) {
  ------------------
  |  Branch (210:7): [True: 89, False: 1.98k]
  ------------------
  211|     89|      throw Decoding_Error("GeneralSubtree minimum must be 0");
  212|     89|   }
  213|       |
  214|  1.98k|   m_maximum = std::numeric_limits<std::size_t>::max();
  215|  1.98k|}

_ZNK5Botan8X509_CRL9PEM_labelEv:
   31|  3.25k|std::string X509_CRL::PEM_label() const {
   32|  3.25k|   return "X509 CRL";
   33|  3.25k|}
_ZNK5Botan8X509_CRL20alternate_PEM_labelsEv:
   35|    149|std::vector<std::string> X509_CRL::alternate_PEM_labels() const {
   36|    149|   return {"CRL"};
   37|    149|}
_ZN5Botan8X509_CRLC2ERNS_10DataSourceE:
   39|  4.00k|X509_CRL::X509_CRL(DataSource& src) {
   40|  4.00k|   load_data(src);
   41|  4.00k|}
_ZN5Botan8X509_CRL12force_decodeEv:
  178|  2.78k|void X509_CRL::force_decode() {
  179|  2.78k|   m_data.reset(decode_crl_body(signed_body(), signature_algorithm()).release());
  180|  2.78k|}
x509_crl.cpp:_ZN5Botan12_GLOBAL__N_115decode_crl_bodyERKNSt3__16vectorIhNS1_9allocatorIhEEEERKNS_19AlgorithmIdentifierE:
  111|  2.78k|std::unique_ptr<CRL_Data> decode_crl_body(const std::vector<uint8_t>& body, const AlgorithmIdentifier& sig_algo) {
  112|  2.78k|   auto data = std::make_unique<CRL_Data>();
  113|       |
  114|  2.78k|   BER_Decoder tbs_crl(body);
  115|       |
  116|  2.78k|   size_t version;
  117|  2.78k|   tbs_crl.decode_optional(version, ASN1_Type::Integer, ASN1_Class::Universal);
  118|       |
  119|  2.78k|   if(version != 0 && version != 1) {
  ------------------
  |  Branch (119:7): [True: 661, False: 2.11k]
  |  Branch (119:23): [True: 42, False: 619]
  ------------------
  120|     42|      throw Decoding_Error("Unknown X.509 CRL version " + std::to_string(version + 1));
  121|     42|   }
  122|       |
  123|  2.73k|   AlgorithmIdentifier sig_algo_inner;
  124|  2.73k|   tbs_crl.decode(sig_algo_inner);
  125|       |
  126|  2.73k|   if(sig_algo != sig_algo_inner) {
  ------------------
  |  Branch (126:7): [True: 112, False: 2.62k]
  ------------------
  127|    112|      throw Decoding_Error("Algorithm identifier mismatch in CRL");
  128|    112|   }
  129|       |
  130|  2.62k|   tbs_crl.decode(data->m_issuer).decode(data->m_this_update).decode(data->m_next_update);
  131|       |
  132|  2.62k|   BER_Object next = tbs_crl.get_next_object();
  133|       |
  134|  2.62k|   if(next.is_a(ASN1_Type::Sequence, ASN1_Class::Constructed)) {
  ------------------
  |  Branch (134:7): [True: 323, False: 2.30k]
  ------------------
  135|    323|      BER_Decoder cert_list(std::move(next));
  136|       |
  137|  4.85k|      while(cert_list.more_items()) {
  ------------------
  |  Branch (137:13): [True: 4.53k, False: 323]
  ------------------
  138|  4.53k|         CRL_Entry entry;
  139|  4.53k|         cert_list.decode(entry);
  140|  4.53k|         data->m_entries.push_back(entry);
  141|  4.53k|      }
  142|    323|      next = tbs_crl.get_next_object();
  143|    323|   }
  144|       |
  145|  2.62k|   if(next.is_a(0, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (145:7): [True: 1.33k, False: 1.28k]
  ------------------
  146|  1.33k|      BER_Decoder crl_options(std::move(next));
  147|  1.33k|      crl_options.decode(data->m_extensions).verify_end();
  148|  1.33k|      next = tbs_crl.get_next_object();
  149|  1.33k|   }
  150|       |
  151|  2.62k|   if(next.is_set()) {
  ------------------
  |  Branch (151:7): [True: 64, False: 2.56k]
  ------------------
  152|     64|      throw Decoding_Error("Unknown tag following extensions in CRL");
  153|     64|   }
  154|       |
  155|  2.56k|   tbs_crl.verify_end();
  156|       |
  157|       |   // Now cache some fields from the extensions
  158|  2.56k|   if(auto ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Number>()) {
  ------------------
  |  Branch (158:12): [True: 6, False: 2.55k]
  ------------------
  159|      6|      data->m_crl_number = ext->get_crl_number();
  160|      6|   }
  161|  2.56k|   if(auto ext = data->m_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
  ------------------
  |  Branch (161:12): [True: 5, False: 2.55k]
  ------------------
  162|      5|      data->m_auth_key_id = ext->get_key_id();
  163|      5|   }
  164|  2.56k|   if(auto ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Issuing_Distribution_Point>()) {
  ------------------
  |  Branch (164:12): [True: 193, False: 2.36k]
  ------------------
  165|    193|      std::stringstream ss;
  166|       |
  167|    727|      for(const auto& pair : ext->get_point().contents()) {
  ------------------
  |  Branch (167:28): [True: 727, False: 193]
  ------------------
  168|    727|         ss << pair.first << ": " << pair.second << " ";
  169|    727|      }
  170|    193|      data->m_issuing_distribution_point = ss.str();
  171|    193|   }
  172|       |
  173|  2.56k|   return data;
  174|  2.62k|}

_ZN5Botan7X509_DN13add_attributeERKNS_3OIDERKNS_11ASN1_StringE:
  100|  3.68k|void X509_DN::add_attribute(const OID& oid, const ASN1_String& str) {
  101|  3.68k|   if(str.empty()) {
  ------------------
  |  Branch (101:7): [True: 182, False: 3.50k]
  ------------------
  102|    182|      return;
  103|    182|   }
  104|       |
  105|  3.50k|   m_rdn.push_back(std::make_pair(oid, str));
  106|  3.50k|   m_dn_bits.clear();
  107|  3.50k|}
_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  347|  4.30k|void X509_DN::decode_from(BER_Decoder& source) {
  348|  4.30k|   std::vector<uint8_t> bits;
  349|       |
  350|  4.30k|   source.start_sequence().raw_bytes(bits).end_cons();
  351|       |
  352|  4.30k|   BER_Decoder sequence(bits);
  353|       |
  354|  4.30k|   m_rdn.clear();
  355|       |
  356|  8.49k|   while(sequence.more_items()) {
  ------------------
  |  Branch (356:10): [True: 4.19k, False: 4.30k]
  ------------------
  357|  4.19k|      BER_Decoder rdn = sequence.start_set();
  358|       |
  359|  8.29k|      while(rdn.more_items()) {
  ------------------
  |  Branch (359:13): [True: 4.09k, False: 4.19k]
  ------------------
  360|  4.09k|         OID oid;
  361|  4.09k|         ASN1_String str;
  362|       |
  363|  4.09k|         rdn.start_sequence()
  364|  4.09k|            .decode(oid)
  365|  4.09k|            .decode(str)  // TODO support Any
  366|  4.09k|            .end_cons();
  367|       |
  368|  4.09k|         add_attribute(oid, str);
  369|  4.09k|      }
  370|  4.19k|   }
  371|       |
  372|       |   // Have to assign last as add_attribute zaps m_dn_bits
  373|  4.30k|   m_dn_bits = bits;
  374|  4.30k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_7X509_DNE:
  408|  1.59k|std::ostream& operator<<(std::ostream& out, const X509_DN& dn) {
  409|  1.59k|   auto info = dn.dn_info();
  410|       |
  411|  3.01k|   for(size_t i = 0; i != info.size(); ++i) {
  ------------------
  |  Branch (411:22): [True: 1.41k, False: 1.59k]
  ------------------
  412|  1.41k|      out << to_short_form(info[i].first) << "=\"";
  413|  14.1k|      for(char c : info[i].second.value()) {
  ------------------
  |  Branch (413:18): [True: 14.1k, False: 1.41k]
  ------------------
  414|  14.1k|         if(c == '\\' || c == '\"') {
  ------------------
  |  Branch (414:13): [True: 179, False: 13.9k]
  |  Branch (414:26): [True: 353, False: 13.6k]
  ------------------
  415|    532|            out << "\\";
  416|    532|         }
  417|  14.1k|         out << c;
  418|  14.1k|      }
  419|  1.41k|      out << "\"";
  420|       |
  421|  1.41k|      if(i + 1 < info.size()) {
  ------------------
  |  Branch (421:10): [True: 321, False: 1.09k]
  ------------------
  422|    321|         out << ",";
  423|    321|      }
  424|  1.41k|   }
  425|  1.59k|   return out;
  426|  1.59k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_113to_short_formERKNS_3OIDE:
  378|  1.41k|std::string to_short_form(const OID& oid) {
  379|  1.41k|   std::string long_id = oid.to_formatted_string();
  380|       |
  381|  1.41k|   if(long_id == "X520.CommonName") {
  ------------------
  |  Branch (381:7): [True: 27, False: 1.39k]
  ------------------
  382|     27|      return "CN";
  383|     27|   }
  384|       |
  385|  1.39k|   if(long_id == "X520.Country") {
  ------------------
  |  Branch (385:7): [True: 45, False: 1.34k]
  ------------------
  386|     45|      return "C";
  387|     45|   }
  388|       |
  389|  1.34k|   if(long_id == "X520.Organization") {
  ------------------
  |  Branch (389:7): [True: 96, False: 1.24k]
  ------------------
  390|     96|      return "O";
  391|     96|   }
  392|       |
  393|  1.24k|   if(long_id == "X520.OrganizationalUnit") {
  ------------------
  |  Branch (393:7): [True: 158, False: 1.09k]
  ------------------
  394|    158|      return "OU";
  395|    158|   }
  396|       |
  397|  1.09k|   return long_id;
  398|  1.24k|}

_ZN5Botan10Extensions15create_extn_objERKNS_3OIDEbRKNSt3__16vectorIhNS4_9allocatorIhEEEE:
   93|  16.5k|                                                                   const std::vector<uint8_t>& body) {
   94|  16.5k|   const std::string oid_str = oid.to_string();
   95|       |
   96|  16.5k|   auto extn = extension_from_oid(oid);
   97|       |
   98|  16.5k|   if(!extn) {
  ------------------
  |  Branch (98:7): [True: 4.25k, False: 12.2k]
  ------------------
   99|       |      // some other unknown extension type
  100|  4.25k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  101|  4.25k|   }
  102|       |
  103|  16.5k|   try {
  104|  16.5k|      extn->decode_inner(body);
  105|  16.5k|   } catch(Decoding_Error&) {
  106|  9.43k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  107|  9.43k|      extn->decode_inner(body);
  108|  9.43k|   }
  109|  16.5k|   return extn;
  110|  16.5k|}
_ZNK5Botan10Extensions20get_extension_objectERKNS_3OIDE:
  190|  4.97k|const Certificate_Extension* Extensions::get_extension_object(const OID& oid) const {
  191|  4.97k|   auto extn = m_extension_info.find(oid);
  192|  4.97k|   if(extn == m_extension_info.end()) {
  ------------------
  |  Branch (192:7): [True: 3.86k, False: 1.11k]
  ------------------
  193|  3.86k|      return nullptr;
  194|  3.86k|   }
  195|       |
  196|  1.11k|   return &extn->second.obj();
  197|  4.97k|}
_ZN5Botan10Extensions11decode_fromERNS_11BER_DecoderE:
  247|  4.38k|void Extensions::decode_from(BER_Decoder& from_source) {
  248|  4.38k|   m_extension_oids.clear();
  249|  4.38k|   m_extension_info.clear();
  250|       |
  251|  4.38k|   BER_Decoder sequence = from_source.start_sequence();
  252|       |
  253|  21.6k|   while(sequence.more_items()) {
  ------------------
  |  Branch (253:10): [True: 17.2k, False: 4.38k]
  ------------------
  254|  17.2k|      OID oid;
  255|  17.2k|      bool critical;
  256|  17.2k|      std::vector<uint8_t> bits;
  257|       |
  258|  17.2k|      sequence.start_sequence()
  259|  17.2k|         .decode(oid)
  260|  17.2k|         .decode_optional(critical, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  261|  17.2k|         .decode(bits, ASN1_Type::OctetString)
  262|  17.2k|         .end_cons();
  263|       |
  264|  17.2k|      auto obj = create_extn_obj(oid, critical, bits);
  265|  17.2k|      Extensions_Info info(critical, bits, std::move(obj));
  266|       |
  267|  17.2k|      m_extension_oids.push_back(oid);
  268|  17.2k|      m_extension_info.emplace(oid, info);
  269|  17.2k|   }
  270|  4.38k|   sequence.verify_end();
  271|  4.38k|}
_ZN5Botan14Cert_Extension17Basic_Constraints12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  300|    778|void Basic_Constraints::decode_inner(const std::vector<uint8_t>& in) {
  301|    778|   BER_Decoder(in)
  302|    778|      .start_sequence()
  303|    778|      .decode_optional(m_is_ca, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  304|    778|      .decode_optional(m_path_limit, ASN1_Type::Integer, ASN1_Class::Universal, NO_CERT_PATH_LIMIT)
  305|    778|      .end_cons();
  306|       |
  307|    778|   if(m_is_ca == false) {
  ------------------
  |  Branch (307:7): [True: 167, False: 611]
  ------------------
  308|    167|      m_path_limit = 0;
  309|    167|   }
  310|    778|}
_ZN5Botan14Cert_Extension9Key_Usage12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  338|    824|void Key_Usage::decode_inner(const std::vector<uint8_t>& in) {
  339|    824|   BER_Decoder ber(in);
  340|       |
  341|    824|   BER_Object obj = ber.get_next_object();
  342|       |
  343|    824|   obj.assert_is_a(ASN1_Type::BitString, ASN1_Class::Universal, "usage constraint");
  344|       |
  345|    824|   if(obj.length() != 2 && obj.length() != 3) {
  ------------------
  |  Branch (345:7): [True: 287, False: 537]
  |  Branch (345:28): [True: 138, False: 149]
  ------------------
  346|    138|      throw BER_Decoding_Error("Bad size for BITSTRING in usage constraint");
  347|    138|   }
  348|       |
  349|    686|   uint16_t usage = 0;
  350|       |
  351|    686|   const uint8_t* bits = obj.bits();
  352|       |
  353|    686|   if(bits[0] >= 8) {
  ------------------
  |  Branch (353:7): [True: 149, False: 537]
  ------------------
  354|    149|      throw BER_Decoding_Error("Invalid unused bits in usage constraint");
  355|    149|   }
  356|       |
  357|    537|   const uint8_t mask = static_cast<uint8_t>(0xFF << bits[0]);
  358|       |
  359|    537|   if(obj.length() == 2) {
  ------------------
  |  Branch (359:7): [True: 88, False: 449]
  ------------------
  360|     88|      usage = make_uint16(bits[1] & mask, 0);
  361|    449|   } else if(obj.length() == 3) {
  ------------------
  |  Branch (361:14): [True: 60, False: 389]
  ------------------
  362|     60|      usage = make_uint16(bits[1], bits[2] & mask);
  363|     60|   }
  364|       |
  365|    537|   m_constraints = Key_Constraints(usage);
  366|    537|}
_ZN5Botan14Cert_Extension14Subject_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  380|    365|void Subject_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  381|    365|   BER_Decoder(in).decode(m_key_id, ASN1_Type::OctetString).verify_end();
  382|    365|}
_ZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  417|    794|void Authority_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  418|    794|   BER_Decoder(in).start_sequence().decode_optional_string(m_key_id, ASN1_Type::OctetString, 0);
  419|    794|}
_ZN5Botan14Cert_Extension24Subject_Alternative_Name12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  442|    657|void Subject_Alternative_Name::decode_inner(const std::vector<uint8_t>& in) {
  443|    657|   BER_Decoder(in).decode(m_alt_name);
  444|    657|}
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  449|    522|void Issuer_Alternative_Name::decode_inner(const std::vector<uint8_t>& in) {
  450|    522|   BER_Decoder(in).decode(m_alt_name);
  451|    522|}
_ZN5Botan14Cert_Extension18Extended_Key_Usage12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  465|    641|void Extended_Key_Usage::decode_inner(const std::vector<uint8_t>& in) {
  466|    641|   BER_Decoder(in).decode_list(m_oids);
  467|    641|}
_ZN5Botan14Cert_Extension16Name_Constraints12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  479|  2.13k|void Name_Constraints::decode_inner(const std::vector<uint8_t>& in) {
  480|  2.13k|   std::vector<GeneralSubtree> permit, exclude;
  481|  2.13k|   BER_Decoder ber(in);
  482|  2.13k|   BER_Decoder ext = ber.start_sequence();
  483|  2.13k|   BER_Object per = ext.get_next_object();
  484|       |
  485|  2.13k|   ext.push_back(per);
  486|  2.13k|   if(per.is_a(0, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (486:7): [True: 781, False: 1.35k]
  ------------------
  487|    781|      ext.decode_list(permit, ASN1_Type(0), ASN1_Class::Constructed | ASN1_Class::ContextSpecific);
  488|    781|      if(permit.empty()) {
  ------------------
  |  Branch (488:10): [True: 3, False: 778]
  ------------------
  489|      3|         throw Encoding_Error("Empty Name Contraint list");
  490|      3|      }
  491|    781|   }
  492|       |
  493|  2.13k|   BER_Object exc = ext.get_next_object();
  494|  2.13k|   ext.push_back(exc);
  495|  2.13k|   if(per.is_a(1, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (495:7): [True: 508, False: 1.62k]
  ------------------
  496|    508|      ext.decode_list(exclude, ASN1_Type(1), ASN1_Class::Constructed | ASN1_Class::ContextSpecific);
  497|    508|      if(exclude.empty()) {
  ------------------
  |  Branch (497:10): [True: 2, False: 506]
  ------------------
  498|      2|         throw Encoding_Error("Empty Name Contraint list");
  499|      2|      }
  500|    508|   }
  501|       |
  502|  2.13k|   ext.end_cons();
  503|       |
  504|  2.13k|   if(permit.empty() && exclude.empty()) {
  ------------------
  |  Branch (504:7): [True: 146, False: 1.98k]
  |  Branch (504:25): [True: 9, False: 137]
  ------------------
  505|      9|      throw Encoding_Error("Empty Name Contraint extension");
  506|      9|   }
  507|       |
  508|  2.12k|   m_name_constraints = NameConstraints(std::move(permit), std::move(exclude));
  509|  2.12k|}
_ZN5Botan14Cert_Extension20Certificate_Policies12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  608|  1.10k|void Certificate_Policies::decode_inner(const std::vector<uint8_t>& in) {
  609|  1.10k|   std::vector<Policy_Information> policies;
  610|       |
  611|  1.10k|   BER_Decoder(in).decode_list(policies);
  612|  1.10k|   m_oids.clear();
  613|  1.10k|   for(const auto& policy : policies) {
  ------------------
  |  Branch (613:27): [True: 380, False: 1.10k]
  ------------------
  614|    380|      m_oids.push_back(policy.oid());
  615|    380|   }
  616|  1.10k|}
_ZN5Botan14Cert_Extension28Authority_Information_Access12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  656|    212|void Authority_Information_Access::decode_inner(const std::vector<uint8_t>& in) {
  657|    212|   BER_Decoder ber = BER_Decoder(in).start_sequence();
  658|       |
  659|  1.00k|   while(ber.more_items()) {
  ------------------
  |  Branch (659:10): [True: 795, False: 212]
  ------------------
  660|    795|      OID oid;
  661|       |
  662|    795|      BER_Decoder info = ber.start_sequence();
  663|       |
  664|    795|      info.decode(oid);
  665|       |
  666|    795|      if(oid == OID::from_string("PKIX.OCSP")) {
  ------------------
  |  Branch (666:10): [True: 138, False: 657]
  ------------------
  667|    138|         BER_Object name = info.get_next_object();
  668|       |
  669|    138|         if(name.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (669:13): [True: 80, False: 58]
  ------------------
  670|     80|            m_ocsp_responder = ASN1::to_string(name);
  671|     80|         }
  672|    138|      }
  673|    795|      if(oid == OID::from_string("PKIX.CertificateAuthorityIssuers")) {
  ------------------
  |  Branch (673:10): [True: 204, False: 591]
  ------------------
  674|    204|         BER_Object name = info.get_next_object();
  675|       |
  676|    204|         if(name.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (676:13): [True: 137, False: 67]
  ------------------
  677|    137|            m_ca_issuers.push_back(ASN1::to_string(name));
  678|    137|         }
  679|    204|      }
  680|    795|   }
  681|    212|}
_ZNK5Botan14Cert_Extension10CRL_Number14get_crl_numberEv:
  686|      6|size_t CRL_Number::get_crl_number() const {
  687|      6|   if(!m_has_value) {
  ------------------
  |  Branch (687:7): [True: 0, False: 6]
  ------------------
  688|      0|      throw Invalid_State("CRL_Number::get_crl_number: Not set");
  689|      0|   }
  690|      6|   return m_crl_number;
  691|      6|}
_ZN5Botan14Cert_Extension10CRL_Number12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  715|    900|void CRL_Number::decode_inner(const std::vector<uint8_t>& in) {
  716|    900|   BER_Decoder(in).decode(m_crl_number);
  717|    900|   m_has_value = true;
  718|    900|}
_ZN5Botan14Cert_Extension14CRL_ReasonCode12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  732|  1.20k|void CRL_ReasonCode::decode_inner(const std::vector<uint8_t>& in) {
  733|  1.20k|   size_t reason_code = 0;
  734|  1.20k|   BER_Decoder(in).decode(reason_code, ASN1_Type::Enumerated, ASN1_Class::Universal);
  735|  1.20k|   m_reason = static_cast<CRL_Code>(reason_code);
  736|  1.20k|}
_ZN5Botan14Cert_Extension23CRL_Distribution_Points12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  744|  1.49k|void CRL_Distribution_Points::decode_inner(const std::vector<uint8_t>& buf) {
  745|  1.49k|   BER_Decoder(buf).decode_list(m_distribution_points).verify_end();
  746|       |
  747|  1.49k|   std::stringstream ss;
  748|       |
  749|  1.49k|   for(const auto& distribution_point : m_distribution_points) {
  ------------------
  |  Branch (749:39): [True: 734, False: 1.49k]
  ------------------
  750|    734|      auto contents = distribution_point.point().contents();
  751|       |
  752|  2.95k|      for(const auto& pair : contents) {
  ------------------
  |  Branch (752:28): [True: 2.95k, False: 734]
  ------------------
  753|  2.95k|         ss << pair.first << ": " << pair.second << " ";
  754|  2.95k|      }
  755|    734|   }
  756|       |
  757|  1.49k|   m_crl_distribution_urls.push_back(ss.str());
  758|  1.49k|}
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_Point11decode_fromERNS_11BER_DecoderE:
  778|  2.51k|void CRL_Distribution_Points::Distribution_Point::decode_from(BER_Decoder& ber) {
  779|  2.51k|   ber.start_sequence()
  780|  2.51k|      .start_context_specific(0)
  781|  2.51k|      .decode_optional_implicit(m_point,
  782|  2.51k|                                ASN1_Type(0),
  783|  2.51k|                                ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
  784|  2.51k|                                ASN1_Type::Sequence,
  785|  2.51k|                                ASN1_Class::Constructed)
  786|  2.51k|      .end_cons()
  787|  2.51k|      .end_cons();
  788|  2.51k|}
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  794|    652|void CRL_Issuing_Distribution_Point::decode_inner(const std::vector<uint8_t>& buf) {
  795|    652|   BER_Decoder(buf).decode(m_distribution_point).verify_end();
  796|    652|}
_ZN5Botan14Cert_Extension17Unknown_Extension12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  806|  13.6k|void Unknown_Extension::decode_inner(const std::vector<uint8_t>& bytes) {
  807|       |   // Just treat as an opaque blob at this level
  808|  13.6k|   m_bytes = bytes;
  809|  13.6k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_118extension_from_oidERKNS_3OIDE:
   26|  16.5k|std::unique_ptr<Certificate_Extension> extension_from_oid(const OID& oid) {
   27|  16.5k|   if(oid == Cert_Extension::Subject_Key_ID::static_oid()) {
  ------------------
  |  Branch (27:7): [True: 365, False: 16.1k]
  ------------------
   28|    365|      return std::make_unique<Cert_Extension::Subject_Key_ID>();
   29|    365|   }
   30|       |
   31|  16.1k|   if(oid == Cert_Extension::Key_Usage::static_oid()) {
  ------------------
  |  Branch (31:7): [True: 824, False: 15.3k]
  ------------------
   32|    824|      return std::make_unique<Cert_Extension::Key_Usage>();
   33|    824|   }
   34|       |
   35|  15.3k|   if(oid == Cert_Extension::Subject_Alternative_Name::static_oid()) {
  ------------------
  |  Branch (35:7): [True: 657, False: 14.7k]
  ------------------
   36|    657|      return std::make_unique<Cert_Extension::Subject_Alternative_Name>();
   37|    657|   }
   38|       |
   39|  14.7k|   if(oid == Cert_Extension::Issuer_Alternative_Name::static_oid()) {
  ------------------
  |  Branch (39:7): [True: 522, False: 14.1k]
  ------------------
   40|    522|      return std::make_unique<Cert_Extension::Issuer_Alternative_Name>();
   41|    522|   }
   42|       |
   43|  14.1k|   if(oid == Cert_Extension::Basic_Constraints::static_oid()) {
  ------------------
  |  Branch (43:7): [True: 778, False: 13.4k]
  ------------------
   44|    778|      return std::make_unique<Cert_Extension::Basic_Constraints>();
   45|    778|   }
   46|       |
   47|  13.4k|   if(oid == Cert_Extension::CRL_Number::static_oid()) {
  ------------------
  |  Branch (47:7): [True: 900, False: 12.5k]
  ------------------
   48|    900|      return std::make_unique<Cert_Extension::CRL_Number>();
   49|    900|   }
   50|       |
   51|  12.5k|   if(oid == Cert_Extension::CRL_ReasonCode::static_oid()) {
  ------------------
  |  Branch (51:7): [True: 1.20k, False: 11.2k]
  ------------------
   52|  1.20k|      return std::make_unique<Cert_Extension::CRL_ReasonCode>();
   53|  1.20k|   }
   54|       |
   55|  11.2k|   if(oid == Cert_Extension::Authority_Key_ID::static_oid()) {
  ------------------
  |  Branch (55:7): [True: 794, False: 10.5k]
  ------------------
   56|    794|      return std::make_unique<Cert_Extension::Authority_Key_ID>();
   57|    794|   }
   58|       |
   59|  10.5k|   if(oid == Cert_Extension::Name_Constraints::static_oid()) {
  ------------------
  |  Branch (59:7): [True: 2.13k, False: 8.36k]
  ------------------
   60|  2.13k|      return std::make_unique<Cert_Extension::Name_Constraints>();
   61|  2.13k|   }
   62|       |
   63|  8.36k|   if(oid == Cert_Extension::CRL_Distribution_Points::static_oid()) {
  ------------------
  |  Branch (63:7): [True: 1.49k, False: 6.86k]
  ------------------
   64|  1.49k|      return std::make_unique<Cert_Extension::CRL_Distribution_Points>();
   65|  1.49k|   }
   66|       |
   67|  6.86k|   if(oid == Cert_Extension::CRL_Issuing_Distribution_Point::static_oid()) {
  ------------------
  |  Branch (67:7): [True: 652, False: 6.21k]
  ------------------
   68|    652|      return std::make_unique<Cert_Extension::CRL_Issuing_Distribution_Point>();
   69|    652|   }
   70|       |
   71|  6.21k|   if(oid == Cert_Extension::Certificate_Policies::static_oid()) {
  ------------------
  |  Branch (71:7): [True: 1.10k, False: 5.11k]
  ------------------
   72|  1.10k|      return std::make_unique<Cert_Extension::Certificate_Policies>();
   73|  1.10k|   }
   74|       |
   75|  5.11k|   if(oid == Cert_Extension::Extended_Key_Usage::static_oid()) {
  ------------------
  |  Branch (75:7): [True: 641, False: 4.46k]
  ------------------
   76|    641|      return std::make_unique<Cert_Extension::Extended_Key_Usage>();
   77|    641|   }
   78|       |
   79|  4.46k|   if(oid == Cert_Extension::Authority_Information_Access::static_oid()) {
  ------------------
  |  Branch (79:7): [True: 212, False: 4.25k]
  ------------------
   80|    212|      return std::make_unique<Cert_Extension::Authority_Information_Access>();
   81|    212|   }
   82|       |
   83|  4.25k|   return nullptr;  // unknown
   84|  4.46k|}
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_118Policy_Information11decode_fromERNS_11BER_DecoderE:
  579|    593|      void decode_from(BER_Decoder& codec) override {
  580|    593|         codec.start_sequence().decode(m_oid).discard_remaining().end_cons();
  581|    593|      }
x509_ext.cpp:_ZNK5Botan14Cert_Extension12_GLOBAL__N_118Policy_Information3oidEv:
  575|    380|      const OID& oid() const { return m_oid; }
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_118Policy_InformationC2Ev:
  571|    593|      Policy_Information() = default;

_ZN5Botan11X509_Object9load_dataERNS_10DataSourceE:
   24|  4.00k|void X509_Object::load_data(DataSource& in) {
   25|  4.00k|   try {
   26|  4.00k|      if(ASN1::maybe_BER(in) && !PEM_Code::matches(in)) {
  ------------------
  |  Branch (26:10): [True: 3.63k, False: 368]
  |  Branch (26:33): [True: 3.63k, False: 7]
  ------------------
   27|  3.63k|         BER_Decoder dec(in);
   28|  3.63k|         decode_from(dec);
   29|  3.63k|      } else {
   30|    375|         std::string got_label;
   31|    375|         DataSource_Memory ber(PEM_Code::decode(in, got_label));
   32|       |
   33|    375|         if(got_label != PEM_label()) {
  ------------------
  |  Branch (33:13): [True: 149, False: 226]
  ------------------
   34|    149|            bool is_alternate = false;
   35|    149|            for(std::string_view alt_label : alternate_PEM_labels()) {
  ------------------
  |  Branch (35:44): [True: 149, False: 148]
  ------------------
   36|    149|               if(got_label == alt_label) {
  ------------------
  |  Branch (36:19): [True: 1, False: 148]
  ------------------
   37|      1|                  is_alternate = true;
   38|      1|                  break;
   39|      1|               }
   40|    149|            }
   41|       |
   42|    149|            if(!is_alternate) {
  ------------------
  |  Branch (42:16): [True: 148, False: 1]
  ------------------
   43|    148|               throw Decoding_Error("Unexpected PEM label for " + PEM_label() + " of " + got_label);
   44|    148|            }
   45|    149|         }
   46|       |
   47|    227|         BER_Decoder dec(ber);
   48|    227|         decode_from(dec);
   49|    227|      }
   50|  4.00k|   } catch(Decoding_Error& e) {
   51|  2.96k|      throw Decoding_Error(PEM_label() + " decoding", e);
   52|  2.96k|   }
   53|  4.00k|}
_ZN5Botan11X509_Object11decode_fromERNS_11BER_DecoderE:
   68|  3.63k|void X509_Object::decode_from(BER_Decoder& from) {
   69|  3.63k|   from.start_sequence()
   70|  3.63k|      .start_sequence()
   71|  3.63k|      .raw_bytes(m_tbs_bits)
   72|  3.63k|      .end_cons()
   73|  3.63k|      .decode(m_sig_algo)
   74|  3.63k|      .decode(m_sig, ASN1_Type::BitString)
   75|  3.63k|      .end_cons();
   76|       |
   77|  3.63k|   force_decode();
   78|  3.63k|}