_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEjEEmT_m:
   45|    605|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|    605|   const T a = ~x & (x - 1);
   51|    605|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|    605|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|    605|   return mask & s;
   54|    605|}
_ZN5Botan8high_bitITkNSt3__117unsigned_integralEjEEmT_:
   73|    121|BOTAN_FORCE_INLINE constexpr size_t high_bit(T n) {
   74|    121|   size_t hb = 0;
   75|       |
   76|    726|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (76:38): [True: 605, False: 121]
  ------------------
   77|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   78|    605|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
   79|    605|      hb += z;
   80|    605|      n >>= z;
   81|    605|   }
   82|       |
   83|    121|   hb += n;
   84|       |
   85|    121|   return hb;
   86|    121|}
_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEmEEmT_m:
   45|   149k|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|   149k|   const T a = ~x & (x - 1);
   51|   149k|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|   149k|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|   149k|   return mask & s;
   54|   149k|}
_ZN5Botan17ct_expand_top_bitITkNSt3__117unsigned_integralEmEET_S2_:
   28|   124k|BOTAN_FORCE_INLINE constexpr T ct_expand_top_bit(T a) {
   29|   124k|   const T top = CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1));
   30|   124k|   return static_cast<T>(0) - top;
   31|   124k|}
_ZN5Botan10ct_is_zeroITkNSt3__117unsigned_integralEmEET_S2_:
   37|   124k|BOTAN_FORCE_INLINE constexpr T ct_is_zero(T x) {
   38|   124k|   return ct_expand_top_bit<T>(~x & (x - 1));
   39|   124k|}
_ZN5Botan8high_bitITkNSt3__117unsigned_integralEmEEmT_:
   73|  24.9k|BOTAN_FORCE_INLINE constexpr size_t high_bit(T n) {
   74|  24.9k|   size_t hb = 0;
   75|       |
   76|   174k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (76:38): [True: 149k, False: 24.9k]
  ------------------
   77|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   78|   149k|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
   79|   149k|      hb += z;
   80|   149k|      n >>= z;
   81|   149k|   }
   82|       |
   83|  24.9k|   hb += n;
   84|       |
   85|  24.9k|   return hb;
   86|  24.9k|}

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

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

_ZN5Botan13nibble_to_hexEh:
   76|     46|inline constexpr char nibble_to_hex(uint8_t b) {
   77|     46|   const uint8_t n = b & 0x0F;
   78|     46|   return static_cast<char>(n < 10 ? '0' + n : 'A' + (n - 10));
  ------------------
  |  Branch (78:29): [True: 31, False: 15]
  ------------------
   79|     46|}

base64.cpp:_ZN5Botan11base_decodeINS_12_GLOBAL__N_16Base64EEEmRKT_PhPKcmRmbb:
  124|    152|                   bool ignore_ws = true) {
  125|       |   // TODO(Botan4) Check if we can use just base. or Base:: here instead
  126|    152|   constexpr size_t decoding_bytes_in = std::remove_reference_t<Base>::decoding_bytes_in();
  127|    152|   constexpr size_t decoding_bytes_out = std::remove_reference_t<Base>::decoding_bytes_out();
  128|       |
  129|    152|   uint8_t* out_ptr = output;
  130|    152|   std::array<uint8_t, decoding_bytes_in> decode_buf{};
  131|    152|   size_t decode_buf_pos = 0;
  132|    152|   size_t final_truncate = 0;
  133|    152|   bool seen_padding = false;
  134|       |
  135|    152|   clear_mem(output, base.decode_max_output(input_length));
  136|       |
  137|  43.1k|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (137:22): [True: 43.0k, False: 111]
  ------------------
  138|  43.0k|      const uint8_t bin = base.lookup_binary_value(input[i]);
  139|       |
  140|       |      // This call might throw Invalid_Argument
  141|  43.0k|      if(base.check_bad_char(bin, input[i], ignore_ws)) {
  ------------------
  |  Branch (141:10): [True: 15.0k, False: 28.0k]
  ------------------
  142|       |         // Padding may only appear at the end, so a data symbol must never
  143|       |         // follow one (0x81 marks a padding character)
  144|  15.0k|         if(seen_padding) {
  ------------------
  |  Branch (144:13): [True: 6, False: 15.0k]
  ------------------
  145|      6|            throw Invalid_Argument(base.name() + " decoding failed, data follows padding");
  146|      6|         }
  147|  15.0k|         decode_buf[decode_buf_pos] = bin;
  148|  15.0k|         ++decode_buf_pos;
  149|  28.0k|      } else if(bin == 0x81) {
  ------------------
  |  Branch (149:17): [True: 373, False: 27.6k]
  ------------------
  150|    373|         seen_padding = true;
  151|    373|      }
  152|       |
  153|       |      /*
  154|       |      * If we're at the end of the input, pad with 0s and truncate
  155|       |      */
  156|  43.0k|      if(final_inputs && (i == input_length - 1)) {
  ------------------
  |  Branch (156:10): [True: 43.0k, False: 28]
  |  Branch (156:26): [True: 78, False: 42.9k]
  ------------------
  157|     78|         if(decode_buf_pos) {
  ------------------
  |  Branch (157:13): [True: 42, False: 36]
  ------------------
  158|     42|            const size_t bits_per_symbol = base.bits_consumed();
  159|     42|            const size_t pad_bits = (decode_buf_pos * bits_per_symbol) % 8;
  160|       |
  161|       |            // A trailing symbol contributing only pad bits cannot occur in a
  162|       |            // valid encoding; RFC 4648 4 and 6 enumerate the reachable cases
  163|     42|            if(pad_bits >= bits_per_symbol) {
  ------------------
  |  Branch (163:16): [True: 17, False: 25]
  ------------------
  164|     17|               throw Invalid_Argument(base.name() + " decoding failed, invalid length");
  165|     17|            }
  166|       |
  167|       |            // RFC 4648 3.5: "decoders MAY chose to reject an encoding if the
  168|       |            // pad bits have not been set to zero"
  169|     25|            const uint8_t pad_mask = static_cast<uint8_t>((1U << pad_bits) - 1);
  170|     25|            if(decode_buf[decode_buf_pos - 1] & pad_mask) {
  ------------------
  |  Branch (170:16): [True: 18, False: 7]
  ------------------
  171|     18|               throw Invalid_Argument(base.name() + " decoding failed, nonzero padding bits");
  172|     18|            }
  173|       |
  174|      7|            for(size_t j = decode_buf_pos; j < decoding_bytes_in; ++j) {
  ------------------
  |  Branch (174:44): [True: 0, False: 7]
  ------------------
  175|      0|               decode_buf[j] = 0;
  176|      0|            }
  177|       |
  178|      7|            final_truncate = decoding_bytes_in - decode_buf_pos;
  179|      7|            decode_buf_pos = decoding_bytes_in;
  180|      7|         }
  181|     78|      }
  182|       |
  183|  43.0k|      if(decode_buf_pos == decoding_bytes_in) {
  ------------------
  |  Branch (183:10): [True: 3.74k, False: 39.2k]
  ------------------
  184|  3.74k|         base.decode(out_ptr, decode_buf.data());
  185|       |
  186|  3.74k|         out_ptr += decoding_bytes_out;
  187|  3.74k|         decode_buf_pos = 0;
  188|  3.74k|         input_consumed = i + 1;
  189|  3.74k|      }
  190|  43.0k|   }
  191|       |
  192|  2.76k|   while(input_consumed < input_length && base.lookup_binary_value(input[input_consumed]) == 0x80) {
  ------------------
  |  Branch (192:10): [True: 2.67k, False: 92]
  |  Branch (192:43): [True: 2.65k, False: 19]
  ------------------
  193|  2.65k|      ++input_consumed;
  194|  2.65k|   }
  195|       |
  196|    111|   const size_t written = (out_ptr - output) - base.bytes_to_remove(final_truncate);
  197|       |
  198|    111|   return written;
  199|    152|}
base64.cpp:_ZN5Botan16base_decode_fullINS_12_GLOBAL__N_16Base64EEEmRKT_PhPKcmb:
  202|    152|size_t base_decode_full(const Base& base, uint8_t output[], const char input[], size_t input_length, bool ignore_ws) {
  203|    152|   size_t consumed = 0;
  204|    152|   const size_t written = base_decode(base, output, input, input_length, consumed, true, ignore_ws);
  205|       |
  206|    152|   if(consumed != input_length) {
  ------------------
  |  Branch (206:7): [True: 19, False: 133]
  ------------------
  207|     19|      throw Invalid_Argument(base.name() + " decoding failed, input did not have full bytes");
  208|     19|   }
  209|       |
  210|    133|   return written;
  211|    152|}
base64.cpp:_ZN5Botan18base_decode_to_vecINSt3__16vectorIhNS_16secure_allocatorIhEEEENS_12_GLOBAL__N_16Base64EEET_RKT0_PKcmb:
  214|    152|Vector base_decode_to_vec(const Base& base, const char input[], size_t input_length, bool ignore_ws) {
  215|    152|   const size_t output_length = base.decode_max_output(input_length);
  216|    152|   Vector bin(output_length);
  217|       |
  218|    152|   const size_t written = base_decode_full(base, bin.data(), input, input_length, ignore_ws);
  219|       |
  220|    152|   bin.resize(written);
  221|    152|   return bin;
  222|    152|}

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

_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  4.74k|std::string fmt(std::string_view format, const T&... args) {
   54|  4.74k|   std::ostringstream oss;
   55|  4.74k|   oss.imbue(std::locale::classic());
   56|  4.74k|   fmt_detail::do_fmt(oss, format, args...);
   57|  4.74k|   return oss.str();
   58|  4.74k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  4.74k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.74k|   size_t i = 0;
   27|       |
   28|  51.0k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 51.0k, False: 0]
  ------------------
   29|  51.0k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.74k, False: 46.2k]
  |  Branch (29:30): [True: 4.74k, False: 0]
  |  Branch (29:59): [True: 4.74k, False: 0]
  ------------------
   30|  4.74k|         oss << val;
   31|  4.74k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  46.2k|      } else {
   33|  46.2k|         oss << format[i];
   34|  46.2k|      }
   35|       |
   36|  46.2k|      i += 1;
   37|  46.2k|   }
   38|  4.74k|}
_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  11.6k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  11.6k|   oss << format;
   22|  11.6k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKcEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  3.92k|std::string fmt(std::string_view format, const T&... args) {
   54|  3.92k|   std::ostringstream oss;
   55|  3.92k|   oss.imbue(std::locale::classic());
   56|  3.92k|   fmt_detail::do_fmt(oss, format, args...);
   57|  3.92k|   return oss.str();
   58|  3.92k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJPKcEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  3.92k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.92k|   size_t i = 0;
   27|       |
   28|  3.92k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.92k, False: 0]
  ------------------
   29|  3.92k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.92k, False: 0]
  |  Branch (29:30): [True: 3.92k, False: 0]
  |  Branch (29:59): [True: 3.92k, False: 0]
  ------------------
   30|  3.92k|         oss << val;
   31|  3.92k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.92k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  3.92k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  3.93k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.93k|   size_t i = 0;
   27|       |
   28|  55.0k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 55.0k, False: 0]
  ------------------
   29|  55.0k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.93k, False: 51.1k]
  |  Branch (29:30): [True: 3.93k, False: 0]
  |  Branch (29:59): [True: 3.93k, False: 0]
  ------------------
   30|  3.93k|         oss << val;
   31|  3.93k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  51.1k|      } else {
   33|  51.1k|         oss << format[i];
   34|  51.1k|      }
   35|       |
   36|  51.1k|      i += 1;
   37|  51.1k|   }
   38|  3.93k|}
_ZN5Botan10fmt_detail6do_fmtImJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_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|    574|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 574, False: 0]
  ------------------
   29|    574|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 14, False: 560]
  |  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|    560|      } else {
   33|    560|         oss << format[i];
   34|    560|      }
   35|       |
   36|    560|      i += 1;
   37|    560|   }
   38|     14|}
_ZN5Botan3fmtIJPKcEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|      3|std::string fmt(std::string_view format, const T&... args) {
   54|      3|   std::ostringstream oss;
   55|      3|   oss.imbue(std::locale::classic());
   56|      3|   fmt_detail::do_fmt(oss, format, args...);
   57|      3|   return oss.str();
   58|      3|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|  2.23k|std::string fmt(std::string_view format, const T&... args) {
   54|  2.23k|   std::ostringstream oss;
   55|  2.23k|   oss.imbue(std::locale::classic());
   56|  2.23k|   fmt_detail::do_fmt(oss, format, args...);
   57|  2.23k|   return oss.str();
   58|  2.23k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|  2.23k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  2.23k|   size_t i = 0;
   27|       |
   28|  46.3k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 46.3k, False: 0]
  ------------------
   29|  46.3k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 2.23k, False: 44.1k]
  |  Branch (29:30): [True: 2.23k, False: 0]
  |  Branch (29:59): [True: 2.23k, False: 0]
  ------------------
   30|  2.23k|         oss << val;
   31|  2.23k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  44.1k|      } else {
   33|  44.1k|         oss << format[i];
   34|  44.1k|      }
   35|       |
   36|  44.1k|      i += 1;
   37|  44.1k|   }
   38|  2.23k|}
_ZN5Botan3fmtIJmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   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_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    763|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    763|   size_t i = 0;
   27|       |
   28|  1.55k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.55k, False: 0]
  ------------------
   29|  1.55k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 763, False: 796]
  |  Branch (29:30): [True: 763, False: 0]
  |  Branch (29:59): [True: 763, False: 0]
  ------------------
   30|    763|         oss << val;
   31|    763|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    796|      } else {
   33|    796|         oss << format[i];
   34|    796|      }
   35|       |
   36|    796|      i += 1;
   37|    796|   }
   38|    763|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|     33|std::string fmt(std::string_view format, const T&... args) {
   54|     33|   std::ostringstream oss;
   55|     33|   oss.imbue(std::locale::classic());
   56|     33|   fmt_detail::do_fmt(oss, format, args...);
   57|     33|   return oss.str();
   58|     33|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|     33|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     33|   size_t i = 0;
   27|       |
   28|     33|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 33, False: 0]
  ------------------
   29|     33|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 33, False: 0]
  |  Branch (29:30): [True: 33, False: 0]
  |  Branch (29:59): [True: 33, False: 0]
  ------------------
   30|     33|         oss << val;
   31|     33|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     33|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|     33|}
_ZN5Botan3fmtIJjjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    730|std::string fmt(std::string_view format, const T&... args) {
   54|    730|   std::ostringstream oss;
   55|    730|   oss.imbue(std::locale::classic());
   56|    730|   fmt_detail::do_fmt(oss, format, args...);
   57|    730|   return oss.str();
   58|    730|}
_ZN5Botan10fmt_detail6do_fmtIjJjEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    730|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    730|   size_t i = 0;
   27|       |
   28|  24.8k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 24.8k, False: 0]
  ------------------
   29|  24.8k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 730, False: 24.0k]
  |  Branch (29:30): [True: 730, False: 0]
  |  Branch (29:59): [True: 730, False: 0]
  ------------------
   30|    730|         oss << val;
   31|    730|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  24.0k|      } else {
   33|  24.0k|         oss << format[i];
   34|  24.0k|      }
   35|       |
   36|  24.0k|      i += 1;
   37|  24.0k|   }
   38|    730|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|      1|std::string fmt(std::string_view format, const T&... args) {
   54|      1|   std::ostringstream oss;
   55|      1|   oss.imbue(std::locale::classic());
   56|      1|   fmt_detail::do_fmt(oss, format, args...);
   57|      1|   return oss.str();
   58|      1|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|      1|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      1|   size_t i = 0;
   27|       |
   28|      1|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1, False: 0]
  ------------------
   29|      1|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1, False: 0]
  |  Branch (29:30): [True: 1, False: 0]
  |  Branch (29:59): [True: 1, False: 0]
  ------------------
   30|      1|         oss << val;
   31|      1|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|      1|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|      1|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|      1|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      1|   size_t i = 0;
   27|       |
   28|      5|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 5, False: 0]
  ------------------
   29|      5|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1, False: 4]
  |  Branch (29:30): [True: 1, False: 0]
  |  Branch (29:59): [True: 1, False: 0]
  ------------------
   30|      1|         oss << val;
   31|      1|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|      4|      } else {
   33|      4|         oss << format[i];
   34|      4|      }
   35|       |
   36|      4|      i += 1;
   37|      4|   }
   38|      1|}

_ZN5Botan11checked_mulITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   46|  32.7k|constexpr inline std::optional<T> checked_mul(T a, T b) {
   47|       |   // Multiplication by 1U is a hack to work around C's insane
   48|       |   // integer promotion rules.
   49|       |   // https://stackoverflow.com/questions/24795651
   50|  32.7k|   const T r = (1U * a) * b;
   51|       |   // If a == 0 then the multiply certainly did not overflow
   52|       |   // Otherwise r / a == b unless overflow occurred
   53|  32.7k|   if(a != 0 && r / a != b) {
  ------------------
  |  Branch (53:7): [True: 32.7k, False: 0]
  |  Branch (53:17): [True: 0, False: 32.7k]
  ------------------
   54|      0|      return {};
   55|      0|   }
   56|  32.7k|   return r;
   57|  32.7k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEjEENS1_8optionalIT_EES3_S3_:
   19|    369|constexpr inline std::optional<T> checked_add(T a, T b) {
   20|    369|   const T r = a + b;
   21|    369|   if(r < a || r < b) {
  ------------------
  |  Branch (21:7): [True: 0, False: 369]
  |  Branch (21:16): [True: 0, False: 369]
  ------------------
   22|      0|      return {};
   23|      0|   }
   24|    369|   return r;
   25|    369|}
_ZN5Botan13swar_in_rangeITkNSt3__117unsigned_integralEmEET_S2_S2_S2_:
  144|  45.7k|constexpr T swar_in_range(T v, T lower, T upper) {
  145|       |   // The constant 0x808080... as a T
  146|  45.7k|   constexpr T hi1 = (static_cast<T>(-1) / 255) << 7;
  147|       |   // The constant 0x7F7F7F... as a T
  148|  45.7k|   constexpr T lo7 = ~hi1;
  149|       |
  150|  45.7k|   const T sub = ((v | hi1) - (lower & lo7)) ^ ((v ^ (~lower)) & hi1);
  151|  45.7k|   const T a_lo = sub & lo7;
  152|  45.7k|   const T a_hi = sub & hi1;
  153|  45.7k|   return (lo7 - a_lo + upper) & hi1 & ~a_hi;
  154|  45.7k|}

_ZN5Botan8store_leINS_6detail10AutoDetectEJmEEEDaDpOT0_:
  736|  1.10k|inline constexpr auto store_le(ParamTs&&... params) {
  737|  1.10k|   return detail::store_any<std::endian::little, ModifierT>(std::forward<ParamTs>(params)...);
  738|  1.10k|}
_ZN5Botan6detail9store_anyILNSt3__16endianE57005ENS0_10AutoDetectETpTkNS0_20unsigned_integralishEJmEQ10all_same_vIDpT1_EEEDaS6_:
  696|  1.10k|inline constexpr auto store_any(Ts... ins) {
  697|  1.10k|   return store_any<endianness, OutR>(std::array{ins...});
  698|  1.10k|}
_ZN5Botan6detail9store_anyILNSt3__16endianE57005ENS0_10AutoDetectETkNS_6ranges14spanable_rangeENS2_5arrayImLm1EEEQoooosr3stdE7same_asIS4_T0_Eaasr6rangesE25statically_spanable_rangeIS8_Esr3stdE21default_initializableIS8_Esr8conceptsE21resizable_byte_bufferIS8_EEEDaOT1_:
  663|  1.10k|inline constexpr auto store_any(InR&& in_range) {
  664|  1.10k|   auto out = []([[maybe_unused]] const auto& in) {
  665|  1.10k|      if constexpr(std::same_as<AutoDetect, OutR>) {
  666|  1.10k|         if constexpr(ranges::statically_spanable_range<InR>) {
  667|  1.10k|            constexpr size_t bytes = decltype(std::span{in})::extent * sizeof(std::ranges::range_value_t<InR>);
  668|  1.10k|            return std::array<uint8_t, bytes>();
  669|  1.10k|         } else {
  670|  1.10k|            static_assert(
  671|  1.10k|               !std::same_as<AutoDetect, OutR>,
  672|  1.10k|               "cannot infer a suitable result container type from the given parameters at compile time, please specify it explicitly");
  673|  1.10k|         }
  674|  1.10k|      } else if constexpr(concepts::resizable_byte_buffer<OutR>) {
  675|  1.10k|         return OutR(std::span{in}.size_bytes());
  676|  1.10k|      } else {
  677|  1.10k|         return OutR{};
  678|  1.10k|      }
  679|  1.10k|   }(in_range);
  680|       |
  681|  1.10k|   store_any<endianness, std::ranges::range_value_t<InR>>(out, std::forward<InR>(in_range));
  682|  1.10k|   return out;
  683|  1.10k|}
_ZZN5Botan6detail9store_anyILNSt3__16endianE57005ENS0_10AutoDetectETkNS_6ranges14spanable_rangeENS2_5arrayImLm1EEEQoooosr3stdE7same_asIS4_T0_Eaasr6rangesE25statically_spanable_rangeIS8_Esr3stdE21default_initializableIS8_Esr8conceptsE21resizable_byte_bufferIS8_EEEDaOT1_ENKUlRKT_E_clIS7_EEDaSD_:
  664|  1.10k|   auto out = []([[maybe_unused]] const auto& in) {
  665|  1.10k|      if constexpr(std::same_as<AutoDetect, OutR>) {
  666|  1.10k|         if constexpr(ranges::statically_spanable_range<InR>) {
  667|  1.10k|            constexpr size_t bytes = decltype(std::span{in})::extent * sizeof(std::ranges::range_value_t<InR>);
  668|  1.10k|            return std::array<uint8_t, bytes>();
  669|       |         } else {
  670|       |            static_assert(
  671|       |               !std::same_as<AutoDetect, OutR>,
  672|       |               "cannot infer a suitable result container type from the given parameters at compile time, please specify it explicitly");
  673|       |         }
  674|       |      } else if constexpr(concepts::resizable_byte_buffer<OutR>) {
  675|       |         return OutR(std::span{in}.size_bytes());
  676|       |      } else {
  677|       |         return OutR{};
  678|       |      }
  679|  1.10k|   }(in_range);
_ZN5Botan6detail9store_anyILNSt3__16endianE57005EmTkNS_6ranges23contiguous_output_rangeIhEERNS2_5arrayIhLm8EEETkNS4_14spanable_rangeENS6_ImLm1EEEQoosr3stdE7same_asINS0_10AutoDetectET0_Esr3stdE7same_asISB_NS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT2_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISJ_EESK_E4type10value_typeEEEEvOT1_RKSG_:
  603|  1.10k|inline constexpr void store_any(OutR&& out /* NOLINT(*-std-forward) */, const InR& in) {
  604|  1.10k|   ranges::assert_equal_byte_lengths(out, in);
  605|  1.10k|   using element_type = std::ranges::range_value_t<InR>;
  606|       |
  607|  1.10k|   auto store_elementwise = [&] {
  608|  1.10k|      constexpr size_t bytes_per_element = sizeof(element_type);
  609|  1.10k|      std::span<uint8_t> out_s(out);
  610|  1.10k|      for(auto in_elem : in) {
  611|  1.10k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  612|  1.10k|         out_s = out_s.subspan(bytes_per_element);
  613|  1.10k|      }
  614|  1.10k|   };
  615|       |
  616|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  617|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  618|       |   // in a `constexpr` context.
  619|  1.10k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (619:7): [Folded, False: 1.10k]
  ------------------
  620|      0|      store_elementwise();
  621|  1.10k|   } else {
  622|  1.10k|      if constexpr(endianness == std::endian::native && !custom_storable<element_type>) {
  623|  1.10k|         typecast_copy(out, in);
  624|       |      } else {
  625|       |         store_elementwise();
  626|       |      }
  627|  1.10k|   }
  628|  1.10k|}
_ZN5Botan6detail26unwrap_strong_type_or_enumITkNS0_20unsigned_integralishEmEEDaT_:
  190|      6|constexpr auto unwrap_strong_type_or_enum(InT t) {
  191|       |   if constexpr(std::is_enum_v<InT>) {
  192|       |      // TODO: C++23: use std::to_underlying(in) instead
  193|       |      return static_cast<std::underlying_type_t<InT>>(t);
  194|      6|   } else {
  195|      6|      return Botan::unwrap_strong_type(t);
  196|      6|   }
  197|      6|}
_ZN5Botan12get_byte_varImEEhmT_:
   69|  42.1k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   70|  42.1k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   71|  42.1k|}
_ZN5Botan6detail9store_anyILNSt3__16endianE64206ENS0_10AutoDetectETkNS0_20unsigned_integralishEmQoosr3stdE7same_asIS4_T0_Esr3stdE7same_asIT1_S5_EEEvS6_Ph:
  711|      6|inline constexpr void store_any(T in, uint8_t out[]) {
  712|       |   // asserts that *out points to enough bytes to write into
  713|      6|   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  714|      6|}
_ZN5Botan6detail9store_anyILNSt3__16endianE64206ENS0_10AutoDetectETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENS2_4spanIhLm8EEEQsr3stdE7same_asIS4_T0_EEEvT1_OT2_:
  646|      6|inline constexpr void store_any(T in, OutR&& out_range) {
  647|      6|   store_any<endianness, T>(in, std::forward<OutR>(out_range));
  648|      6|}
_ZN5Botan6detail9store_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENS2_4spanIhLm8EEEQnt15custom_storableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEEvS9_OT1_:
  525|      6|inline constexpr void store_any(WrappedInT wrapped_in, OutR&& out_range) {
  526|      6|   const auto in = detail::unwrap_strong_type_or_enum(wrapped_in);
  527|      6|   using InT = decltype(in);
  528|      6|   ranges::assert_exact_byte_length<sizeof(in)>(out_range);
  529|      6|   const std::span out{out_range};
  530|       |
  531|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  532|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  533|       |   // in a `constexpr` context.
  534|      6|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (534:7): [Folded, False: 6]
  ------------------
  535|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  536|      6|   } else {
  537|       |      if constexpr(sizeof(InT) == 1) {
  538|       |         out[0] = static_cast<uint8_t>(in);
  539|       |      } else if constexpr(endianness == std::endian::native) {
  540|       |         typecast_copy(out, in);
  541|      6|      } else {
  542|      6|         static_assert(opposite(endianness) == std::endian::native);
  543|      6|         typecast_copy(out, reverse_bytes(in));
  544|      6|      }
  545|      6|   }
  546|      6|}
_ZN5Botan8store_beINS_6detail10AutoDetectEJRKmPhEEEDaDpOT0_:
  745|      6|inline constexpr auto store_be(ParamTs&&... params) {
  746|      6|   return detail::store_any<std::endian::big, ModifierT>(std::forward<ParamTs>(params)...);
  747|      6|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  1.20k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  1.20k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  1.20k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  1.20k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  1.20k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  1.20k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  1.20k|      } else {
  289|  1.20k|         const std::span in{in_range};
  290|  1.20k|         if constexpr(sizeof(OutT) == 1) {
  291|  1.20k|            return static_cast<OutT>(in[0]);
  292|  1.20k|         } else if constexpr(endianness == std::endian::native) {
  293|  1.20k|            return typecast_copy<OutT>(in);
  294|  1.20k|         } else {
  295|  1.20k|            static_assert(opposite(endianness) == std::endian::native);
  296|  1.20k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  1.20k|         }
  298|  1.20k|      }
  299|  1.20k|   }());
  300|  1.20k|}
_ZN5Botan6detail24wrap_strong_type_or_enumITkNS0_20unsigned_integralishEmTkNSt3__117unsigned_integralEmEEDaT0_:
  200|  16.6k|constexpr auto wrap_strong_type_or_enum(T t) {
  201|       |   if constexpr(std::is_enum_v<OutT>) {
  202|       |      return static_cast<OutT>(t);
  203|  16.6k|   } else {
  204|  16.6k|      return Botan::wrap_strong_type<OutT>(t);
  205|  16.6k|   }
  206|  16.6k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  1.20k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  1.20k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 1.20k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  1.20k|      } else {
  289|  1.20k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  1.20k|         } else {
  295|  1.20k|            static_assert(opposite(endianness) == std::endian::native);
  296|  1.20k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  1.20k|         }
  298|  1.20k|      }
  299|  1.20k|   }());
_ZN5Botan7load_beImJNSt3__14spanIKhLm8EEEEEEDaDpOT0_:
  504|  1.20k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  1.20k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  1.20k|}
_ZN5Botan7load_beImJRNSt3__15arrayIhLm8EEEEEEDaDpOT0_:
  504|  15.4k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  15.4k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  15.4k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  15.4k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  15.4k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  15.4k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  15.4k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  15.4k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  15.4k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  15.4k|      } else {
  289|  15.4k|         const std::span in{in_range};
  290|  15.4k|         if constexpr(sizeof(OutT) == 1) {
  291|  15.4k|            return static_cast<OutT>(in[0]);
  292|  15.4k|         } else if constexpr(endianness == std::endian::native) {
  293|  15.4k|            return typecast_copy<OutT>(in);
  294|  15.4k|         } else {
  295|  15.4k|            static_assert(opposite(endianness) == std::endian::native);
  296|  15.4k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  15.4k|         }
  298|  15.4k|      }
  299|  15.4k|   }());
  300|  15.4k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  15.4k|   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
  283|       |      // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  284|       |      // internally to copy ranges on a byte-by-byte basis, which is not allowed
  285|       |      // in a `constexpr` context.
  286|  15.4k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 15.4k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  15.4k|      } else {
  289|  15.4k|         const std::span in{in_range};
  290|       |         if constexpr(sizeof(OutT) == 1) {
  291|       |            return static_cast<OutT>(in[0]);
  292|       |         } else if constexpr(endianness == std::endian::native) {
  293|       |            return typecast_copy<OutT>(in);
  294|  15.4k|         } else {
  295|  15.4k|            static_assert(opposite(endianness) == std::endian::native);
  296|  15.4k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  15.4k|         }
  298|  15.4k|      }
  299|  15.4k|   }());

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

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

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

_ZN5Botan17is_sub_element_ofERKNS_3OIDESt16initializer_listIjE:
   20|  22.1k|inline std::optional<uint32_t> is_sub_element_of(const OID& oid, std::initializer_list<uint32_t> prefix) {
   21|  22.1k|   const auto& c = oid.get_components();
   22|       |
   23|  22.1k|   if(c.size() != prefix.size() + 1) {
  ------------------
  |  Branch (23:7): [True: 9.51k, False: 12.6k]
  ------------------
   24|  9.51k|      return {};
   25|  9.51k|   }
   26|       |
   27|  12.6k|   if(!std::equal(c.begin(), c.end() - 1, prefix.begin(), prefix.end())) {
  ------------------
  |  Branch (27:7): [True: 414, False: 12.2k]
  ------------------
   28|    414|      return {};
   29|    414|   }
   30|       |
   31|  12.2k|   return c[c.size() - 1];
   32|  12.6k|}

_ZN5Botan11ASN1_ObjectD2Ev:
  122|   162k|      virtual ~ASN1_Object() = default;
_ZNK5Botan10BER_Object6is_setEv:
  138|   335k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|   142k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|   142k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|   158k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  25.1k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|  13.6k|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|  3.85M|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|  7.93M|      size_t length() const { return m_value.size(); }
_ZNK5Botan10BER_Object4dataEv:
  154|  49.6k|      std::span<const uint8_t> data() const { return std::span{m_value}; }
_ZN5Botan10BER_Object12mutable_bitsEm:
  171|   120k|      uint8_t* mutable_bits(size_t length) {
  172|   120k|         m_value.resize(length);
  173|   120k|         return m_value.data();
  174|   120k|      }
_ZNK5Botan3OIDeqERKS0_:
  301|  12.3k|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan3OID14get_componentsEv:
  321|  74.1k|      const std::vector<uint32_t>& get_components() const {
  322|  74.1k|         return m_id;
  323|  74.1k|      }
_ZNK5Botan11ASN1_String5valueEv:
  365|    369|      const std::string& value() const { return m_utf8_str; }
_ZNK5Botan19AlgorithmIdentifier3oidEv:
  407|  5.78k|      const OID& oid() const { return m_oid; }
_ZNK5Botan19AlgorithmIdentifier10parametersEv:
  409|    392|      const std::vector<uint8_t>& parameters() const { return m_parameters; }
_ZNK5Botan19AlgorithmIdentifier20parameters_are_emptyEv:
  419|  5.54k|      bool parameters_are_empty() const { return m_parameters.empty(); }
_ZNK5Botan19AlgorithmIdentifier28parameters_are_null_or_emptyEv:
  421|  5.54k|      bool parameters_are_null_or_empty() const { return parameters_are_empty() || parameters_are_null(); }
  ------------------
  |  Branch (421:58): [True: 4.68k, False: 857]
  |  Branch (421:84): [True: 661, False: 196]
  ------------------
_ZN5BotanorENS_10ASN1_ClassES0_:
   78|  54.3k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   79|  54.3k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   80|  54.3k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|   142k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|   142k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|   142k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  22.0k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  22.0k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  22.0k|}
_ZN5BotanneERKNS_3OIDES2_:
  342|  2.89k|inline bool operator!=(const OID& a, const OID& b) {
  343|  2.89k|   return !(a == b);
  344|  2.89k|}
_ZN5Botan11ASN1_ObjectC2Ev:
  117|  96.5k|      ASN1_Object() = default;
_ZN5Botan19AlgorithmIdentifierC2Ev:
  399|  6.66k|      AlgorithmIdentifier() = default;
_ZN5Botan3OIDC2Ev:
  220|  22.5k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectC2EOS0_:
  120|  30.4k|      ASN1_Object(ASN1_Object&&) = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  135|  48.0k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|  35.4k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan10BER_ObjectC2Ev:
  130|   204k|      BER_Object() = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  133|  70.0k|      BER_Object(BER_Object&& other) = default;

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

_ZN5Botan13ignore_paramsIJPKmmEEEvDpRKT_:
  142|  56.0k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJjEEEvDpRKT_:
  142|    169|constexpr void ignore_params([[maybe_unused]] const T&... args) {}

_ZN5Botan11BER_Decoder6Limits3DEREv:
   35|  9.97k|            static Limits DER() { return Limits(false, 0); }
_ZN5Botan11BER_Decoder6LimitsC2Ebm:
   54|  9.97k|                  m_allow_ber(allow_ber), m_max_nested_indef(max_nested_indef) {}
_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  285|  3.08k|      BER_Decoder& decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value = T()) {
  286|  3.08k|         std::optional<T> optval;
  287|  3.08k|         this->decode_optional(optval, type_tag, class_tag);
  288|  3.08k|         out = optval ? *optval : default_value;
  ------------------
  |  Branch (288:16): [True: 2.93k, False: 152]
  ------------------
  289|  3.08k|         return (*this);
  290|  3.08k|      }
_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RNSt3__18optionalIT_EENS_9ASN1_TypeENS_10ASN1_ClassE:
  394|  3.08k|BER_Decoder& BER_Decoder::decode_optional(std::optional<T>& optval, ASN1_Type type_tag, ASN1_Class class_tag) {
  395|  3.08k|   BER_Object obj = get_next_object();
  396|       |
  397|  3.08k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (397:7): [True: 3.05k, False: 32]
  ------------------
  398|  3.05k|      T out{};
  399|  3.05k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (399:10): [True: 0, False: 3.05k]
  ------------------
  400|      0|         BER_Decoder(obj, m_limits).decode(out).verify_end();
  401|  3.05k|      } else {
  402|  3.05k|         this->push_back(std::move(obj));
  403|  3.05k|         this->decode(out, type_tag, class_tag);
  404|  3.05k|      }
  405|  3.05k|      optval = std::move(out);
  406|  3.05k|   } else {
  407|     32|      this->push_back(std::move(obj));
  408|     32|      optval = std::nullopt;
  409|     32|   }
  410|       |
  411|  3.08k|   return (*this);
  412|  3.08k|}
_ZN5Botan11BER_Decoder6decodeERm:
  225|     48|      BER_Decoder& decode(size_t& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZNK5Botan11BER_Decoder6limitsEv:
   98|  57.0k|      Limits limits() const { return m_limits; }
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectENS0_6LimitsE:
   81|    171|            BER_Decoder(obj.data(), limits) {}
_ZNK5Botan11BER_Decoder6Limits18allow_ber_encodingEv:
   44|   273k|            bool allow_ber_encoding() const { return m_allow_ber; }
_ZNK5Botan11BER_Decoder6Limits20require_der_encodingEv:
   46|   152k|            bool require_der_encoding() const { return !allow_ber_encoding(); }
_ZN5Botan11BER_Decoder14start_sequenceEv:
  160|  51.3k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9start_setEv:
  162|  3.18k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  230|  9.55k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  242|  15.8k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  243|  15.8k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  244|  15.8k|      }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EE:
  203|  12.1k|      BER_Decoder& raw_bytes(std::vector<uint8_t, Alloc>& out) {
  204|  12.1k|         out.clear();
  205|  3.49M|         for(;;) {
  206|  3.49M|            if(auto next = this->read_next_byte()) {
  ------------------
  |  Branch (206:21): [True: 3.48M, False: 12.1k]
  ------------------
  207|  3.48M|               out.push_back(*next);
  208|  3.48M|            } else {
  209|  12.1k|               break;
  210|  12.1k|            }
  211|  3.49M|         }
  212|  12.1k|         return (*this);
  213|  12.1k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  285|  12.6k|      BER_Decoder& decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value = T()) {
  286|  12.6k|         std::optional<T> optval;
  287|  12.6k|         this->decode_optional(optval, type_tag, class_tag);
  288|  12.6k|         out = optval ? *optval : default_value;
  ------------------
  |  Branch (288:16): [True: 0, False: 12.6k]
  ------------------
  289|  12.6k|         return (*this);
  290|  12.6k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RNSt3__18optionalIT_EENS_9ASN1_TypeENS_10ASN1_ClassE:
  394|  12.6k|BER_Decoder& BER_Decoder::decode_optional(std::optional<T>& optval, ASN1_Type type_tag, ASN1_Class class_tag) {
  395|  12.6k|   BER_Object obj = get_next_object();
  396|       |
  397|  12.6k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (397:7): [True: 0, False: 12.6k]
  ------------------
  398|      0|      T out{};
  399|      0|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (399:10): [True: 0, False: 0]
  ------------------
  400|      0|         BER_Decoder(obj, m_limits).decode(out).verify_end();
  401|      0|      } else {
  402|      0|         this->push_back(std::move(obj));
  403|      0|         this->decode(out, type_tag, class_tag);
  404|      0|      }
  405|      0|      optval = std::move(out);
  406|  12.6k|   } else {
  407|  12.6k|      this->push_back(std::move(obj));
  408|  12.6k|      optval = std::nullopt;
  409|  12.6k|   }
  410|       |
  411|  12.6k|   return (*this);
  412|  12.6k|}
_ZN5Botan11BER_Decoder22decode_optional_stringINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeEjNS_10ASN1_ClassE:
  345|     46|                                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  346|     46|         BER_Object obj = get_next_object();
  347|       |
  348|     46|         const ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
  349|       |
  350|     46|         if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (350:13): [True: 46, False: 0]
  ------------------
  351|     46|            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (351:16): [True: 0, False: 46]
  ------------------
  352|      0|               BER_Decoder(obj, m_limits).decode(out, real_type).verify_end();
  353|     46|            } else {
  354|     46|               push_back(std::move(obj));
  355|     46|               decode(out, real_type, type_tag, class_tag);
  356|     46|            }
  357|     46|         } else {
  358|      0|            out.clear();
  359|      0|            push_back(std::move(obj));
  360|      0|         }
  361|       |
  362|     46|         return (*this);
  363|     46|      }

_ZN5Botan6BigIntC2Ev:
   45|  15.7k|      BigInt() = default;
_ZNK5Botan6BigInt9serializeINSt3__16vectorIhNS2_9allocatorIhEEEEEET_v:
  760|  9.51k|      T serialize() const {
  761|  9.51k|         return serialize<T>(this->bytes());
  762|  9.51k|      }
_ZNK5Botan6BigInt9serializeINSt3__16vectorIhNS2_9allocatorIhEEEEEET_m:
  747|  9.51k|      T serialize(size_t len) const {
  748|       |         // TODO this supports std::vector and secure_vector
  749|       |         // it would be nice if this also could work with std::array as in
  750|       |         //   bn.serialize_to<std::array<uint8_t, 32>>(32);
  751|  9.51k|         T out(len);
  752|  9.51k|         this->serialize_to(out);
  753|  9.51k|         return out;
  754|  9.51k|      }
_ZNK5Botan6BigInt6signumEv:
  467|  5.93k|      int signum() const {
  468|  5.93k|         if(sig_words() == 0) {
  ------------------
  |  Branch (468:13): [True: 7, False: 5.93k]
  ------------------
  469|      7|            return 0;
  470|      7|         }
  471|  5.93k|         return (sign() == Negative) ? -1 : 1;
  ------------------
  |  Branch (471:17): [True: 66, False: 5.86k]
  ------------------
  472|  5.93k|      }
_ZNK5Botan6BigInt9sig_wordsEv:
  648|  55.8k|      size_t sig_words() const { return m_data.sig_words(); }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
 1102|  55.8k|            size_t sig_words() const {
 1103|  55.8k|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (1103:19): [True: 15.4k, False: 40.4k]
  ------------------
 1104|  15.4k|                  m_sig_words = calc_sig_words();
 1105|  15.4k|               }
 1106|  55.8k|               return m_sig_words;
 1107|  55.8k|            }
_ZNK5Botan6BigInt4signEv:
  604|  6.06k|      Sign sign() const { return (m_signedness); }
_ZN5Botan6BigIntD2Ev:
  185|  15.7k|      ~BigInt() { _const_time_unpoison(); }
_ZN5Botan6BigInt5clearEv:
  415|  15.4k|      void clear() {
  416|  15.4k|         m_data.set_to_zero();
  417|  15.4k|         m_signedness = Positive;
  418|  15.4k|      }
_ZNK5Botan6BigInt7is_zeroEv:
  484|    134|      bool is_zero() const { return sig_words() == 0; }
_ZNK5Botan6BigInt7word_atEm:
  574|  57.7k|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZNK5Botan6BigInt12reverse_signEv:
  609|    134|      Sign reverse_sign() const {
  610|    134|         if(sign() == Positive) {
  ------------------
  |  Branch (610:13): [True: 134, False: 0]
  ------------------
  611|    134|            return Negative;
  612|    134|         }
  613|      0|         return Positive;
  614|    134|      }
_ZN5Botan6BigInt9flip_signEv:
  619|    134|      BOTAN_DEPRECATED("Deprecated no replacement") void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  625|    134|      void set_sign(Sign sign) {
  626|    134|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (626:13): [True: 134, False: 0]
  |  Branch (626:33): [True: 0, False: 134]
  ------------------
  627|      0|            sign = Positive;
  628|      0|         }
  629|       |
  630|    134|         m_signedness = sign;
  631|    134|      }
_ZN5Botan6BigInt18_assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  983|  15.4k|      void _assign_from_bytes(std::span<const uint8_t> bytes) { assign_from_bytes(bytes); }
_ZNK5Botan6BigInt4Data10const_dataEv:
 1027|  15.7k|            const word* const_data() const { return m_reg.data(); }
_ZNK5Botan6BigInt4Data11get_word_atEm:
 1038|  57.7k|            word get_word_at(size_t n) const {
 1039|  57.7k|               if(n < m_reg.size()) {
  ------------------
  |  Branch (1039:19): [True: 57.7k, False: 0]
  ------------------
 1040|  57.7k|                  return m_reg[n];
 1041|  57.7k|               }
 1042|      0|               return 0;
 1043|  57.7k|            }
_ZNK5Botan6BigInt4Data4sizeEv:
 1075|  15.7k|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
 1095|  15.4k|            void swap(secure_vector<word>& reg) noexcept {
 1096|  15.4k|               m_reg.swap(reg);
 1097|  15.4k|               invalidate_sig_words();
 1098|  15.4k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
 1100|  15.4k|            void invalidate_sig_words() const noexcept { m_sig_words = sig_words_npos; }

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

_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassENSt3__14spanIKhLm18446744073709551615EEE:
  184|    369|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, std::span<const uint8_t> rep) {
  185|    369|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  186|    369|      }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  188|    369|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const std::vector<uint8_t>& rep) {
  189|    369|         return add_object(type_tag, class_tag, std::span{rep});
  190|    369|      }

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

_ZN5Botan11clear_bytesEPvm:
  101|  15.6k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  102|  15.6k|   if(bytes > 0) {
  ------------------
  |  Branch (102:7): [True: 112, False: 15.4k]
  ------------------
  103|    112|      std::memset(ptr, 0, bytes);
  104|    112|   }
  105|  15.6k|}
_ZN5Botan8copy_memIhQsr3stdE12is_trivial_vIu7__decayIT_EEEEvPS1_PKS1_m:
  144|  3.97M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  145|  3.97M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |  103|  3.97M|   do {                                                                                          \
  |  |  104|  3.97M|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                              \
  |  |  105|  7.92M|      if((expr1) && !(expr2)) {                                                                  \
  |  |  ------------------
  |  |  |  Branch (105:10): [True: 3.96M, False: 12.9k]
  |  |  |  Branch (105:23): [True: 3.96M, False: 0]
  |  |  |  Branch (105:23): [True: 3.96M, False: 0]
  |  |  ------------------
  |  |  106|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                     \
  |  |  107|      0|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |  108|      0|      }                                                                                          \
  |  |  109|  3.97M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (109:12): [Folded, False: 3.97M]
  |  |  ------------------
  ------------------
  146|       |
  147|  3.97M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (147:7): [True: 3.97M, False: 133]
  |  Branch (147:24): [True: 3.97M, False: 334]
  |  Branch (147:42): [True: 3.96M, False: 12.4k]
  ------------------
  148|  3.96M|      std::memmove(out, in, sizeof(T) * n);
  149|  3.96M|   }
  150|  3.97M|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__15arrayIhLm8EEETkNS1_16contiguous_rangeENS3_ImLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  1.10k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  1.10k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.10k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.10k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERKNSt3__14spanIhLm8EEETkNS1_16contiguous_rangeENS3_IKmLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISG_EESH_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS9_IXsr21__is_primary_templateINSA_Iu14__remove_cvrefIDTclL_ZNSC_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSI_ISQ_EESR_E4type10value_typeEEEEvOSN_RKSD_:
  176|      6|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|      6|   ranges::assert_equal_byte_lengths(out, in);
  178|      6|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|      6|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERKNSt3__14spanIhLm8EEEmQaaaasr3stdE23is_trivially_copyable_vIT0_Entsr3std6rangesE5rangeIS7_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEEEvOSC_RKS7_:
  199|      6|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromT& in) {
  200|      6|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|      6|}
_ZN5Botan19secure_scrub_memoryITkNS_6ranges23contiguous_output_rangeERNSt3__16vectorIhNS2_9allocatorIhEEEEEEvOT_:
   59|   274k|void secure_scrub_memory(ranges::contiguous_output_range auto&& data) {
   60|   274k|   secure_scrub_memory(std::ranges::data(data), ranges::size_bytes(data));
   61|   274k|}
_ZN5Botan9clear_memIhEEvPT_m:
  118|    152|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|    152|   clear_bytes(ptr, sizeof(T) * n);
  120|    152|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  1.20k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  1.20k|   ToT dst;  // NOLINT(*-member-init)
  212|  1.20k|   typecast_copy(dst, src);
  213|  1.20k|   return dst;
  214|  1.20k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  1.20k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  1.20k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.20k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IKhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  1.20k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  1.20k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.20k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.20k|}
_ZN5Botan9clear_memImEEvPT_m:
  118|  15.4k|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|  15.4k|   clear_bytes(ptr, sizeof(T) * n);
  120|  15.4k|}
_ZN5Botan8copy_memITkNS_6ranges23contiguous_output_rangeENSt3__14spanIhLm18446744073709551615EEETkNS1_16contiguous_rangeENS3_IKhLm18446744073709551615EEEQaasr3stdE9is_same_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeENS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIST_EEEvOSB_RKSL_:
  160|  15.4k|inline constexpr void copy_mem(OutR&& out /* NOLINT(*-std-forward) */, const InR& in) {
  161|  15.4k|   ranges::assert_equal_byte_lengths(out, in);
  162|  15.4k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (162:7): [Folded, False: 15.4k]
  ------------------
  163|      0|      std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
  164|  15.4k|   } else if(ranges::size_bytes(out) > 0) {
  ------------------
  |  Branch (164:14): [True: 15.4k, False: 0]
  ------------------
  165|  15.4k|      std::memmove(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  166|  15.4k|   }
  167|  15.4k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS5_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEEES5_RKSA_:
  210|  15.4k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  15.4k|   ToT dst;  // NOLINT(*-member-init)
  212|  15.4k|   typecast_copy(dst, src);
  213|  15.4k|   return dst;
  214|  15.4k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISC_EESD_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISJ_EEEvRSJ_RKS9_:
  188|  15.4k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  15.4k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  15.4k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS6_IXsr21__is_primary_templateINS7_Iu14__remove_cvrefIDTclL_ZNS9_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSF_ISN_EESO_E4type10value_typeEEEEvOSK_RKSA_:
  176|  15.4k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  15.4k|   ranges::assert_equal_byte_lengths(out, in);
  178|  15.4k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  15.4k|}

_ZN5Botan7X509_DNC2Ev:
   48|  3.08k|      X509_DN() = default;
_ZN5Botan10ExtensionsC2Ev:
  871|  12.6k|      Extensions() = default;
_ZNK5Botan10Extensions30has_unknown_critical_extensionEv:
  789|  9.53k|      bool has_unknown_critical_extension() const { return m_has_unknown_critical_extension; }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension10CRL_NumberEEEPKT_RKNS_3OIDE:
  737|     50|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  738|     50|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (738:42): [True: 48, False: 2]
  ------------------
  739|       |            // Unknown_Extension oid_name is empty
  740|     48|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (740:16): [True: 3, False: 45]
  ------------------
  741|      3|               return nullptr;
  742|     45|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (742:32): [True: 45, False: 0]
  ------------------
  743|     45|               return extn_as_T;
  744|     45|            } else {
  745|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  746|      0|            }
  747|     48|         }
  748|       |
  749|      2|         return nullptr;
  750|     50|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Authority_Key_IDEEEPKT_RKNS_3OIDE:
  737|     50|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  738|     50|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (738:42): [True: 47, False: 3]
  ------------------
  739|       |            // Unknown_Extension oid_name is empty
  740|     47|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (740:16): [True: 1, False: 46]
  ------------------
  741|      1|               return nullptr;
  742|     46|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (742:32): [True: 46, False: 0]
  ------------------
  743|     46|               return extn_as_T;
  744|     46|            } else {
  745|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  746|      0|            }
  747|     47|         }
  748|       |
  749|      3|         return nullptr;
  750|     50|      }
_ZN5Botan10ExtensionsD2Ev:
  879|  12.6k|      ~Extensions() override = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension30CRL_Issuing_Distribution_PointEEEPKT_RKNS_3OIDE:
  737|     50|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  738|     50|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (738:42): [True: 0, False: 50]
  ------------------
  739|       |            // Unknown_Extension oid_name is empty
  740|      0|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (740:16): [True: 0, False: 0]
  ------------------
  741|      0|               return nullptr;
  742|      0|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (742:32): [True: 0, False: 0]
  ------------------
  743|      0|               return extn_as_T;
  744|      0|            } else {
  745|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  746|      0|            }
  747|      0|         }
  748|       |
  749|     50|         return nullptr;
  750|     50|      }
_ZN5Botan10Extensions15Extensions_InfoC2EbRKNSt3__16vectorIhNS2_9allocatorIhEEEENS2_10unique_ptrINS_21Certificate_ExtensionENS2_14default_deleteISA_EEEE:
  895|  12.6k|                  m_obj(std::move(ext)), m_bits(encoding), m_critical(critical) {}
_ZN5Botan21Certificate_ExtensionD2Ev:
  711|  12.9k|      virtual ~Certificate_Extension() = default;
_ZN5Botan15AlternativeNameC2Ev:
  211|      4|      AlternativeName() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension14CRL_ReasonCodeEEEPKT_RKNS_3OIDE:
  737|  9.48k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  738|  9.48k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (738:42): [True: 3.05k, False: 6.42k]
  ------------------
  739|       |            // Unknown_Extension oid_name is empty
  740|  3.05k|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (740:16): [True: 222, False: 2.83k]
  ------------------
  741|    222|               return nullptr;
  742|  2.83k|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (742:32): [True: 2.83k, False: 0]
  ------------------
  743|  2.83k|               return extn_as_T;
  744|  2.83k|            } else {
  745|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  746|      0|            }
  747|  3.05k|         }
  748|       |
  749|  6.42k|         return nullptr;
  750|  9.48k|      }

_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJNS3_IKhLm18446744073709551615EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  15.4k|{
  101|  15.4k|   const std::span s0{r0};
  102|       |
  103|       |   if constexpr(statically_spanable_range<R0>) {
  104|       |      constexpr size_t expected_size = s0.size_bytes();
  105|       |      (assert_exact_byte_length<expected_size>(rs), ...);
  106|  15.4k|   } else {
  107|  15.4k|      const size_t expected_size = s0.size_bytes();
  108|  15.4k|      const bool correct_size =
  109|  15.4k|         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|  15.4k|      if(!correct_size) {
  ------------------
  |  Branch (111:10): [True: 0, False: 15.4k]
  ------------------
  112|      0|         memory_region_size_violation();
  113|      0|      }
  114|  15.4k|   }
  115|  15.4k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__15arrayIhLm8EEETpTkNS0_14spanable_rangeEJNS3_ImLm1EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  2.21k|{
  101|  2.21k|   const std::span s0{r0};
  102|       |
  103|  2.21k|   if constexpr(statically_spanable_range<R0>) {
  104|  2.21k|      constexpr size_t expected_size = s0.size_bytes();
  105|  2.21k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  2.21k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayImLm1EEEEEvRKT0_:
   77|  2.21k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.21k|   const std::span s{r};
   79|  2.21k|   if constexpr(statically_spanable_range<R>) {
   80|  2.21k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.21k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEmRKT_:
   59|  1.10k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  1.10k|   return std::span{r}.size_bytes();
   61|  1.10k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEvRKT0_:
   77|  15.4k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  15.4k|   const std::span s{r};
   79|  15.4k|   if constexpr(statically_spanable_range<R>) {
   80|  15.4k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  15.4k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKmLm1EEEEEvRKT0_:
   77|      6|inline constexpr void assert_exact_byte_length(const R& r) {
   78|      6|   const std::span s{r};
   79|      6|   if constexpr(statically_spanable_range<R>) {
   80|      6|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|      6|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm8EEETpTkNS0_14spanable_rangeEJNS3_IKmLm1EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|      6|{
  101|      6|   const std::span s0{r0};
  102|       |
  103|      6|   if constexpr(statically_spanable_range<R0>) {
  104|      6|      constexpr size_t expected_size = s0.size_bytes();
  105|      6|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|      6|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEmRKT_:
   59|      6|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|      6|   return std::span{r}.size_bytes();
   61|      6|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__16vectorIhNS2_9allocatorIhEEEEEEmRKT_:
   59|   274k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|   274k|   return std::span{r}.size_bytes();
   61|   274k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEEEEmRKT_:
   59|  30.8k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  30.8k|   return std::span{r}.size_bytes();
   61|  30.8k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKhLm8EEEEEvRKT0_:
   77|  2.41k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.41k|   const std::span s{r};
   79|  2.41k|   if constexpr(statically_spanable_range<R>) {
   80|  2.41k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.41k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  1.20k|{
  101|  1.20k|   const std::span s0{r0};
  102|       |
  103|  1.20k|   if constexpr(statically_spanable_range<R0>) {
  104|  1.20k|      constexpr size_t expected_size = s0.size_bytes();
  105|  1.20k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  1.20k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanImLm1EEEEEmRKT_:
   59|  16.6k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  16.6k|   return std::span{r}.size_bytes();
   61|  16.6k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEvRKT0_:
   77|  15.4k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  15.4k|   const std::span s{r};
   79|  15.4k|   if constexpr(statically_spanable_range<R>) {
   80|  15.4k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  15.4k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  15.4k|{
  101|  15.4k|   const std::span s0{r0};
  102|       |
  103|  15.4k|   if constexpr(statically_spanable_range<R0>) {
  104|  15.4k|      constexpr size_t expected_size = s0.size_bytes();
  105|  15.4k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  15.4k|}

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

_ZN5Botan18unwrap_strong_typeIRmEEDcOT_:
  243|      6|[[nodiscard]] constexpr decltype(auto) unwrap_strong_type(T&& t) {
  244|      6|   if constexpr(!concepts::strong_type<std::remove_cvref_t<T>>) {
  245|       |      // If the parameter type isn't a strong type, return it as is.
  246|      6|      return std::forward<T>(t);
  247|       |   } else {
  248|       |      // Unwrap the strong type and return the underlying value.
  249|       |      return std::forward<T>(t).get();
  250|       |   }
  251|      6|}
_ZN5Botan16wrap_strong_typeImRmQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  268|  16.6k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  269|  16.6k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  270|       |      // Noop, if the parameter type already is the desired return type.
  271|  16.6k|      return std::forward<ParamT>(t);
  272|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  273|       |      // Implicit conversion from the parameter type to the return type.
  274|       |      return T{std::forward<ParamT>(t)};
  275|       |   } else {
  276|       |      // Explicitly calling the wrapped type's constructor to support
  277|       |      // implicit conversions on types that mark their constructors as explicit.
  278|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  279|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  280|       |   }
  281|  16.6k|}

_ZN5Botan9CRL_EntryC2Ev:
   61|  9.55k|      CRL_Entry() = default;

_ZN5Botan14Cert_Extension10CRL_Number10static_oidEv:
  406|     50|      static OID static_oid() { return OID({2, 5, 29, 20}); }
_ZN5Botan14Cert_Extension16Authority_Key_ID10static_oidEv:
  152|     50|      static OID static_oid() { return OID({2, 5, 29, 35}); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID10get_key_idEv:
  150|     46|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point10static_oidEv:
  522|     50|      static OID static_oid() { return OID({2, 5, 29, 28}); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID8oid_nameEv:
  157|     73|      std::string oid_name() const override { return "X509v3.AuthorityKeyIdentifier"; }
_ZN5Botan14Cert_Extension10CRL_NumberC2Ev:
  400|     49|      CRL_Number() : m_has_value(false), m_crl_number(0) {}
_ZNK5Botan14Cert_Extension10CRL_Number8oid_nameEv:
  411|     46|      std::string oid_name() const override { return "X509v3.CRLNumber"; }
_ZN5Botan14Cert_Extension14CRL_ReasonCodeC2ENS_8CRL_CodeE:
  433|  3.05k|      explicit CRL_ReasonCode(CRL_Code r = CRL_Code::Unspecified) : m_reason(r) {}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode10get_reasonEv:
  435|  2.83k|      CRL_Code get_reason() const { return m_reason; }
_ZN5Botan14Cert_Extension14CRL_ReasonCode10static_oidEv:
  437|  9.48k|      static OID static_oid() { return OID({2, 5, 29, 21}); }
_ZNK5Botan14Cert_Extension14CRL_ReasonCode8oid_nameEv:
  442|  2.83k|      std::string oid_name() const override { return "X509v3.ReasonCode"; }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_PointC2ERKNS_15AlternativeNameE:
  465|      4|            explicit Distribution_Point(const AlternativeName& name = AlternativeName()) : m_point(name) {}
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point8oid_nameEv:
  527|      4|      std::string oid_name() const override { return "X509v3.CRLIssuingDistributionPoint"; }
_ZN5Botan14Cert_Extension12OCSP_NoCheck10static_oidEv:
  556|  9.50k|      static OID static_oid() { return OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 5}); }
_ZN5Botan14Cert_Extension17Unknown_ExtensionC2ERKNS_3OIDEbb:
 1038|  9.72k|            m_oid(oid), m_critical(critical), m_failed_to_decode(failed_to_decode) {}
_ZNK5Botan14Cert_Extension17Unknown_Extension8oid_nameEv:
 1080|    226|      std::string oid_name() const override { return ""; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_PointC2Ev:
  511|      4|      CRL_Issuing_Distribution_Point() = default;
_ZN5Botan14Cert_Extension16Authority_Key_IDC2Ev:
  146|     74|      Authority_Key_ID() = default;

_ZN5Botan11X509_ObjectC2Ev:
  120|  4.06k|      X509_Object() = default;

_Z4fuzzNSt3__14spanIKhLm18446744073709551615EEE:
   12|  4.06k|void fuzz(std::span<const uint8_t> in) {
   13|  4.06k|   try {
   14|  4.06k|      Botan::DataSource_Memory input(in);
   15|  4.06k|      const Botan::X509_CRL crl(input);
   16|  4.06k|   } catch(const Botan::Exception& e) {}
   17|  4.06k|}

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

_ZNK5Botan19AlgorithmIdentifier19parameters_are_nullEv:
   49|    857|bool AlgorithmIdentifier::parameters_are_null() const {
   50|    857|   return (m_parameters.size() == 2 && (m_parameters[0] == 0x05) && (m_parameters[1] == 0x00));
  ------------------
  |  Branch (50:12): [True: 847, False: 10]
  |  Branch (50:40): [True: 823, False: 24]
  |  Branch (50:69): [True: 661, False: 162]
  ------------------
   51|    857|}
_ZN5BotaneqERKNS_19AlgorithmIdentifierES2_:
   53|  2.89k|bool operator==(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   54|  2.89k|   if(a1.oid() != a2.oid()) {
  ------------------
  |  Branch (54:7): [True: 38, False: 2.85k]
  ------------------
   55|     38|      return false;
   56|     38|   }
   57|       |
   58|       |   /*
   59|       |   * Treat NULL and empty as equivalent
   60|       |   */
   61|  2.85k|   if(a1.parameters_are_null_or_empty() && a2.parameters_are_null_or_empty()) {
  ------------------
  |  Branch (61:7): [True: 2.68k, False: 171]
  |  Branch (61:44): [True: 2.66k, False: 25]
  ------------------
   62|  2.66k|      return true;
   63|  2.66k|   }
   64|       |
   65|    196|   return (a1.parameters() == a2.parameters());
   66|  2.85k|}
_ZN5BotanneERKNS_19AlgorithmIdentifierES2_:
   68|  2.89k|bool operator!=(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   69|  2.89k|   return !(a1 == a2);
   70|  2.89k|}
_ZN5Botan19AlgorithmIdentifier11decode_fromERNS_11BER_DecoderE:
   82|  6.21k|void AlgorithmIdentifier::decode_from(BER_Decoder& codec) {
   83|  6.21k|   codec.start_sequence().decode(m_oid).raw_bytes(m_parameters).end_cons();
   84|  6.21k|}

_ZNK5Botan11ASN1_Object10BER_encodeEv:
   20|    369|std::vector<uint8_t> ASN1_Object::BER_encode() const {
   21|    369|   std::vector<uint8_t> output;
   22|    369|   DER_Encoder der(output);
   23|    369|   this->encode_into(der);
   24|    369|   return output;
   25|    369|}
_ZN5Botan10BER_ObjectD2Ev:
   27|   274k|BER_Object::~BER_Object() {
   28|   274k|   secure_scrub_memory(m_value);
   29|   274k|}
_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   34|  85.8k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   35|  85.8k|   if(!this->is_a(expected_type_tag, expected_class_tag)) {
  ------------------
  |  Branch (35:7): [True: 416, False: 85.4k]
  ------------------
   36|    416|      std::stringstream msg;
   37|       |
   38|    416|      msg << "Tag mismatch when decoding " << descr << " got ";
   39|       |
   40|    416|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (40:10): [True: 60, False: 356]
  |  Branch (40:49): [True: 60, False: 0]
  ------------------
   41|     60|         msg << "EOF";
   42|    356|      } else {
   43|    356|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (43:13): [True: 197, False: 159]
  |  Branch (43:53): [True: 118, False: 41]
  ------------------
   44|    315|            msg << asn1_tag_to_string(m_type_tag);
   45|    315|         } else {
   46|     41|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   47|     41|         }
   48|       |
   49|    356|         msg << "/" << asn1_class_to_string(m_class_tag);
   50|    356|      }
   51|       |
   52|    416|      msg << " expected ";
   53|       |
   54|    416|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (54:10): [True: 227, False: 189]
  |  Branch (54:57): [True: 189, False: 0]
  ------------------
   55|    416|         msg << asn1_tag_to_string(expected_type_tag);
   56|    416|      } else {
   57|      0|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   58|      0|      }
   59|       |
   60|    416|      msg << "/" << asn1_class_to_string(expected_class_tag);
   61|       |
   62|    416|      throw BER_Decoding_Error(msg.str());
   63|    416|   }
   64|  85.8k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   66|   101k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   67|   101k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (67:12): [True: 88.8k, False: 13.1k]
  |  Branch (67:47): [True: 88.8k, False: 4]
  ------------------
   68|   101k|}
_ZNK5Botan10BER_Object4is_aEiNS_10ASN1_ClassE:
   70|     96|bool BER_Object::is_a(int expected_type_tag, ASN1_Class expected_class_tag) const {
   71|     96|   return is_a(ASN1_Type(expected_type_tag), expected_class_tag);
   72|     96|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   74|   121k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   75|   121k|   m_type_tag = type_tag;
   76|   121k|   m_class_tag = class_tag;
   77|   121k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   79|    772|std::string asn1_class_to_string(ASN1_Class type) {
   80|    772|   switch(type) {
   81|    424|      case ASN1_Class::Universal:
  ------------------
  |  Branch (81:7): [True: 424, False: 348]
  ------------------
   82|    424|         return "UNIVERSAL";
   83|    307|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (83:7): [True: 307, False: 465]
  ------------------
   84|    307|         return "CONSTRUCTED";
   85|      4|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (85:7): [True: 4, False: 768]
  ------------------
   86|      4|         return "CONTEXT_SPECIFIC";
   87|      5|      case ASN1_Class::Application:
  ------------------
  |  Branch (87:7): [True: 5, False: 767]
  ------------------
   88|      5|         return "APPLICATION";
   89|      2|      case ASN1_Class::Private:
  ------------------
  |  Branch (89:7): [True: 2, False: 770]
  ------------------
   90|      2|         return "PRIVATE";
   91|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (91:7): [True: 0, False: 772]
  ------------------
   92|      0|         return "NO_OBJECT";
   93|     30|      default:
  ------------------
  |  Branch (93:7): [True: 30, False: 742]
  ------------------
   94|     30|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   95|    772|   }
   96|    772|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   98|  2.67k|std::string asn1_tag_to_string(ASN1_Type type) {
   99|  2.67k|   switch(type) {
  100|    190|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (100:7): [True: 190, False: 2.48k]
  ------------------
  101|    190|         return "SEQUENCE";
  102|       |
  103|      5|      case ASN1_Type::Set:
  ------------------
  |  Branch (103:7): [True: 5, False: 2.66k]
  ------------------
  104|      5|         return "SET";
  105|       |
  106|     18|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (106:7): [True: 18, False: 2.65k]
  ------------------
  107|     18|         return "PRINTABLE STRING";
  108|       |
  109|  1.89k|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (109:7): [True: 1.89k, False: 780]
  ------------------
  110|  1.89k|         return "NUMERIC STRING";
  111|       |
  112|      3|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (112:7): [True: 3, False: 2.66k]
  ------------------
  113|      3|         return "IA5 STRING";
  114|       |
  115|      1|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (115:7): [True: 1, False: 2.67k]
  ------------------
  116|      1|         return "T61 STRING";
  117|       |
  118|     36|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (118:7): [True: 36, False: 2.63k]
  ------------------
  119|     36|         return "UTF8 STRING";
  120|       |
  121|      2|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (121:7): [True: 2, False: 2.66k]
  ------------------
  122|      2|         return "VISIBLE STRING";
  123|       |
  124|      1|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (124:7): [True: 1, False: 2.67k]
  ------------------
  125|      1|         return "BMP STRING";
  126|       |
  127|      0|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (127:7): [True: 0, False: 2.67k]
  ------------------
  128|      0|         return "UNIVERSAL STRING";
  129|       |
  130|      1|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (130:7): [True: 1, False: 2.67k]
  ------------------
  131|      1|         return "UTC TIME";
  132|       |
  133|      1|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (133:7): [True: 1, False: 2.67k]
  ------------------
  134|      1|         return "GENERALIZED TIME";
  135|       |
  136|      4|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (136:7): [True: 4, False: 2.66k]
  ------------------
  137|      4|         return "OCTET STRING";
  138|       |
  139|     55|      case ASN1_Type::BitString:
  ------------------
  |  Branch (139:7): [True: 55, False: 2.61k]
  ------------------
  140|     55|         return "BIT STRING";
  141|       |
  142|    175|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (142:7): [True: 175, False: 2.49k]
  ------------------
  143|    175|         return "ENUMERATED";
  144|       |
  145|      2|      case ASN1_Type::Integer:
  ------------------
  |  Branch (145:7): [True: 2, False: 2.66k]
  ------------------
  146|      2|         return "INTEGER";
  147|       |
  148|      1|      case ASN1_Type::Null:
  ------------------
  |  Branch (148:7): [True: 1, False: 2.67k]
  ------------------
  149|      1|         return "NULL";
  150|       |
  151|      2|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (151:7): [True: 2, False: 2.66k]
  ------------------
  152|      2|         return "OBJECT";
  153|       |
  154|      1|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (154:7): [True: 1, False: 2.67k]
  ------------------
  155|      1|         return "BOOLEAN";
  156|       |
  157|      0|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (157:7): [True: 0, False: 2.67k]
  ------------------
  158|      0|         return "NO_OBJECT";
  159|       |
  160|    282|      default:
  ------------------
  |  Branch (160:7): [True: 282, False: 2.38k]
  ------------------
  161|    282|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  162|  2.67k|   }
  163|  2.67k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  168|    991|BER_Decoding_Error::BER_Decoding_Error(std::string_view err) : Decoding_Error(fmt("BER: {}", err)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  170|     33|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  190|  12.2k|std::string to_string(const BER_Object& obj) {
  191|  12.2k|   return bytes_to_string(obj.data());
  192|  12.2k|}
_ZN5Botan4ASN19maybe_BERERNS_10DataSourceE:
  197|  4.06k|bool maybe_BER(DataSource& source) {
  198|  4.06k|   uint8_t first_u8 = 0;
  199|  4.06k|   if(source.peek_byte(first_u8) == 0) {
  ------------------
  |  Branch (199:7): [True: 0, False: 4.06k]
  ------------------
  200|      0|      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
  ------------------
  |  |   90|      0|   do {                                                                                                \
  |  |   91|      0|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                                    \
  |  |   92|      0|      if((expr1) != (expr2)) {                                                                         \
  |  |  ------------------
  |  |  |  Branch (92:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   93|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                           \
  |  |   94|      0|         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   95|      0|      }                                                                                                \
  |  |   96|      0|   } while(0)
  |  |  ------------------
  |  |  |  Branch (96:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  201|      0|      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
  202|      0|   }
  203|       |
  204|  4.06k|   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
  205|  4.06k|   return first_u8 == cons_seq;
  206|  4.06k|}

_ZN5Botan3OIDC2ESt16initializer_listIjE:
   98|  19.1k|OID::OID(std::initializer_list<uint32_t> init) : m_id(init) {
   99|  19.1k|   oid_valid_check(m_id);
  100|  19.1k|}
_ZN5BotanltERKNS_3OIDES2_:
  171|  25.9k|bool operator<(const OID& a, const OID& b) {
  172|  25.9k|   const std::vector<uint32_t>& oid1 = a.get_components();
  173|  25.9k|   const std::vector<uint32_t>& oid2 = b.get_components();
  174|       |
  175|  25.9k|   return std::lexicographical_compare(oid1.begin(), oid1.end(), oid2.begin(), oid2.end());
  176|  25.9k|}
_ZNK5Botan3OID11encode_intoERNS_11DER_EncoderE:
  181|    369|void OID::encode_into(DER_Encoder& der) const {
  182|    369|   if(m_id.size() < 2) {
  ------------------
  |  Branch (182:7): [True: 0, False: 369]
  ------------------
  183|      0|      throw Invalid_Argument("OID::encode_into: OID is invalid");
  184|      0|   }
  185|       |
  186|    369|   auto append = [](std::vector<uint8_t>& encoding, uint32_t z) {
  187|    369|      if(z <= 0x7F) {
  188|    369|         encoding.push_back(static_cast<uint8_t>(z));
  189|    369|      } else {
  190|    369|         const size_t z7 = (high_bit(z) + 7 - 1) / 7;
  191|       |
  192|    369|         for(size_t j = 0; j != z7; ++j) {
  193|    369|            uint8_t zp = static_cast<uint8_t>(z >> (7 * (z7 - j - 1)) & 0x7F);
  194|       |
  195|    369|            if(j != z7 - 1) {
  196|    369|               zp |= 0x80;
  197|    369|            }
  198|       |
  199|    369|            encoding.push_back(zp);
  200|    369|         }
  201|    369|      }
  202|    369|   };
  203|       |
  204|    369|   std::vector<uint8_t> encoding;
  205|       |
  206|       |   // We know 40 * root can't overflow because root is between 0 and 2
  207|    369|   auto first = checked_add(40 * m_id[0], m_id[1]);
  208|    369|   BOTAN_ASSERT_NOMSG(first.has_value());
  ------------------
  |  |   77|    369|   do {                                                                     \
  |  |   78|    369|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|    369|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 369]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|    369|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 369]
  |  |  ------------------
  ------------------
  209|       |
  210|    369|   append(encoding, *first);
  211|       |
  212|    986|   for(size_t i = 2; i != m_id.size(); ++i) {
  ------------------
  |  Branch (212:22): [True: 617, False: 369]
  ------------------
  213|    617|      append(encoding, m_id[i]);
  214|    617|   }
  215|    369|   der.add_object(ASN1_Type::ObjectId, ASN1_Class::Universal, encoding);
  216|    369|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  221|  22.0k|void OID::decode_from(BER_Decoder& decoder) {
  222|  22.0k|   const BER_Object obj = decoder.get_next_object();
  223|  22.0k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (223:7): [True: 33, False: 21.9k]
  ------------------
  224|     33|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  225|     33|   }
  226|       |
  227|  21.9k|   if(obj.length() == 0) {
  ------------------
  |  Branch (227:7): [True: 1, False: 21.9k]
  ------------------
  228|      1|      throw BER_Decoding_Error("OID encoding is too short");
  229|      1|   }
  230|       |
  231|  21.9k|   auto consume = [](BufferSlicer& data) -> uint32_t {
  232|  21.9k|      BOTAN_ASSERT_NOMSG(!data.empty());
  233|  21.9k|      uint32_t b = data.take_byte();
  234|       |
  235|  21.9k|      if(b > 0x7F) {
  236|  21.9k|         b &= 0x7F;
  237|       |
  238|       |         // Even BER requires that the OID have minimal length, ie that
  239|       |         // the first byte of a multibyte encoding cannot be zero
  240|       |         // See X.690 section 8.19.2
  241|  21.9k|         if(b == 0) {
  242|  21.9k|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  243|  21.9k|         }
  244|       |
  245|  21.9k|         while(true) {
  246|  21.9k|            if(data.empty()) {
  247|  21.9k|               throw Decoding_Error("Truncated OID value");
  248|  21.9k|            }
  249|       |
  250|  21.9k|            const uint8_t next = data.take_byte();
  251|  21.9k|            const bool more = (next & 0x80) == 0x80;
  252|  21.9k|            const uint8_t value = next & 0x7F;
  253|       |
  254|  21.9k|            if((b >> (32 - 7)) != 0) {
  255|  21.9k|               throw Decoding_Error("OID component overflow");
  256|  21.9k|            }
  257|       |
  258|  21.9k|            b = (b << 7) | value;
  259|       |
  260|  21.9k|            if(!more) {
  261|  21.9k|               break;
  262|  21.9k|            }
  263|  21.9k|         }
  264|  21.9k|      }
  265|       |
  266|  21.9k|      return b;
  267|  21.9k|   };
  268|       |
  269|  21.9k|   BufferSlicer data(obj.data());
  270|  21.9k|   std::vector<uint32_t> parts;
  271|   106k|   while(!data.empty()) {
  ------------------
  |  Branch (271:10): [True: 84.5k, False: 21.9k]
  ------------------
  272|  84.5k|      const uint32_t comp = consume(data);
  273|       |
  274|  84.5k|      if(parts.empty()) {
  ------------------
  |  Branch (274:10): [True: 21.9k, False: 62.5k]
  ------------------
  275|       |         // divide into root and second arc
  276|       |
  277|  21.9k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  278|  21.9k|            if(b0 < 40) {
  279|  21.9k|               return 0;
  280|  21.9k|            } else if(b0 < 80) {
  281|  21.9k|               return 1;
  282|  21.9k|            } else {
  283|  21.9k|               return 2;
  284|  21.9k|            }
  285|  21.9k|         }(comp);
  286|       |
  287|  21.9k|         parts.push_back(root_arc);
  288|  21.9k|         BOTAN_ASSERT_NOMSG(comp >= 40 * root_arc);
  ------------------
  |  |   77|  21.9k|   do {                                                                     \
  |  |   78|  21.9k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  21.9k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 21.9k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  21.9k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 21.9k]
  |  |  ------------------
  ------------------
  289|  21.9k|         parts.push_back(comp - 40 * root_arc);
  290|  62.5k|      } else {
  291|  62.5k|         parts.push_back(comp);
  292|  62.5k|      }
  293|  84.5k|   }
  294|       |
  295|  21.9k|   m_id = parts;
  296|  21.9k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_115oid_valid_checkENSt3__14spanIKjLm18446744073709551615EEE:
   26|  19.1k|void oid_valid_check(std::span<const uint32_t> oid) {
   27|  19.1k|   BOTAN_ARG_CHECK(oid.size() >= 2, "OID too short to be valid");
  ------------------
  |  |   35|  19.1k|   do {                                                          \
  |  |   36|  19.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  19.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 19.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  19.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 19.1k]
  |  |  ------------------
  ------------------
   28|  19.1k|   BOTAN_ARG_CHECK(oid[0] <= 2, "OID root out of range");
  ------------------
  |  |   35|  19.1k|   do {                                                          \
  |  |   36|  19.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  19.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 19.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  19.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 19.1k]
  |  |  ------------------
  ------------------
   29|  19.1k|   BOTAN_ARG_CHECK(oid[1] <= 39 || oid[0] == 2, "OID second arc too large");
  ------------------
  |  |   35|  19.1k|   do {                                                          \
  |  |   36|  19.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  19.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 19.1k, False: 0]
  |  |  |  Branch (37:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  19.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 19.1k]
  |  |  ------------------
  ------------------
   30|       |   // This last is a limitation of using 32 bit integers when decoding
   31|       |   // not a limitation of ASN.1 object identifiers in general
   32|  19.1k|   BOTAN_ARG_CHECK(oid[1] <= 0xFFFFFFAF, "OID second arc too large");
  ------------------
  |  |   35|  19.1k|   do {                                                          \
  |  |   36|  19.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  19.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 19.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  19.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 19.1k]
  |  |  ------------------
  ------------------
   33|  19.1k|}
asn1_oid.cpp:_ZZNK5Botan3OID11encode_intoERNS_11DER_EncoderEENK3$_0clERNSt3__16vectorIhNS4_9allocatorIhEEEEj:
  186|    986|   auto append = [](std::vector<uint8_t>& encoding, uint32_t z) {
  187|    986|      if(z <= 0x7F) {
  ------------------
  |  Branch (187:10): [True: 865, False: 121]
  ------------------
  188|    865|         encoding.push_back(static_cast<uint8_t>(z));
  189|    865|      } else {
  190|    121|         const size_t z7 = (high_bit(z) + 7 - 1) / 7;
  191|       |
  192|    363|         for(size_t j = 0; j != z7; ++j) {
  ------------------
  |  Branch (192:28): [True: 242, False: 121]
  ------------------
  193|    242|            uint8_t zp = static_cast<uint8_t>(z >> (7 * (z7 - j - 1)) & 0x7F);
  194|       |
  195|    242|            if(j != z7 - 1) {
  ------------------
  |  Branch (195:16): [True: 121, False: 121]
  ------------------
  196|    121|               zp |= 0x80;
  197|    121|            }
  198|       |
  199|    242|            encoding.push_back(zp);
  200|    242|         }
  201|    121|      }
  202|    986|   };
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_0clERNS_12BufferSlicerE:
  231|  84.5k|   auto consume = [](BufferSlicer& data) -> uint32_t {
  232|  84.5k|      BOTAN_ASSERT_NOMSG(!data.empty());
  ------------------
  |  |   77|  84.5k|   do {                                                                     \
  |  |   78|  84.5k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  84.5k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 84.5k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  84.5k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 84.5k]
  |  |  ------------------
  ------------------
  233|  84.5k|      uint32_t b = data.take_byte();
  234|       |
  235|  84.5k|      if(b > 0x7F) {
  ------------------
  |  Branch (235:10): [True: 12.4k, False: 72.1k]
  ------------------
  236|  12.4k|         b &= 0x7F;
  237|       |
  238|       |         // Even BER requires that the OID have minimal length, ie that
  239|       |         // the first byte of a multibyte encoding cannot be zero
  240|       |         // See X.690 section 8.19.2
  241|  12.4k|         if(b == 0) {
  ------------------
  |  Branch (241:13): [True: 2, False: 12.3k]
  ------------------
  242|      2|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  243|      2|         }
  244|       |
  245|  18.7k|         while(true) {
  ------------------
  |  Branch (245:16): [True: 18.7k, Folded]
  ------------------
  246|  18.7k|            if(data.empty()) {
  ------------------
  |  Branch (246:16): [True: 35, False: 18.7k]
  ------------------
  247|     35|               throw Decoding_Error("Truncated OID value");
  248|     35|            }
  249|       |
  250|  18.7k|            const uint8_t next = data.take_byte();
  251|  18.7k|            const bool more = (next & 0x80) == 0x80;
  252|  18.7k|            const uint8_t value = next & 0x7F;
  253|       |
  254|  18.7k|            if((b >> (32 - 7)) != 0) {
  ------------------
  |  Branch (254:16): [True: 18, False: 18.6k]
  ------------------
  255|     18|               throw Decoding_Error("OID component overflow");
  256|     18|            }
  257|       |
  258|  18.6k|            b = (b << 7) | value;
  259|       |
  260|  18.6k|            if(!more) {
  ------------------
  |  Branch (260:16): [True: 12.3k, False: 6.35k]
  ------------------
  261|  12.3k|               break;
  262|  12.3k|            }
  263|  18.6k|         }
  264|  12.3k|      }
  265|       |
  266|  84.4k|      return b;
  267|  84.5k|   };
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_1clEj:
  277|  21.9k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  278|  21.9k|            if(b0 < 40) {
  ------------------
  |  Branch (278:16): [True: 182, False: 21.7k]
  ------------------
  279|    182|               return 0;
  280|  21.7k|            } else if(b0 < 80) {
  ------------------
  |  Branch (280:23): [True: 6.23k, False: 15.5k]
  ------------------
  281|  6.23k|               return 1;
  282|  15.5k|            } else {
  283|  15.5k|               return 2;
  284|  15.5k|            }
  285|  21.9k|         }(comp);

_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  135|  3.18k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
  136|  3.18k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (136:7): [True: 0, False: 3.18k]
  ------------------
  137|      0|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
  138|      0|   }
  139|       |
  140|  3.18k|   if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (140:7): [True: 0, False: 3.18k]
  ------------------
  141|      0|      throw Invalid_Argument(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  142|      0|   }
  143|  3.18k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  145|  3.18k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
  162|  3.18k|void ASN1_String::decode_from(BER_Decoder& source) {
  163|  3.18k|   const BER_Object obj = source.get_next_object();
  164|       |
  165|  3.18k|   if(obj.get_class() != ASN1_Class::Universal || !is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (165:7): [True: 730, False: 2.45k]
  |  Branch (165:51): [True: 0, False: 2.45k]
  ------------------
  166|    730|      auto typ = static_cast<uint32_t>(obj.type());
  167|    730|      auto cls = static_cast<uint32_t>(obj.get_class());
  168|    730|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}/{}", typ, cls));
  169|    730|   }
  170|       |
  171|  2.45k|   m_tag = obj.type();
  172|  2.45k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
  173|       |
  174|  2.45k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (174:7): [True: 0, False: 2.45k]
  ------------------
  175|      0|      m_utf8_str = ucs2_to_utf8(m_data);
  176|  2.45k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (176:14): [True: 0, False: 2.45k]
  ------------------
  177|      0|      m_utf8_str = ucs4_to_utf8(m_data);
  178|  2.45k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (178:14): [True: 5, False: 2.44k]
  ------------------
  179|       |      /*
  180|       |      TeletexString is nominally ITU T.61 not ISO-8859-1 but it seems
  181|       |      the majority of implementations actually used that charset here.
  182|       |      */
  183|      5|      m_utf8_str = latin1_to_utf8(m_data);
  184|  2.44k|   } else {
  185|       |      // All other supported string types are UTF-8 or some subset thereof
  186|  2.44k|      m_utf8_str = ASN1::to_string(obj);
  187|       |
  188|  2.44k|      if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (188:10): [True: 1.94k, False: 508]
  ------------------
  189|  1.94k|         throw Decoding_Error(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  190|  1.94k|      }
  191|  2.44k|   }
  192|  2.45k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   99|  2.45k|bool is_asn1_string_type(ASN1_Type tag) {
  100|  2.45k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (100:12): [True: 2.44k, False: 5]
  |  Branch (100:47): [True: 5, False: 0]
  |  Branch (100:82): [True: 0, False: 0]
  ------------------
  101|      0|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (101:12): [True: 0, False: 0]
  ------------------
  102|  2.45k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   94|  11.2k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   95|  11.2k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (95:12): [True: 3.77k, False: 7.49k]
  |  Branch (95:47): [True: 7.38k, False: 109]
  |  Branch (95:84): [True: 24, False: 85]
  ------------------
   96|     85|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (96:12): [True: 10, False: 75]
  |  Branch (96:43): [True: 70, False: 5]
  ------------------
   97|  11.2k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_128is_valid_asn1_string_contentERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_9ASN1_TypeE:
  104|  5.63k|bool is_valid_asn1_string_content(const std::string& str, ASN1_Type tag) {
  105|  5.63k|   BOTAN_ASSERT_NOMSG(is_utf8_subset_string_type(tag));
  ------------------
  |  |   77|  5.63k|   do {                                                                     \
  |  |   78|  5.63k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  5.63k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 5.63k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  5.63k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 5.63k]
  |  |  ------------------
  ------------------
  106|       |
  107|  5.63k|   switch(tag) {
  108|     35|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (108:7): [True: 35, False: 5.59k]
  ------------------
  109|     35|         return is_valid_utf8(str);
  110|  1.88k|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (110:7): [True: 1.88k, False: 3.74k]
  ------------------
  111|  5.57k|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (111:7): [True: 3.69k, False: 1.94k]
  ------------------
  112|  5.58k|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (112:7): [True: 5, False: 5.62k]
  ------------------
  113|  5.59k|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (113:7): [True: 12, False: 5.61k]
  ------------------
  114|  5.59k|         return g_char_validator.valid_encoding(str, tag);
  115|      0|      default:
  ------------------
  |  Branch (115:7): [True: 0, False: 5.63k]
  ------------------
  116|      0|         return false;
  117|  5.63k|   }
  118|  5.63k|}
asn1_str.cpp:_ZNK5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator14valid_encodingENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_9ASN1_TypeE:
   25|  8.77k|      constexpr bool valid_encoding(std::string_view str, ASN1_Type tag) const {
   26|  8.77k|         const uint8_t mask = mask_for(tag);
   27|  8.77k|         for(const char c : str) {
  ------------------
  |  Branch (27:27): [True: 8.65k, False: 6.87k]
  ------------------
   28|  8.65k|            const uint8_t codepoint = static_cast<uint8_t>(c);
   29|  8.65k|            const bool is_valid = (m_table[codepoint] & mask) != 0;
   30|       |
   31|  8.65k|            if(!is_valid) {
  ------------------
  |  Branch (31:16): [True: 1.90k, False: 6.75k]
  ------------------
   32|  1.90k|               return false;
   33|  1.90k|            }
   34|  8.65k|         }
   35|       |
   36|  6.87k|         return true;
   37|  8.77k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator8mask_forENS_9ASN1_TypeE:
   45|  8.77k|      static constexpr uint8_t mask_for(ASN1_Type tag) {
   46|  8.77k|         switch(tag) {
   47|  1.88k|            case ASN1_Type::NumericString:
  ------------------
  |  Branch (47:13): [True: 1.88k, False: 6.89k]
  ------------------
   48|  1.88k|               return Numeric_String;
   49|  6.87k|            case ASN1_Type::PrintableString:
  ------------------
  |  Branch (49:13): [True: 6.87k, False: 1.90k]
  ------------------
   50|  6.87k|               return Printable_String;
   51|      5|            case ASN1_Type::Ia5String:
  ------------------
  |  Branch (51:13): [True: 5, False: 8.77k]
  ------------------
   52|      5|               return IA5_String;
   53|     12|            case ASN1_Type::VisibleString:
  ------------------
  |  Branch (53:13): [True: 12, False: 8.76k]
  ------------------
   54|     12|               return Visible_String;
   55|      0|            default:
  ------------------
  |  Branch (55:13): [True: 0, False: 8.77k]
  ------------------
   56|      0|               return 0;
   57|  8.77k|         }
   58|  8.77k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  120|  3.18k|ASN1_Type choose_encoding(std::string_view str) {
  121|  3.18k|   if(g_char_validator.valid_encoding(str, ASN1_Type::PrintableString)) {
  ------------------
  |  Branch (121:7): [True: 3.18k, False: 0]
  ------------------
  122|  3.18k|      return ASN1_Type::PrintableString;
  123|  3.18k|   } else {
  124|      0|      return ASN1_Type::Utf8String;
  125|      0|   }
  126|  3.18k|}

_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   59|  9.76k|void ASN1_Time::decode_from(BER_Decoder& source) {
   60|  9.76k|   const BER_Object ber_time = source.get_next_object();
   61|       |
   62|  9.76k|   if(ber_time.get_class() != ASN1_Class::Universal ||
  ------------------
  |  Branch (62:7): [True: 1, False: 9.76k]
  ------------------
   63|  9.76k|      (ber_time.type() != ASN1_Type::UtcTime && ber_time.type() != ASN1_Type::GeneralizedTime)) {
  ------------------
  |  Branch (63:8): [True: 2, False: 9.76k]
  |  Branch (63:49): [True: 0, False: 2]
  ------------------
   64|      0|      throw Decoding_Error(fmt("ASN1_Time: Unexpected tag {}/{}",
   65|      0|                               static_cast<uint32_t>(ber_time.type()),
   66|      0|                               static_cast<uint32_t>(ber_time.get_class())));
   67|      0|   }
   68|       |
   69|  9.76k|   try {
   70|  9.76k|      set_to(ASN1::to_string(ber_time), ber_time.type());
   71|  9.76k|   } catch(Invalid_Argument& e) {
   72|      3|      throw Decoding_Error(fmt("Invalid ASN1_Time encoding: {}", e.what()));
   73|      3|   }
   74|  9.76k|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  176|  9.76k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  177|  9.76k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   35|  9.76k|   do {                                                          \
  |  |   36|  9.76k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  9.76k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 9.76k, False: 2]
  |  |  |  Branch (37:12): [True: 2, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  9.76k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 9.76k]
  |  |  ------------------
  ------------------
  178|  9.76k|                   "Invalid tag for ASN1_Time");
  179|       |
  180|  9.76k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (180:7): [True: 2, False: 9.76k]
  ------------------
  181|      2|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   35|      2|   do {                                                          \
  |  |   36|      2|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|      2|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 2]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|      2|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  182|  9.76k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (182:14): [True: 9.76k, False: 0]
  ------------------
  183|  9.76k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   35|  9.76k|   do {                                                          \
  |  |   36|  9.76k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  9.76k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 1, False: 9.75k]
  |  |  ------------------
  |  |   38|      1|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      1|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      1|      }                                                          \
  |  |   41|  9.76k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 9.76k]
  |  |  ------------------
  ------------------
  184|  9.76k|   }
  185|       |
  186|  9.76k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   35|  9.76k|   do {                                                          \
  |  |   36|  9.76k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  9.76k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 9.76k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  9.76k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 9.76k]
  |  |  ------------------
  ------------------
  187|       |
  188|  9.76k|   const size_t field_len = 2;
  189|       |
  190|  9.76k|   const size_t year_start = 0;
  191|  9.76k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (191:28): [True: 9.75k, False: 3]
  ------------------
  192|  9.76k|   const size_t month_start = year_start + year_len;
  193|  9.76k|   const size_t day_start = month_start + field_len;
  194|  9.76k|   const size_t hour_start = day_start + field_len;
  195|  9.76k|   const size_t min_start = hour_start + field_len;
  196|  9.76k|   const size_t sec_start = min_start + field_len;
  197|       |
  198|  9.76k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  199|  9.76k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  200|  9.76k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  201|  9.76k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  202|  9.76k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  203|  9.76k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  204|  9.76k|   m_tag = spec_tag;
  205|       |
  206|  9.76k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (206:7): [True: 9.75k, False: 3]
  ------------------
  207|  9.75k|      if(m_year >= 50) {
  ------------------
  |  Branch (207:10): [True: 1, False: 9.75k]
  ------------------
  208|      1|         m_year += 1900;
  209|  9.75k|      } else {
  210|  9.75k|         m_year += 2000;
  211|  9.75k|      }
  212|  9.75k|   }
  213|       |
  214|  9.76k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (214:7): [True: 2, False: 9.76k]
  ------------------
  215|      2|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  216|      2|   }
  217|  9.76k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  222|  9.76k|bool ASN1_Time::passes_sanity_check() const {
  223|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  224|  9.76k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (224:7): [True: 0, False: 9.76k]
  |  Branch (224:24): [True: 0, False: 9.76k]
  ------------------
  225|      0|      return false;
  226|      0|   }
  227|  9.76k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (227:7): [True: 0, False: 9.76k]
  |  Branch (227:23): [True: 0, False: 9.76k]
  ------------------
  228|      0|      return false;
  229|      0|   }
  230|       |
  231|  9.76k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  232|       |
  233|  9.76k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (233:7): [True: 0, False: 9.76k]
  |  Branch (233:21): [True: 2, False: 9.75k]
  ------------------
  234|      2|      return false;
  235|      2|   }
  236|       |
  237|  9.75k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (237:7): [True: 396, False: 9.36k]
  |  Branch (237:23): [True: 24, False: 372]
  ------------------
  238|     24|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (238:10): [True: 0, False: 24]
  ------------------
  239|      0|         return false;  // not a leap year
  240|      0|      }
  241|       |
  242|     24|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (242:10): [True: 0, False: 24]
  |  Branch (242:31): [True: 0, False: 0]
  ------------------
  243|      0|         return false;
  244|      0|      }
  245|     24|   }
  246|       |
  247|  9.75k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (247:7): [True: 0, False: 9.75k]
  |  Branch (247:23): [True: 0, False: 9.75k]
  |  Branch (247:41): [True: 0, False: 9.75k]
  ------------------
  248|      0|      return false;
  249|      0|   }
  250|       |
  251|  9.75k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (251:7): [True: 9.75k, False: 2]
  ------------------
  252|       |      /*
  253|       |      UTCTime limits the value of components such that leap seconds
  254|       |      are not covered. See "UNIVERSAL 23" in "Information technology
  255|       |      Abstract Syntax Notation One (ASN.1): Specification of basic notation"
  256|       |
  257|       |      http://www.itu.int/ITU-T/studygroups/com17/languages/
  258|       |      */
  259|  9.75k|      if(m_second > 59) {
  ------------------
  |  Branch (259:10): [True: 0, False: 9.75k]
  ------------------
  260|      0|         return false;
  261|      0|      }
  262|  9.75k|   }
  263|       |
  264|  9.75k|   return true;
  265|  9.75k|}

_ZN5Botan11BER_DecoderD2Ev:
  366|  67.0k|BER_Decoder::~BER_Decoder() = default;
_ZNK5Botan11BER_Decoder10more_itemsEv:
  371|  48.3k|bool BER_Decoder::more_items() const {
  372|  48.3k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (372:7): [True: 10.2k, False: 38.1k]
  |  Branch (372:34): [True: 10.2k, False: 0]
  ------------------
  373|  10.2k|      return false;
  374|  10.2k|   }
  375|  38.1k|   return true;
  376|  48.3k|}
_ZN5Botan11BER_Decoder10verify_endEv:
  381|  12.5k|BER_Decoder& BER_Decoder::verify_end() {
  382|  12.5k|   return verify_end("BER_Decoder::verify_end called, but data remains");
  383|  12.5k|}
_ZN5Botan11BER_Decoder10verify_endENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  388|  12.5k|BER_Decoder& BER_Decoder::verify_end(std::string_view err) {
  389|  12.5k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (389:7): [True: 0, False: 12.5k]
  |  Branch (389:35): [True: 0, False: 12.5k]
  ------------------
  390|      0|      throw Decoding_Error(err);
  391|      0|   }
  392|  12.5k|   return (*this);
  393|  12.5k|}
_ZN5Botan11BER_Decoder17discard_remainingEv:
  398|     46|BER_Decoder& BER_Decoder::discard_remaining() {
  399|     46|   m_pushed = BER_Object();
  400|     46|   uint8_t buf = 0;
  401|     46|   while(m_source->read_byte(buf) != 0) {}
  ------------------
  |  Branch (401:10): [True: 0, False: 46]
  ------------------
  402|     46|   return (*this);
  403|     46|}
_ZN5Botan11BER_Decoder14read_next_byteEv:
  405|  3.49M|std::optional<uint8_t> BER_Decoder::read_next_byte() {
  406|  3.49M|   BOTAN_ASSERT_NOMSG(m_source != nullptr);
  ------------------
  |  |   77|  3.49M|   do {                                                                     \
  |  |   78|  3.49M|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  3.49M|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 3.49M]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  3.49M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 3.49M]
  |  |  ------------------
  ------------------
  407|  3.49M|   uint8_t b = 0;
  408|  3.49M|   if(m_source->read_byte(b) != 0) {
  ------------------
  |  Branch (408:7): [True: 3.48M, False: 12.1k]
  ------------------
  409|  3.48M|      return b;
  410|  3.48M|   } else {
  411|  12.1k|      return {};
  412|  12.1k|   }
  413|  3.49M|}
_ZN5Botan11BER_Decoder16peek_next_objectEv:
  415|    169|const BER_Object& BER_Decoder::peek_next_object() {
  416|    169|   if(!m_pushed.is_set()) {
  ------------------
  |  Branch (416:7): [True: 169, False: 0]
  ------------------
  417|    169|      m_pushed = get_next_object();
  418|    169|   }
  419|       |
  420|    169|   return m_pushed;
  421|    169|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  426|   137k|BER_Object BER_Decoder::get_next_object() {
  427|   137k|   BER_Object next;
  428|       |
  429|   137k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (429:7): [True: 15.9k, False: 121k]
  ------------------
  430|  15.9k|      std::swap(next, m_pushed);
  431|  15.9k|      return next;
  432|  15.9k|   }
  433|       |
  434|   121k|   for(;;) {
  435|   121k|      ASN1_Type type_tag = ASN1_Type::NoObject;
  436|   121k|      ASN1_Class class_tag = ASN1_Class::NoObject;
  437|   121k|      decode_tag(m_source, type_tag, class_tag);
  438|   121k|      next.set_tagging(type_tag, class_tag);
  439|   121k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (439:10): [True: 112, False: 121k]
  ------------------
  440|    112|         return next;
  441|    112|      }
  442|       |
  443|   121k|      const size_t allow_indef = m_limits.allow_ber_encoding() ? m_limits.max_nested_indefinite_length() : 0;
  ------------------
  |  Branch (443:34): [True: 0, False: 121k]
  ------------------
  444|   121k|      const bool der_mode = m_limits.require_der_encoding();
  445|   121k|      const auto dl = decode_length(m_source, allow_indef, der_mode, is_constructed(class_tag));
  446|       |
  447|       |      // Per X.690 8.1.5 the only valid EOC encoding is the two-octet
  448|       |      // sequence 0x00 0x00. Reject any other length encoding on a tag of
  449|       |      // (Eoc, Universal) before we consume the "content" bytes.
  450|   121k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal &&
  ------------------
  |  Branch (450:10): [True: 128, False: 121k]
  |  Branch (450:40): [True: 27, False: 101]
  ------------------
  451|     27|         (dl.content_length() != 0 || dl.indefinite_length())) {
  ------------------
  |  Branch (451:11): [True: 13, False: 14]
  |  Branch (451:39): [True: 0, False: 14]
  ------------------
  452|     13|         throw BER_Decoding_Error("EOC marker with non-zero length");
  453|     13|      }
  454|       |
  455|   121k|      if(!m_source->check_available(dl.total_length())) {
  ------------------
  |  Branch (455:10): [True: 136, False: 121k]
  ------------------
  456|    136|         throw BER_Decoding_Error("Value truncated");
  457|    136|      }
  458|       |
  459|   121k|      uint8_t* out = next.mutable_bits(dl.content_length());
  460|   121k|      if(m_source->read(out, dl.content_length()) != dl.content_length()) {
  ------------------
  |  Branch (460:10): [True: 0, False: 121k]
  ------------------
  461|      0|         throw BER_Decoding_Error("Value truncated");
  462|      0|      }
  463|       |
  464|   121k|      if(dl.indefinite_length()) {
  ------------------
  |  Branch (464:10): [True: 0, False: 121k]
  ------------------
  465|       |         // After reading the data consume the 2-byte EOC
  466|      0|         uint8_t eoc[2] = {0xFF, 0xFF};
  467|      0|         if(m_source->read(eoc, 2) != 2 || eoc[0] != 0x00 || eoc[1] != 0x00) {
  ------------------
  |  Branch (467:13): [True: 0, False: 0]
  |  Branch (467:44): [True: 0, False: 0]
  |  Branch (467:62): [True: 0, False: 0]
  ------------------
  468|      0|            throw BER_Decoding_Error("Missing or malformed EOC marker");
  469|      0|         }
  470|      0|      }
  471|       |
  472|   121k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (472:10): [True: 14, False: 121k]
  ------------------
  473|     14|         if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (473:13): [True: 14, False: 0]
  ------------------
  474|     14|            throw BER_Decoding_Error("Detected EOC marker in DER structure");
  475|     14|         }
  476|      0|         continue;
  477|   121k|      } else {
  478|   121k|         break;
  479|   121k|      }
  480|   121k|   }
  481|       |
  482|   121k|   return next;
  483|   121k|}
_ZN5Botan11BER_Decoder9push_backEONS_10BER_ObjectE:
  507|  15.8k|void BER_Decoder::push_back(BER_Object&& obj) {
  508|  15.8k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (508:7): [True: 0, False: 15.8k]
  ------------------
  509|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  510|      0|   }
  511|  15.8k|   m_pushed = std::move(obj);
  512|  15.8k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  514|  54.5k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  515|  54.5k|   BER_Object obj = get_next_object();
  516|  54.5k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  517|  54.5k|   BER_Decoder child(std::move(obj), this);
  518|  54.5k|   return child;
  519|  54.5k|}
_ZN5Botan11BER_Decoder8end_consEv:
  524|  37.9k|BER_Decoder& BER_Decoder::end_cons() {
  525|  37.9k|   if(m_parent == nullptr) {
  ------------------
  |  Branch (525:7): [True: 0, False: 37.9k]
  ------------------
  526|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  527|      0|   }
  528|  37.9k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (528:7): [True: 14, False: 37.9k]
  |  Branch (528:35): [True: 0, False: 37.9k]
  ------------------
  529|     14|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  530|     14|   }
  531|  37.9k|   return (*m_parent);
  532|  37.9k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  535|  54.0k|      m_limits(parent != nullptr ? parent->limits() : BER_Decoder::Limits::BER()), m_parent(parent) {
  ------------------
  |  Branch (535:16): [True: 54.0k, False: 0]
  ------------------
  536|  54.0k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  537|  54.0k|   m_source = m_data_src.get();
  538|  54.0k|}
_ZN5Botan11BER_DecoderC2ERNS_10DataSourceENS0_6LimitsE:
  543|  3.74k|BER_Decoder::BER_Decoder(DataSource& src, Limits limits) : m_limits(limits), m_source(&src) {}
_ZN5Botan11BER_DecoderC2ENSt3__14spanIKhLm18446744073709551615EEENS0_6LimitsE:
  548|  9.19k|BER_Decoder::BER_Decoder(std::span<const uint8_t> buf, Limits limits) : m_limits(limits) {
  549|  9.19k|   m_data_src = std::make_unique<DataSource_Memory>(buf);
  550|  9.19k|   m_source = m_data_src.get();
  551|  9.19k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  560|  53.5k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  561|  53.5k|   obj.decode_from(*this);
  562|  53.5k|   return (*this);
  563|  53.5k|}
_ZN5Botan11BER_Decoder6decodeERmNS_9ASN1_TypeENS_10ASN1_ClassE:
  610|  6.15k|BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  611|  6.15k|   BigInt integer;
  612|  6.15k|   decode(integer, type_tag, class_tag);
  613|       |
  614|  6.15k|   if(integer.signum() < 0) {
  ------------------
  |  Branch (614:7): [True: 66, False: 6.08k]
  ------------------
  615|     66|      throw BER_Decoding_Error("Decoded small integer value was negative");
  616|     66|   }
  617|       |
  618|  6.08k|   if(integer.bits() > 32) {
  ------------------
  |  Branch (618:7): [True: 51, False: 6.03k]
  ------------------
  619|     51|      throw BER_Decoding_Error("Decoded integer value larger than expected");
  620|     51|   }
  621|       |
  622|  6.03k|   out = 0;
  623|  29.3k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (623:22): [True: 23.2k, False: 6.03k]
  ------------------
  624|  23.2k|      out = (out << 8) | integer.byte_at(3 - i);
  625|  23.2k|   }
  626|       |
  627|  6.03k|   return (*this);
  628|  6.08k|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  660|  15.7k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  661|  15.7k|   const BER_Object obj = get_next_object();
  662|  15.7k|   obj.assert_is_a(type_tag, class_tag);
  663|       |
  664|       |   // DER requires minimal INTEGER encoding (X.690 section 8.3.2)
  665|  15.7k|   if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (665:7): [True: 15.5k, False: 203]
  ------------------
  666|  15.5k|      if(obj.length() == 0) {
  ------------------
  |  Branch (666:10): [True: 2, False: 15.5k]
  ------------------
  667|      2|         throw BER_Decoding_Error("Detected empty INTEGER encoding in DER structure");
  668|      2|      }
  669|  15.5k|      if(obj.length() > 1) {
  ------------------
  |  Branch (669:10): [True: 9.72k, False: 5.77k]
  ------------------
  670|  9.72k|         if(obj.bits()[0] == 0x00 && (obj.bits()[1] & 0x80) == 0) {
  ------------------
  |  Branch (670:13): [True: 238, False: 9.48k]
  |  Branch (670:38): [True: 37, False: 201]
  ------------------
  671|     37|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  672|     37|         }
  673|  9.69k|         if(obj.bits()[0] == 0xFF && (obj.bits()[1] & 0x80) != 0) {
  ------------------
  |  Branch (673:13): [True: 36, False: 9.65k]
  |  Branch (673:38): [True: 8, False: 28]
  ------------------
  674|      8|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  675|      8|         }
  676|  9.69k|      }
  677|  15.5k|   }
  678|       |
  679|  15.6k|   if(obj.length() == 0) {
  ------------------
  |  Branch (679:7): [True: 0, False: 15.6k]
  ------------------
  680|      0|      out.clear();
  681|  15.6k|   } else {
  682|  15.6k|      const uint8_t first = obj.bits()[0];
  683|  15.6k|      const bool negative = (first & 0x80) == 0x80;
  684|       |
  685|  15.6k|      if(negative) {
  ------------------
  |  Branch (685:10): [True: 134, False: 15.5k]
  ------------------
  686|    134|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  687|    514|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (687:39): [True: 514, False: 0]
  ------------------
  688|    514|            const bool gt0 = (vec[i - 1] > 0);
  689|    514|            vec[i - 1] -= 1;
  690|    514|            if(gt0) {
  ------------------
  |  Branch (690:16): [True: 134, False: 380]
  ------------------
  691|    134|               break;
  692|    134|            }
  693|    514|         }
  694|  4.18k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (694:28): [True: 4.05k, False: 134]
  ------------------
  695|  4.05k|            vec[i] = ~vec[i];
  696|  4.05k|         }
  697|    134|         out._assign_from_bytes(vec);
  698|    134|         out.flip_sign();
  699|  15.5k|      } else {
  700|  15.5k|         out._assign_from_bytes(obj.data());
  701|  15.5k|      }
  702|  15.6k|   }
  703|       |
  704|  15.6k|   return (*this);
  705|  15.7k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  782|  15.9k|                                 ASN1_Class class_tag) {
  783|  15.9k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (783:7): [True: 3.17k, False: 12.7k]
  |  Branch (783:46): [True: 0, False: 3.17k]
  ------------------
  784|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  785|      0|   }
  786|       |
  787|  15.9k|   asn1_decode_binary_string(
  788|  15.9k|      buffer, get_next_object(), real_type, type_tag, class_tag, m_limits.require_der_encoding());
  789|  15.9k|   return (*this);
  790|  15.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   27|   121k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   28|   121k|   auto b = ber->read_byte();
   29|       |
   30|   121k|   if(!b) {
  ------------------
  |  Branch (30:7): [True: 112, False: 121k]
  ------------------
   31|    112|      type_tag = ASN1_Type::NoObject;
   32|    112|      class_tag = ASN1_Class::NoObject;
   33|    112|      return 0;
   34|    112|   }
   35|       |
   36|   121k|   if((*b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (36:7): [True: 121k, False: 259]
  ------------------
   37|   121k|      type_tag = ASN1_Type(*b & 0x1F);
   38|   121k|      class_tag = ASN1_Class(*b & 0xE0);
   39|   121k|      return 1;
   40|   121k|   }
   41|       |
   42|    259|   size_t tag_bytes = 1;
   43|    259|   class_tag = ASN1_Class(*b & 0xE0);
   44|       |
   45|    259|   uint32_t tag_buf = 0;
   46|    884|   while(true) {
  ------------------
  |  Branch (46:10): [True: 884, Folded]
  ------------------
   47|    884|      b = ber->read_byte();
   48|    884|      if(!b) {
  ------------------
  |  Branch (48:10): [True: 14, False: 870]
  ------------------
   49|     14|         throw BER_Decoding_Error("Long-form tag truncated");
   50|     14|      }
   51|    870|      if((tag_buf >> 24) != 0) {
  ------------------
  |  Branch (51:10): [True: 10, False: 860]
  ------------------
   52|     10|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|     10|      }
   54|       |      // This is required even by BER (see X.690 section 8.1.2.4.2 sentence c).
   55|       |      // Bits 7-1 of the first subsequent octet must not be all zero; this rules
   56|       |      // out both 0x80 (continuation with no data) and 0x00 (a long-form encoding
   57|       |      // of tag value 0, which collides with the EOC marker).
   58|    860|      if(tag_bytes == 1 && (*b & 0x7F) == 0) {
  ------------------
  |  Branch (58:10): [True: 257, False: 603]
  |  Branch (58:28): [True: 2, False: 255]
  ------------------
   59|      2|         throw BER_Decoding_Error("Long form tag with leading zero");
   60|      2|      }
   61|    858|      ++tag_bytes;
   62|    858|      tag_buf = (tag_buf << 7) | (*b & 0x7F);
   63|    858|      if((*b & 0x80) == 0) {
  ------------------
  |  Branch (63:10): [True: 233, False: 625]
  ------------------
   64|    233|         break;
   65|    233|      }
   66|    858|   }
   67|       |   // Per X.690 8.1.2.2, tag values 0-30 shall be encoded in the short form.
   68|       |   // Long-form encoding is reserved for tag values >= 31 (X.690 8.1.2.3).
   69|       |   // This is unconditional and applies to BER as well as DER.
   70|    233|   if(tag_buf <= 30) {
  ------------------
  |  Branch (70:7): [True: 4, False: 229]
  ------------------
   71|      4|      throw BER_Decoding_Error("Long-form tag encoding used for small tag value");
   72|      4|   }
   73|       |
   74|    229|   if(tag_buf == static_cast<uint32_t>(ASN1_Type::NoObject)) {
  ------------------
  |  Branch (74:7): [True: 1, False: 228]
  ------------------
   75|      1|      throw BER_Decoding_Error("Tag value collides with internal sentinel");
   76|      1|   }
   77|       |
   78|       |   // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
   79|    228|   type_tag = ASN1_Type(tag_buf);
   80|    228|   return tag_bytes;
   81|    229|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceEmbb:
  126|   121k|BerDecodedLength decode_length(DataSource* ber, size_t allow_indef, bool der_mode, bool constructed) {
  127|   121k|   uint8_t b = 0;
  128|   121k|   if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (128:7): [True: 60, False: 121k]
  ------------------
  129|     60|      throw BER_Decoding_Error("Length field not found");
  130|     60|   }
  131|   121k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (131:7): [True: 114k, False: 7.06k]
  ------------------
  132|   114k|      return BerDecodedLength(b, 1);
  133|   114k|   }
  134|       |
  135|  7.06k|   const size_t num_length_bytes = (b & 0x7F);
  136|  7.06k|   if(num_length_bytes > 4) {
  ------------------
  |  Branch (136:7): [True: 45, False: 7.01k]
  ------------------
  137|     45|      throw BER_Decoding_Error("Length field is too large");
  138|     45|   }
  139|       |
  140|  7.01k|   const size_t field_size = 1 + num_length_bytes;
  141|       |
  142|  7.01k|   if(num_length_bytes == 0) {
  ------------------
  |  Branch (142:7): [True: 26, False: 6.98k]
  ------------------
  143|     26|      if(der_mode) {
  ------------------
  |  Branch (143:10): [True: 26, False: 0]
  ------------------
  144|     26|         throw BER_Decoding_Error("Detected indefinite-length encoding in DER structure");
  145|     26|      } else if(!constructed) {
  ------------------
  |  Branch (145:17): [True: 0, False: 0]
  ------------------
  146|       |         // Indefinite length is only valid for constructed types (X.690 8.1.3.2)
  147|      0|         throw BER_Decoding_Error("Indefinite-length encoding used with non-constructed type");
  148|      0|      } else if(allow_indef == 0) {
  ------------------
  |  Branch (148:17): [True: 0, False: 0]
  ------------------
  149|      0|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
  150|      0|      } else {
  151|       |         // find_eoc returns bytes up to and including the EOC marker.
  152|       |         // Return the content length; the caller consumes the EOC separately.
  153|      0|         const size_t eoc_len = find_eoc(ber, /*base_offset=*/0, allow_indef - 1);
  154|      0|         if(eoc_len < 2) {
  ------------------
  |  Branch (154:13): [True: 0, False: 0]
  ------------------
  155|      0|            throw BER_Decoding_Error("Invalid EOC encoding");
  156|      0|         }
  157|      0|         return BerDecodedLength::indefinite(eoc_len - 2, field_size);
  158|      0|      }
  159|     26|   }
  160|       |
  161|  6.98k|   size_t length = 0;
  162|       |
  163|  21.0k|   for(size_t i = 0; i != num_length_bytes; ++i) {
  ------------------
  |  Branch (163:22): [True: 14.0k, False: 6.96k]
  ------------------
  164|  14.0k|      if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (164:10): [True: 26, False: 14.0k]
  ------------------
  165|     26|         throw BER_Decoding_Error("Corrupted length field");
  166|     26|      }
  167|       |      // Can't overflow since we already checked that num_length_bytes <= 4
  168|  14.0k|      length = (length << 8) | b;
  169|  14.0k|   }
  170|       |
  171|       |   // DER requires shortest possible length encoding
  172|  6.96k|   if(der_mode) {
  ------------------
  |  Branch (172:7): [True: 6.96k, False: 0]
  ------------------
  173|  6.96k|      if(length < 128) {
  ------------------
  |  Branch (173:10): [True: 11, False: 6.95k]
  ------------------
  174|     11|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  175|     11|      }
  176|  6.95k|      if(num_length_bytes > 1 && length < (size_t(1) << ((num_length_bytes - 1) * 8))) {
  ------------------
  |  Branch (176:10): [True: 6.91k, False: 36]
  |  Branch (176:34): [True: 1, False: 6.91k]
  ------------------
  177|      1|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  178|      1|      }
  179|  6.95k|   }
  180|       |
  181|  6.95k|   return BerDecodedLength(length, field_size);
  182|  6.96k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emm:
   99|   121k|            BerDecodedLength(content_length, field_length, false) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emmb:
  116|   121k|            m_content_length(content_length), m_field_length(field_length), m_indefinite(indefinite) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_114is_constructedENS_10ASN1_ClassE:
   20|   137k|bool is_constructed(ASN1_Class class_tag) {
   21|   137k|   return (static_cast<uint32_t>(class_tag) & static_cast<uint32_t>(ASN1_Class::Constructed)) != 0;
   22|   137k|}
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength14content_lengthEv:
  105|   362k|      size_t content_length() const { return m_content_length; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength17indefinite_lengthEv:
  112|   120k|      bool indefinite_length() const { return m_indefinite; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength12total_lengthEv:
  108|   121k|      size_t total_length() const { return m_indefinite ? m_content_length + 2 : m_content_length; }
  ------------------
  |  Branch (108:44): [True: 0, False: 121k]
  ------------------
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  357|  54.0k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  327|  3.78M|      size_t read(uint8_t out[], size_t length) override {
  328|  3.78M|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   77|  3.78M|   do {                                                                     \
  |  |   78|  3.78M|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  3.78M|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 3.78M]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  3.78M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 3.78M]
  |  |  ------------------
  ------------------
  329|  3.78M|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  330|  3.78M|         copy_mem(out, m_obj.bits() + m_offset, got);
  331|  3.78M|         m_offset += got;
  332|  3.78M|         return got;
  333|  3.78M|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  348|  92.2k|      bool check_available(size_t n) override {
  349|  92.2k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   77|  92.2k|   do {                                                                     \
  |  |   78|  92.2k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  92.2k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 92.2k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  92.2k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 92.2k]
  |  |  ------------------
  ------------------
  350|  92.2k|         return (n <= (m_obj.length() - m_offset));
  351|  92.2k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  353|  82.9k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  355|  82.9k|      size_t get_bytes_read() const override { return m_offset; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_114is_constructedERKNS_10BER_ObjectE:
  709|  15.8k|bool is_constructed(const BER_Object& obj) {
  710|  15.8k|   return is_constructed(obj.class_tag());
  711|  15.8k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassEb:
  719|  15.8k|                               bool require_der) {
  720|  15.8k|   obj.assert_is_a(type_tag, class_tag);
  721|       |
  722|       |   // DER requires BIT STRING and OCTET STRING to use primitive encoding
  723|  15.8k|   if(require_der && is_constructed(obj)) {
  ------------------
  |  Branch (723:7): [True: 15.8k, False: 54]
  |  Branch (723:22): [True: 0, False: 15.8k]
  ------------------
  724|      0|      throw BER_Decoding_Error("Detected constructed string encoding in DER structure");
  725|      0|   }
  726|       |
  727|  15.8k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (727:7): [True: 12.7k, False: 3.16k]
  ------------------
  728|  12.7k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  729|  12.7k|   } else {
  730|  3.16k|      if(obj.length() == 0) {
  ------------------
  |  Branch (730:10): [True: 2, False: 3.16k]
  ------------------
  731|      2|         throw BER_Decoding_Error("Invalid BIT STRING");
  732|      2|      }
  733|       |
  734|  3.16k|      const uint8_t unused_bits = obj.bits()[0];
  735|       |
  736|  3.16k|      if(unused_bits >= 8) {
  ------------------
  |  Branch (736:10): [True: 1, False: 3.16k]
  ------------------
  737|      1|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  738|      1|      }
  739|       |
  740|       |      // Empty BIT STRING with unused bits > 0 ...
  741|  3.16k|      if(unused_bits > 0 && obj.length() < 2) {
  ------------------
  |  Branch (741:10): [True: 669, False: 2.49k]
  |  Branch (741:29): [True: 2, False: 667]
  ------------------
  742|      2|         throw BER_Decoding_Error("Invalid BIT STRING");
  743|      2|      }
  744|       |
  745|       |      // DER requires unused bits in BIT STRING to be zero (X.690 section 11.2.2)
  746|  3.16k|      if(require_der && unused_bits > 0) {
  ------------------
  |  Branch (746:10): [True: 3.10k, False: 54]
  |  Branch (746:25): [True: 667, False: 2.43k]
  ------------------
  747|    667|         const uint8_t last_byte = obj.bits()[obj.length() - 1];
  748|    667|         if((last_byte & ((1 << unused_bits) - 1)) != 0) {
  ------------------
  |  Branch (748:13): [True: 9, False: 658]
  ------------------
  749|      9|            throw BER_Decoding_Error("Detected non-zero padding bits in BIT STRING in DER structure");
  750|      9|         }
  751|    667|      }
  752|       |
  753|  3.15k|      buffer.resize(obj.length() - 1);
  754|       |
  755|  3.15k|      if(obj.length() > 1) {
  ------------------
  |  Branch (755:10): [True: 3.09k, False: 55]
  ------------------
  756|  3.09k|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  757|  3.09k|      }
  758|  3.15k|   }
  759|  15.8k|}

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

_ZN5Botan13base64_decodeEPKcmb:
  189|    152|secure_vector<uint8_t> base64_decode(const char input[], size_t input_length, bool ignore_ws) {
  190|    152|   return base_decode_to_vec<secure_vector<uint8_t>>(Base64(), input, input_length, ignore_ws);
  191|    152|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6417decode_max_outputEm:
   43|    304|      static constexpr size_t decode_max_output(size_t input_length) {
   44|       |         // Divide before multiply to avoid overflow; round_up makes the division exact.
   45|    304|         return (round_up(input_length, m_encoding_bytes_out) / m_encoding_bytes_out) * m_encoding_bytes_in;
   46|    304|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6413bits_consumedEv:
   34|     42|      static constexpr size_t bits_consumed() noexcept { return m_encoding_bits; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEc:
  112|  45.7k|uint8_t Base64::lookup_binary_value(char input) noexcept {
  113|  45.7k|   auto has_zero_byte = [](uint64_t v) { return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080); };
  114|       |
  115|       |   // Assumes each byte is either 0x00 or 0x80
  116|  45.7k|   auto index_of_first_set_byte = [](uint64_t v) {
  117|  45.7k|      return ((((v - 1) & 0x0101010101010101) * 0x0101010101010101) >> 56) - 1;
  118|  45.7k|   };
  119|       |
  120|  45.7k|   constexpr uint64_t lo = 0x0101010101010101;
  121|       |
  122|  45.7k|   const uint8_t x = static_cast<uint8_t>(input);
  123|       |
  124|  45.7k|   const uint64_t x8 = x * lo;
  125|       |
  126|       |   // Defines the valid ASCII ranges of base64, except the special chars (below)
  127|  45.7k|   constexpr uint64_t val_l = make_uint64(0, 0, 0, 0, 0, 'A', 'a', '0');
  128|  45.7k|   constexpr uint64_t val_u = make_uint64(0, 0, 0, 0, 0, 26, 26, 10);
  129|       |
  130|       |   // If x is in one of the ranges return a mask. Otherwise we xor in at the
  131|       |   // high word which will be our invalid marker
  132|  45.7k|   auto v_mask = swar_in_range<uint64_t>(x8, val_l, val_u) ^ 0x80000000;
  133|       |
  134|       |   // This is the offset added to x to get the value
  135|  45.7k|   const uint64_t val_v = 0xbfb904 ^ (0xFF000000 - (x << 24));
  136|       |
  137|  45.7k|   const uint8_t z = x + static_cast<uint8_t>(val_v >> (8 * index_of_first_set_byte(v_mask)));
  138|       |
  139|       |   // Valid base64 special characters, and some whitespace chars
  140|  45.7k|   constexpr uint64_t specials_i = make_uint64(0, '+', '/', '=', ' ', '\n', '\t', '\r');
  141|       |
  142|  45.7k|   const uint64_t specials_v = 0x3e3f8180808080 ^ (static_cast<uint64_t>(z) << 56);
  143|       |
  144|  45.7k|   const uint64_t smask = has_zero_byte(x8 ^ specials_i) ^ 0x8000000000000000;
  145|       |
  146|  45.7k|   return static_cast<uint8_t>(specials_v >> (8 * index_of_first_set_byte(smask)));
  147|  45.7k|}
base64.cpp:_ZZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEcENK3$_0clEm:
  116|  91.4k|   auto index_of_first_set_byte = [](uint64_t v) {
  117|  91.4k|      return ((((v - 1) & 0x0101010101010101) * 0x0101010101010101) >> 56) - 1;
  118|  91.4k|   };
base64.cpp:_ZZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEcENK3$_1clEm:
  113|  45.7k|   auto has_zero_byte = [](uint64_t v) { return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080); };
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6414check_bad_charEhcb:
  150|  43.0k|bool Base64::check_bad_char(uint8_t bin, char input, bool ignore_ws) {
  151|  43.0k|   if(bin <= 0x3F) {
  ------------------
  |  Branch (151:7): [True: 15.0k, False: 28.0k]
  ------------------
  152|  15.0k|      return true;
  153|  28.0k|   } else if(!(bin == 0x81 || (bin == 0x80 && ignore_ws))) {
  ------------------
  |  Branch (153:16): [True: 373, False: 27.6k]
  |  Branch (153:32): [True: 27.6k, False: 28]
  |  Branch (153:47): [True: 27.6k, False: 0]
  ------------------
  154|     28|      throw Invalid_Argument(fmt("base64_decode: invalid character '{}'", format_char_for_display(input)));
  155|     28|   }
  156|  27.9k|   return false;
  157|  43.0k|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base644nameEv:
   24|     60|      static std::string name() { return "base64"; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base646decodeEPhPKh:
   54|  3.74k|      static void decode(uint8_t* out_ptr, const uint8_t decode_buf[4]) {
   55|  3.74k|         out_ptr[0] = (decode_buf[0] << 2) | (decode_buf[1] >> 4);
   56|  3.74k|         out_ptr[1] = (decode_buf[1] << 4) | (decode_buf[2] >> 2);
   57|  3.74k|         out_ptr[2] = (decode_buf[2] << 6) | decode_buf[3];
   58|  3.74k|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6415bytes_to_removeEm:
   60|     83|      static size_t bytes_to_remove(size_t final_truncate) { return final_truncate; }

_ZNK5Botan6BigInt7byte_atEm:
  118|  23.2k|uint8_t BigInt::byte_at(size_t n) const {
  119|  23.2k|   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));
  120|  23.2k|}
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  191|  15.4k|void BigInt::Data::set_to_zero() {
  192|  15.4k|   m_reg.resize(m_reg.capacity());
  193|  15.4k|   clear_mem(m_reg.data(), m_reg.size());
  194|  15.4k|   m_sig_words = 0;
  195|  15.4k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  215|  15.4k|size_t BigInt::Data::calc_sig_words() const {
  216|  15.4k|   const size_t sz = m_reg.size();
  217|  15.4k|   size_t sig = sz;
  218|       |
  219|  15.4k|   word sub = 1;
  220|       |
  221|   139k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (221:22): [True: 124k, False: 15.4k]
  ------------------
  222|   124k|      const word w = m_reg[sz - i - 1];
  223|   124k|      sub &= ct_is_zero(w);
  224|   124k|      sig -= sub;
  225|   124k|   }
  226|       |
  227|       |   /*
  228|       |   * This depends on the data so is poisoned, but unpoison it here as
  229|       |   * later conditionals are made on the size.
  230|       |   */
  231|  15.4k|   CT::unpoison(sig);
  232|       |
  233|  15.4k|   return sig;
  234|  15.4k|}
_ZNK5Botan6BigInt5bytesEv:
  294|  19.0k|size_t BigInt::bytes() const {
  295|  19.0k|   return round_up(bits(), 8) / 8;
  296|  19.0k|}
_ZNK5Botan6BigInt13top_bits_freeEv:
  298|  24.9k|size_t BigInt::top_bits_free() const {
  299|  24.9k|   const size_t words = sig_words();
  300|       |
  301|  24.9k|   const word top_word = word_at(words - 1);
  302|  24.9k|   const size_t bits_used = high_bit(CT::value_barrier(top_word));
  303|  24.9k|   CT::unpoison(bits_used);
  304|  24.9k|   return WordInfo<word>::bits - bits_used;
  305|  24.9k|}
_ZNK5Botan6BigInt4bitsEv:
  307|  24.9k|size_t BigInt::bits() const {
  308|  24.9k|   const size_t words = sig_words();
  309|       |
  310|  24.9k|   if(words == 0) {
  ------------------
  |  Branch (310:7): [True: 9, False: 24.9k]
  ------------------
  311|      9|      return 0;
  312|      9|   }
  313|       |
  314|  24.9k|   const size_t full_words = (words - 1) * WordInfo<word>::bits;
  315|  24.9k|   const size_t top_bits = WordInfo<word>::bits - top_bits_free();
  316|       |
  317|  24.9k|   return full_words + top_bits;
  318|  24.9k|}
_ZNK5Botan6BigInt12serialize_toENSt3__14spanIhLm18446744073709551615EEE:
  395|  9.51k|void BigInt::serialize_to(std::span<uint8_t> output) const {
  396|  9.51k|   BOTAN_ARG_CHECK(this->bytes() <= output.size(), "Insufficient output space");
  ------------------
  |  |   35|  9.51k|   do {                                                          \
  |  |   36|  9.51k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  9.51k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 9.51k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  9.51k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 9.51k]
  |  |  ------------------
  ------------------
  397|       |
  398|  9.51k|   this->binary_encode(output.data(), output.size());
  399|  9.51k|}
_ZNK5Botan6BigInt13binary_encodeEPhm:
  404|  9.51k|void BigInt::binary_encode(uint8_t output[], size_t len) const {
  405|  9.51k|   const size_t full_words = len / sizeof(word);
  406|  9.51k|   const size_t extra_bytes = len % sizeof(word);
  407|       |
  408|  9.52k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (408:22): [True: 6, False: 9.51k]
  ------------------
  409|      6|      const word w = word_at(i);
  410|      6|      store_be(w, output + (len - (i + 1) * sizeof(word)));
  411|      6|   }
  412|       |
  413|  9.51k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (413:7): [True: 9.51k, False: 1]
  ------------------
  414|  9.51k|      const word w = word_at(full_words);
  415|       |
  416|  28.3k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (416:25): [True: 18.8k, False: 9.51k]
  ------------------
  417|  18.8k|         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);
  418|  18.8k|      }
  419|  9.51k|   }
  420|  9.51k|}
_ZN5Botan6BigInt17assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  425|  15.4k|void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {
  426|  15.4k|   clear();
  427|       |
  428|  15.4k|   const size_t length = bytes.size();
  429|  15.4k|   const size_t full_words = length / sizeof(word);
  430|  15.4k|   const size_t extra_bytes = length % sizeof(word);
  431|       |
  432|  15.4k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (432:52): [True: 15.4k, False: 27]
  ------------------
  433|       |
  434|  16.6k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (434:22): [True: 1.20k, False: 15.4k]
  ------------------
  435|  1.20k|      reg[i] = load_be<word>(bytes.last<sizeof(word)>());
  436|  1.20k|      bytes = bytes.first(bytes.size() - sizeof(word));
  437|  1.20k|   }
  438|       |
  439|  15.4k|   if(!bytes.empty()) {
  ------------------
  |  Branch (439:7): [True: 15.4k, False: 27]
  ------------------
  440|  15.4k|      BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());
  ------------------
  |  |   77|  15.4k|   do {                                                                     \
  |  |   78|  15.4k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   79|  15.4k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 0, False: 15.4k]
  |  |  ------------------
  |  |   80|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   81|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   82|      0|      }                                                                     \
  |  |   83|  15.4k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 15.4k]
  |  |  ------------------
  ------------------
  441|  15.4k|      std::array<uint8_t, sizeof(word)> last_partial_word = {0};
  442|  15.4k|      copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);
  443|  15.4k|      reg[full_words] = load_be<word>(last_partial_word);
  444|  15.4k|   }
  445|       |
  446|  15.4k|   m_data.swap(reg);
  447|  15.4k|}
_ZNK5Botan6BigInt20_const_time_unpoisonEv:
  559|  15.7k|void BigInt::_const_time_unpoison() const {
  560|  15.7k|   CT::unpoison(m_data.const_data(), m_data.size());
  561|  15.7k|}

_ZN5Botan8PEM_Code6decodeERNS_10DataSourceERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   62|    324|secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   63|    324|   const size_t RANDOM_CHAR_LIMIT = 8;
   64|       |
   65|    324|   label.clear();
   66|       |
   67|    324|   const std::string PEM_HEADER1 = "-----BEGIN ";
   68|    324|   const std::string PEM_HEADER2 = "-----";
   69|    324|   size_t position = 0;
   70|       |
   71|  14.1k|   while(position != PEM_HEADER1.length()) {
  ------------------
  |  Branch (71:10): [True: 13.8k, False: 278]
  ------------------
   72|  13.8k|      auto b = source.read_byte();
   73|       |
   74|  13.8k|      if(!b) {
  ------------------
  |  Branch (74:10): [True: 45, False: 13.8k]
  ------------------
   75|     45|         throw Decoding_Error("PEM: No PEM header found");
   76|     45|      }
   77|  13.8k|      if(static_cast<char>(*b) == PEM_HEADER1[position]) {
  ------------------
  |  Branch (77:10): [True: 3.31k, False: 10.5k]
  ------------------
   78|  3.31k|         ++position;
   79|  10.5k|      } else if(position >= RANDOM_CHAR_LIMIT) {
  ------------------
  |  Branch (79:17): [True: 1, False: 10.5k]
  ------------------
   80|      1|         throw Decoding_Error("PEM: Malformed PEM header");
   81|  10.5k|      } else {
   82|  10.5k|         position = 0;
   83|  10.5k|      }
   84|  13.8k|   }
   85|    278|   position = 0;
   86|  3.80k|   while(position != PEM_HEADER2.length()) {
  ------------------
  |  Branch (86:10): [True: 3.56k, False: 236]
  ------------------
   87|  3.56k|      auto b = source.read_byte();
   88|       |
   89|  3.56k|      if(!b) {
  ------------------
  |  Branch (89:10): [True: 39, False: 3.52k]
  ------------------
   90|     39|         throw Decoding_Error("PEM: No PEM header found");
   91|     39|      }
   92|  3.52k|      if(static_cast<char>(*b) == PEM_HEADER2[position]) {
  ------------------
  |  Branch (92:10): [True: 1.19k, False: 2.32k]
  ------------------
   93|  1.19k|         ++position;
   94|  2.32k|      } else if(position > 0) {
  ------------------
  |  Branch (94:17): [True: 2, False: 2.32k]
  ------------------
   95|      2|         throw Decoding_Error("PEM: Malformed PEM header");
   96|      2|      }
   97|       |
   98|  3.52k|      if(position == 0) {
  ------------------
  |  Branch (98:10): [True: 2.32k, False: 1.19k]
  ------------------
   99|  2.32k|         if(label.size() >= 128) {
  ------------------
  |  Branch (99:13): [True: 1, False: 2.32k]
  ------------------
  100|      1|            throw Decoding_Error("PEM: Label too long");
  101|      1|         }
  102|  2.32k|         label += static_cast<char>(*b);
  103|  2.32k|      }
  104|  3.52k|   }
  105|       |
  106|    236|   std::vector<char> b64;
  107|       |
  108|    236|   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
  109|    236|   position = 0;
  110|  71.0k|   while(position != PEM_TRAILER.length()) {
  ------------------
  |  Branch (110:10): [True: 70.8k, False: 152]
  ------------------
  111|  70.8k|      auto b = source.read_byte();
  112|       |
  113|  70.8k|      if(!b) {
  ------------------
  |  Branch (113:10): [True: 73, False: 70.8k]
  ------------------
  114|     73|         throw Decoding_Error("PEM: No PEM trailer found");
  115|     73|      }
  116|  70.8k|      if(static_cast<char>(*b) == PEM_TRAILER[position]) {
  ------------------
  |  Branch (116:10): [True: 3.01k, False: 67.7k]
  ------------------
  117|  3.01k|         ++position;
  118|  67.7k|      } else if(position > 0) {
  ------------------
  |  Branch (118:17): [True: 11, False: 67.7k]
  ------------------
  119|     11|         throw Decoding_Error("PEM: Malformed PEM trailer");
  120|     11|      }
  121|       |
  122|  70.7k|      if(position == 0) {
  ------------------
  |  Branch (122:10): [True: 67.7k, False: 3.01k]
  ------------------
  123|  67.7k|         b64.push_back(*b);
  124|  67.7k|      }
  125|  70.7k|   }
  126|       |
  127|    152|   return base64_decode(b64.data(), b64.size());
  128|    236|}
_ZN5Botan8PEM_Code7matchesERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
  143|  3.75k|bool matches(DataSource& source, std::string_view extra, size_t search_range) {
  144|  3.75k|   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
  145|       |
  146|  3.75k|   secure_vector<uint8_t> search_buf(search_range);
  147|  3.75k|   const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);
  148|       |
  149|  3.75k|   if(got < PEM_HEADER.length()) {
  ------------------
  |  Branch (149:7): [True: 371, False: 3.38k]
  ------------------
  150|    371|      return false;
  151|    371|   }
  152|       |
  153|  3.38k|   size_t index = 0;
  154|       |
  155|  3.09M|   for(size_t j = 0; j != got; ++j) {
  ------------------
  |  Branch (155:22): [True: 3.09M, False: 3.37k]
  ------------------
  156|  3.09M|      if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
  ------------------
  |  Branch (156:10): [True: 11.9k, False: 3.07M]
  ------------------
  157|  11.9k|         ++index;
  158|  3.07M|      } else {
  159|  3.07M|         index = 0;
  160|  3.07M|      }
  161|       |
  162|  3.09M|      if(index == PEM_HEADER.size()) {
  ------------------
  |  Branch (162:10): [True: 10, False: 3.09M]
  ------------------
  163|     10|         return true;
  164|     10|      }
  165|  3.09M|   }
  166|       |
  167|  3.37k|   return false;
  168|  3.38k|}

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

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

_ZN5Botan19next_utf8_codepointENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEERm:
   53|    204|uint32_t next_utf8_codepoint(std::string_view utf8, size_t& pos) {
   54|    204|   auto read_continuation = [&]() -> uint32_t {
   55|    204|      if(pos >= utf8.size()) {
   56|    204|         throw Decoding_Error("Invalid UTF-8 sequence");
   57|    204|      }
   58|    204|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   59|    204|      if((b & 0xC0) != 0x80) {
   60|    204|         throw Decoding_Error("Invalid UTF-8 sequence");
   61|    204|      }
   62|    204|      return b & 0x3F;
   63|    204|   };
   64|       |
   65|    204|   const uint8_t lead = static_cast<uint8_t>(utf8[pos++]);
   66|    204|   uint32_t c = 0;
   67|       |
   68|    204|   if(lead <= 0x7F) {
  ------------------
  |  Branch (68:7): [True: 169, False: 35]
  ------------------
   69|    169|      c = lead;
   70|    169|   } else if((lead & 0xE0) == 0xC0) {
  ------------------
  |  Branch (70:14): [True: 17, False: 18]
  ------------------
   71|     17|      c = (lead & 0x1F) << 6;
   72|     17|      c |= read_continuation();
   73|     17|      if(c < 0x80) {
  ------------------
  |  Branch (73:10): [True: 0, False: 17]
  ------------------
   74|      0|         throw Decoding_Error("Overlong UTF-8 sequence");
   75|      0|      }
   76|     18|   } else if((lead & 0xF0) == 0xE0) {
  ------------------
  |  Branch (76:14): [True: 0, False: 18]
  ------------------
   77|      0|      c = (lead & 0x0F) << 12;
   78|      0|      c |= read_continuation() << 6;
   79|      0|      c |= read_continuation();
   80|      0|      if(c < 0x800) {
  ------------------
  |  Branch (80:10): [True: 0, False: 0]
  ------------------
   81|      0|         throw Decoding_Error("Overlong UTF-8 sequence");
   82|      0|      }
   83|     18|   } else if((lead & 0xF8) == 0xF0) {
  ------------------
  |  Branch (83:14): [True: 0, False: 18]
  ------------------
   84|      0|      c = (lead & 0x07) << 18;
   85|      0|      c |= read_continuation() << 12;
   86|      0|      c |= read_continuation() << 6;
   87|      0|      c |= read_continuation();
   88|      0|      if(c < 0x10000) {
  ------------------
  |  Branch (88:10): [True: 0, False: 0]
  ------------------
   89|      0|         throw Decoding_Error("Overlong UTF-8 sequence");
   90|      0|      }
   91|     18|   } else {
   92|     18|      throw Decoding_Error("Invalid UTF-8 sequence");
   93|     18|   }
   94|       |
   95|    186|   if(c > 0x10FFFF) {
  ------------------
  |  Branch (95:7): [True: 0, False: 186]
  ------------------
   96|      0|      throw Decoding_Error("UTF-8 sequence encodes value outside Unicode range");
   97|      0|   }
   98|    186|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (98:7): [True: 0, False: 186]
  |  Branch (98:22): [True: 0, False: 0]
  ------------------
   99|      0|      throw Decoding_Error("UTF-8 sequence encodes surrogate code point");
  100|      0|   }
  101|       |
  102|    186|   return c;
  103|    186|}
_ZN5Botan13is_valid_utf8ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  105|     35|bool is_valid_utf8(std::string_view utf8) {
  106|     35|   try {
  107|     35|      size_t pos = 0;
  108|    239|      while(pos < utf8.size()) {
  ------------------
  |  Branch (108:13): [True: 204, False: 35]
  ------------------
  109|    204|         const uint32_t c = next_utf8_codepoint(utf8, pos);
  110|    204|         BOTAN_UNUSED(c);
  ------------------
  |  |  144|    204|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  111|    204|      }
  112|     35|   } catch(Decoding_Error&) {
  113|     35|      return false;
  114|     35|   }
  115|      0|   return true;
  116|     35|}
_ZN5Botan14latin1_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  187|      5|std::string latin1_to_utf8(std::span<const uint8_t> chars) {
  188|      5|   std::string s;
  189|     30|   for(const uint8_t b : chars) {
  ------------------
  |  Branch (189:24): [True: 30, False: 5]
  ------------------
  190|     30|      append_utf8_for(s, static_cast<uint32_t>(b));
  191|     30|   }
  192|      5|   return s;
  193|      5|}
_ZN5Botan21is_ascii_control_charEc:
  195|     28|bool is_ascii_control_char(char c) {
  196|     28|   const uint8_t b = static_cast<uint8_t>(c);
  197|     28|   return b < 0x20 || b == 0x7F;
  ------------------
  |  Branch (197:11): [True: 10, False: 18]
  |  Branch (197:23): [True: 0, False: 18]
  ------------------
  198|     28|}
_ZN5Botan23format_char_for_displayEc:
  240|     28|std::string format_char_for_display(char c) {
  241|     28|   std::string out;
  242|     28|   out += '\'';
  243|       |
  244|     28|   if(c == '\t') {
  ------------------
  |  Branch (244:7): [True: 0, False: 28]
  ------------------
  245|      0|      out += "\\t";
  246|     28|   } else if(c == '\n') {
  ------------------
  |  Branch (246:14): [True: 0, False: 28]
  ------------------
  247|      0|      out += "\\n";
  248|     28|   } else if(c == '\r') {
  ------------------
  |  Branch (248:14): [True: 0, False: 28]
  ------------------
  249|      0|      out += "\\r";
  250|     28|   } else if(is_ascii_control_char(c) || static_cast<uint8_t>(c) >= 0x80) {
  ------------------
  |  Branch (250:14): [True: 10, False: 18]
  |  Branch (250:42): [True: 13, False: 5]
  ------------------
  251|     23|      const auto b = static_cast<uint8_t>(c);
  252|     23|      out += "\\x";
  253|     23|      out += nibble_to_hex(b >> 4);
  254|     23|      out += nibble_to_hex(b);
  255|     23|   } else {
  256|      5|      out += c;
  257|      5|   }
  258|       |
  259|     28|   out += '\'';
  260|       |
  261|     28|   return out;
  262|     28|}
charset.cpp:_ZZN5Botan19next_utf8_codepointENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEERmENK3$_0clEv:
   54|     17|   auto read_continuation = [&]() -> uint32_t {
   55|     17|      if(pos >= utf8.size()) {
  ------------------
  |  Branch (55:10): [True: 16, False: 1]
  ------------------
   56|     16|         throw Decoding_Error("Invalid UTF-8 sequence");
   57|     16|      }
   58|      1|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   59|      1|      if((b & 0xC0) != 0x80) {
  ------------------
  |  Branch (59:10): [True: 1, False: 0]
  ------------------
   60|      1|         throw Decoding_Error("Invalid UTF-8 sequence");
   61|      1|      }
   62|      0|      return b & 0x3F;
   63|      1|   };
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   17|     30|void append_utf8_for(std::string& s, uint32_t c) {
   18|     30|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (18:7): [True: 0, False: 30]
  |  Branch (18:22): [True: 0, False: 0]
  ------------------
   19|      0|      throw Decoding_Error("Invalid Unicode character");
   20|      0|   }
   21|       |
   22|     30|   if(c <= 0x7F) {
  ------------------
  |  Branch (22:7): [True: 26, False: 4]
  ------------------
   23|     26|      const uint8_t b0 = static_cast<uint8_t>(c);
   24|     26|      s.push_back(static_cast<char>(b0));
   25|     26|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (25:14): [True: 4, False: 0]
  ------------------
   26|      4|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   27|      4|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   28|      4|      s.push_back(static_cast<char>(b0));
   29|      4|      s.push_back(static_cast<char>(b1));
   30|      4|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (30:14): [True: 0, False: 0]
  ------------------
   31|      0|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   32|      0|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   33|      0|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   34|      0|      s.push_back(static_cast<char>(b0));
   35|      0|      s.push_back(static_cast<char>(b1));
   36|      0|      s.push_back(static_cast<char>(b2));
   37|      0|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (37:14): [True: 0, False: 0]
  ------------------
   38|      0|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   39|      0|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   40|      0|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   41|      0|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   42|      0|      s.push_back(static_cast<char>(b0));
   43|      0|      s.push_back(static_cast<char>(b1));
   44|      0|      s.push_back(static_cast<char>(b2));
   45|      0|      s.push_back(static_cast<char>(b3));
   46|      0|   } else {
   47|      0|      throw Decoding_Error("Invalid Unicode character");
   48|      0|   }
   49|     30|}

_ZN5Botan10DataSource9read_byteERh:
   27|  3.63M|size_t DataSource::read_byte(uint8_t& out) {
   28|  3.63M|   return read(&out, 1);
   29|  3.63M|}
_ZN5Botan10DataSource9read_byteEv:
   34|   210k|std::optional<uint8_t> DataSource::read_byte() {
   35|   210k|   uint8_t b = 0;
   36|   210k|   if(this->read(&b, 1) == 1) {
  ------------------
  |  Branch (36:7): [True: 210k, False: 283]
  ------------------
   37|   210k|      return b;
   38|   210k|   } else {
   39|    283|      return {};
   40|    283|   }
   41|   210k|}
_ZNK5Botan10DataSource9peek_byteERh:
   46|  4.06k|size_t DataSource::peek_byte(uint8_t& out) const {
   47|  4.06k|   return peek(&out, 1, 0);
   48|  4.06k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   73|   181k|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   74|   181k|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   75|   181k|   copy_mem(out, m_source.data() + m_offset, got);
   76|   181k|   m_offset += got;
   77|   181k|   return got;
   78|   181k|}
_ZN5Botan17DataSource_Memory15check_availableEm:
   80|  28.7k|bool DataSource_Memory::check_available(size_t n) {
   81|  28.7k|   return (n <= (m_source.size() - m_offset));
   82|  28.7k|}
_ZNK5Botan17DataSource_Memory4peekEPhmm:
   87|  7.82k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   88|  7.82k|   const size_t bytes_left = m_source.size() - m_offset;
   89|  7.82k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (89:7): [True: 0, False: 7.82k]
  ------------------
   90|      0|      return 0;
   91|      0|   }
   92|       |
   93|  7.82k|   const size_t got = std::min(bytes_left - peek_offset, length);
   94|  7.82k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   95|  7.82k|   return got;
   96|  7.82k|}
_ZNK5Botan17DataSource_Memory11end_of_dataEv:
  101|  15.9k|bool DataSource_Memory::end_of_data() const {
  102|  15.9k|   return (m_offset == m_source.size());
  103|  15.9k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  4.28k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
   73|  3.92k|Exception::Exception(std::string_view msg, const std::exception& e) : m_msg(fmt("{} failed with {}", msg, e.what())) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|     91|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  4.19k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
  130|  3.92k|Decoding_Error::Decoding_Error(std::string_view msg, const std::exception& e) : Exception(msg, e) {}

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

_ZN5Botan9parse_u32ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   59|  58.5k|std::optional<uint32_t> parse_u32(std::string_view input) {
   60|  58.5k|   return parse_decimal_integer<uint32_t>(input);
   61|  58.5k|}
_ZN5Botan9to_u32bitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   71|  58.5k|uint32_t to_u32bit(std::string_view input) {
   72|  58.5k|   if(const auto parsed = parse_u32(input)) {
  ------------------
  |  Branch (72:18): [True: 58.5k, False: 0]
  ------------------
   73|  58.5k|      return *parsed;
   74|  58.5k|   } else {
   75|      0|      throw Invalid_Argument(fmt("Failed to parse input '{}' as a 32-bit integer", input));
   76|      0|   }
   77|  58.5k|}
parsing.cpp:_ZN5Botan12_GLOBAL__N_116digit_from_asciiEc:
   23|   117k|std::optional<size_t> digit_from_ascii(char c) {
   24|   117k|   if(c >= '0' && c <= '9') {
  ------------------
  |  Branch (24:7): [True: 117k, False: 0]
  |  Branch (24:19): [True: 117k, False: 0]
  ------------------
   25|   117k|      return c - '0';
   26|   117k|   } else {
   27|      0|      return {};
   28|      0|   }
   29|   117k|}
parsing.cpp:_ZN5Botan12_GLOBAL__N_121parse_decimal_integerITkNSt3__117unsigned_integralEjEENS2_8optionalIT_EENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   32|  58.5k|std::optional<T> parse_decimal_integer(std::string_view input) {
   33|  58.5k|   if(input.empty() || input.size() > (std::numeric_limits<T>::digits10 + 1)) {
  ------------------
  |  Branch (33:7): [True: 0, False: 58.5k]
  |  Branch (33:24): [True: 0, False: 58.5k]
  ------------------
   34|      0|      return {};
   35|      0|   }
   36|       |
   37|  58.5k|   T accum = 0;
   38|       |
   39|   117k|   for(const char c : input) {
  ------------------
  |  Branch (39:21): [True: 117k, False: 58.5k]
  ------------------
   40|   117k|      if(const auto digit = digit_from_ascii(c)) {
  ------------------
  |  Branch (40:21): [True: 117k, False: 0]
  ------------------
   41|   117k|         if(accum > (std::numeric_limits<T>::max() - static_cast<T>(*digit)) / 10) {
  ------------------
  |  Branch (41:13): [True: 0, False: 117k]
  ------------------
   42|      0|            return {};
   43|      0|         }
   44|   117k|         accum = accum * 10 + static_cast<T>(*digit);
   45|   117k|      } else {
   46|      0|         return {};
   47|      0|      }
   48|   117k|   }
   49|       |
   50|  58.5k|   return accum;
   51|  58.5k|}

_ZN5Botan9CRL_Entry11decode_fromERNS_11BER_DecoderE:
   85|  9.55k|void CRL_Entry::decode_from(BER_Decoder& source) {
   86|  9.55k|   auto data = std::make_unique<CRL_Entry_Data>();
   87|       |
   88|  9.55k|   BER_Decoder entry = source.start_sequence();
   89|       |
   90|  9.55k|   BigInt serial;
   91|  9.55k|   entry.decode(serial);
   92|  9.55k|   data->m_serial = serial.serialize();
   93|       |
   94|  9.55k|   entry.decode(data->m_time);
   95|       |
   96|  9.55k|   if(entry.more_items()) {
  ------------------
  |  Branch (96:7): [True: 9.51k, False: 40]
  ------------------
   97|  9.51k|      data->m_extensions.decode_from(entry, Extension_Context::CRL_Entry);
   98|  9.51k|      if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_ReasonCode>()) {
  ------------------
  |  Branch (98:22): [True: 2.83k, False: 6.68k]
  ------------------
   99|  2.83k|         data->m_reason = ext->get_reason();
  100|  6.68k|      } else {
  101|  6.68k|         data->m_reason = CRL_Code::Unspecified;
  102|  6.68k|      }
  103|  9.51k|   }
  104|       |
  105|  9.55k|   entry.end_cons();
  106|       |
  107|  9.55k|   m_data = std::move(data);
  108|  9.55k|}
_ZNK5Botan9CRL_Entry4dataEv:
  110|  16.4k|const CRL_Entry_Data& CRL_Entry::data() const {
  111|  16.4k|   if(!m_data) {
  ------------------
  |  Branch (111:7): [True: 0, False: 16.4k]
  ------------------
  112|      0|      throw Invalid_State("CRL_Entry_Data uninitialized");
  113|      0|   }
  114|       |
  115|  16.4k|   return *m_data;
  116|  16.4k|}
_ZNK5Botan9CRL_Entry13serial_numberEv:
  118|  6.98k|const std::vector<uint8_t>& CRL_Entry::serial_number() const {
  119|  6.98k|   return data().m_serial;
  120|  6.98k|}
_ZNK5Botan9CRL_Entry10extensionsEv:
  130|  9.48k|const Extensions& CRL_Entry::extensions() const {
  131|  9.48k|   return data().m_extensions;
  132|  9.48k|}
_ZN5Botan14CRL_Entry_DataC2Ev:
   29|  9.55k|      CRL_Entry_Data() = default;

_ZNK5Botan8X509_CRL9PEM_labelEv:
   59|  4.05k|std::string X509_CRL::PEM_label() const {
   60|  4.05k|   return "X509 CRL";
   61|  4.05k|}
_ZNK5Botan8X509_CRL20alternate_PEM_labelsEv:
   63|     61|std::vector<std::string> X509_CRL::alternate_PEM_labels() const {
   64|     61|   return {"CRL"};
   65|     61|}
_ZN5Botan8X509_CRLC2ERNS_10DataSourceE:
   67|  4.06k|X509_CRL::X509_CRL(DataSource& src) {
   68|  4.06k|   load_data(src);
   69|  4.06k|}
_ZN5Botan8X509_CRL12force_decodeEv:
  216|  3.08k|void X509_CRL::force_decode() {
  217|  3.08k|   m_data.reset(decode_crl_body(signed_body(), signature_algorithm()).release());
  218|  3.08k|}
x509_crl.cpp:_ZN5Botan12_GLOBAL__N_115decode_crl_bodyERKNSt3__16vectorIhNS1_9allocatorIhEEEERKNS_19AlgorithmIdentifierE:
  127|  3.08k|std::unique_ptr<CRL_Data> decode_crl_body(const std::vector<uint8_t>& body, const AlgorithmIdentifier& sig_algo) {
  128|  3.08k|   auto data = std::make_unique<CRL_Data>();
  129|       |
  130|  3.08k|   BER_Decoder tbs_crl(body, BER_Decoder::Limits::DER());
  131|       |
  132|  3.08k|   tbs_crl.decode_optional(data->m_version, ASN1_Type::Integer, ASN1_Class::Universal);
  133|  3.08k|   data->m_version += 1;  // wire-format is 0-based
  134|       |
  135|  3.08k|   if(data->m_version != 1 && data->m_version != 2) {
  ------------------
  |  Branch (135:7): [True: 2.92k, False: 159]
  |  Branch (135:31): [True: 47, False: 2.87k]
  ------------------
  136|     47|      throw Decoding_Error("Unknown X.509 CRL version " + std::to_string(data->m_version));
  137|     47|   }
  138|       |
  139|  3.03k|   AlgorithmIdentifier sig_algo_inner;
  140|  3.03k|   tbs_crl.decode(sig_algo_inner);
  141|       |
  142|  3.03k|   if(sig_algo != sig_algo_inner) {
  ------------------
  |  Branch (142:7): [True: 97, False: 2.94k]
  ------------------
  143|     97|      throw Decoding_Error("Algorithm identifier mismatch in CRL");
  144|     97|   }
  145|       |
  146|  2.94k|   tbs_crl.decode(data->m_issuer).decode(data->m_this_update);
  147|       |
  148|       |   // According to RFC 5280 Section 5.1, nextUpdate is OPTIONAL and may be
  149|       |   // encoded as either a UTCTime or a GeneralizedTime. Section 5.1.2.5
  150|       |   // further states that "[c]onforming CRL issuers MUST include the nextUpdate
  151|       |   // field in all CRLs". Obviously, not everyone complies...
  152|       |   //
  153|       |   // See https://github.com/randombit/botan/issues/4722 for more details.
  154|  2.94k|   {
  155|  2.94k|      const auto& next_update = tbs_crl.peek_next_object();
  156|  2.94k|      if(next_update.is_a(ASN1_Type::UtcTime, ASN1_Class::Universal) ||
  ------------------
  |  Branch (156:10): [True: 2.94k, False: 0]
  ------------------
  157|    122|         next_update.is_a(ASN1_Type::GeneralizedTime, ASN1_Class::Universal)) {
  ------------------
  |  Branch (157:10): [True: 0, False: 0]
  ------------------
  158|    122|         tbs_crl.decode(data->m_next_update);
  159|    122|      }
  160|  2.94k|   }
  161|       |
  162|  2.94k|   BER_Object next = tbs_crl.get_next_object();
  163|       |
  164|  2.94k|   if(next.is_a(ASN1_Type::Sequence, ASN1_Class::Constructed)) {
  ------------------
  |  Branch (164:7): [True: 121, False: 2.82k]
  ------------------
  165|    121|      BER_Decoder cert_list(next, tbs_crl.limits());
  166|       |
  167|  9.67k|      while(cert_list.more_items()) {
  ------------------
  |  Branch (167:13): [True: 9.55k, False: 121]
  ------------------
  168|  9.55k|         CRL_Entry entry;
  169|  9.55k|         cert_list.decode(entry);
  170|       |
  171|  9.55k|         if(entry.extensions().has_unknown_critical_extension()) {
  ------------------
  |  Branch (171:13): [True: 0, False: 9.55k]
  ------------------
  172|      0|            data->m_has_unknown_critical_extension = true;
  173|      0|         }
  174|       |
  175|  9.55k|         data->m_entries.push_back(std::move(entry));
  176|  9.55k|      }
  177|    121|      next = tbs_crl.get_next_object();
  178|    121|   }
  179|       |
  180|  2.94k|   if(next.is_a(0, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (180:7): [True: 50, False: 2.89k]
  ------------------
  181|     50|      BER_Decoder crl_options(next, tbs_crl.limits());
  182|     50|      data->m_extensions.decode_from(crl_options, Extension_Context::CRL);
  183|     50|      crl_options.verify_end();
  184|     50|      next = tbs_crl.get_next_object();
  185|     50|      if(data->m_extensions.has_unknown_critical_extension()) {
  ------------------
  |  Branch (185:10): [True: 0, False: 50]
  ------------------
  186|      0|         data->m_has_unknown_critical_extension = true;
  187|      0|      }
  188|     50|   }
  189|       |
  190|  2.94k|   if(next.is_set()) {
  ------------------
  |  Branch (190:7): [True: 0, False: 2.94k]
  ------------------
  191|      0|      throw Decoding_Error("Unknown tag following extensions in CRL");
  192|      0|   }
  193|       |
  194|  2.94k|   tbs_crl.verify_end();
  195|       |
  196|       |   // Now cache some fields from the extensions
  197|  2.94k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Number>()) {
  ------------------
  |  Branch (197:19): [True: 45, False: 2.89k]
  ------------------
  198|     45|      data->m_crl_number = ext->get_crl_number();
  199|     45|   }
  200|  2.94k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
  ------------------
  |  Branch (200:19): [True: 46, False: 2.89k]
  ------------------
  201|     46|      data->m_auth_key_id = ext->get_key_id();
  202|     46|   }
  203|  2.94k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Issuing_Distribution_Point>()) {
  ------------------
  |  Branch (203:19): [True: 0, False: 2.94k]
  ------------------
  204|      0|      for(const auto& uri : ext->get_point().uri_names()) {
  ------------------
  |  Branch (204:27): [True: 0, False: 0]
  ------------------
  205|      0|         data->m_idp_urls.push_back(uri);
  206|      0|      }
  207|      0|   }
  208|       |
  209|  2.94k|   data->update_index();
  210|       |
  211|  2.94k|   return data;
  212|  2.94k|}
_ZN5Botan8CRL_DataC2Ev:
   31|  3.08k|      CRL_Data() = default;
_ZN5Botan8CRL_Data12update_indexEv:
   33|     50|      void update_index() {
   34|     50|         m_revoked_serials.clear();
   35|  6.98k|         for(const auto& entry : m_entries) {
  ------------------
  |  Branch (35:32): [True: 6.98k, False: 50]
  ------------------
   36|  6.98k|            m_revoked_serials.insert(entry.serial_number());
   37|  6.98k|         }
   38|     50|      }

_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  372|  2.79k|void X509_DN::decode_from(BER_Decoder& source) {
  373|  2.79k|   std::vector<uint8_t> bits;
  374|       |
  375|  2.79k|   source.start_sequence().raw_bytes(bits).end_cons();
  376|       |
  377|  2.79k|   BER_Decoder sequence(bits, source.limits());
  378|       |
  379|  2.79k|   std::vector<std::vector<std::pair<OID, ASN1_String>>> rdns;
  380|       |
  381|       |   // Cap AVAs per RDN to bound work for downstream set-based matching.
  382|       |   // No legitimate cert has anywhere near this many AVAs in a single RDN.
  383|  2.79k|   constexpr size_t MAX_AVAS_PER_RDN = 32;
  384|       |
  385|  5.98k|   while(sequence.more_items()) {
  ------------------
  |  Branch (385:10): [True: 3.18k, False: 2.79k]
  ------------------
  386|  3.18k|      BER_Decoder rdn_decoder = sequence.start_set();
  387|       |
  388|  3.18k|      std::vector<std::pair<OID, ASN1_String>> rdn;
  389|  6.36k|      while(rdn_decoder.more_items()) {
  ------------------
  |  Branch (389:13): [True: 3.18k, False: 3.18k]
  ------------------
  390|  3.18k|         OID oid;
  391|  3.18k|         ASN1_String str;
  392|       |
  393|  3.18k|         rdn_decoder.start_sequence()
  394|  3.18k|            .decode(oid)
  395|  3.18k|            .decode(str)  // TODO support Any
  396|  3.18k|            .end_cons();
  397|       |
  398|  3.18k|         rdn.emplace_back(std::move(oid), std::move(str));
  399|       |
  400|  3.18k|         if(rdn.size() > MAX_AVAS_PER_RDN) {
  ------------------
  |  Branch (400:13): [True: 0, False: 3.18k]
  ------------------
  401|      0|            throw Decoding_Error("X.500 RDN has too many attribute-value assertions");
  402|      0|         }
  403|  3.18k|      }
  404|       |
  405|       |      /*
  406|       |      RFC 5280 4.1.2.4:
  407|       |         RelativeDistinguishedName ::=
  408|       |           SET SIZE (1..MAX) OF AttributeTypeAndValue
  409|       |      */
  410|  3.18k|      if(rdn.empty()) {
  ------------------
  |  Branch (410:10): [True: 0, False: 3.18k]
  ------------------
  411|      0|         throw Decoding_Error("X.500 RDN must contain at least one attribute-value assertion");
  412|      0|      }
  413|  3.18k|      rdns.push_back(std::move(rdn));
  414|  3.18k|   }
  415|       |
  416|  2.79k|   auto canonical_bits = canonicalize_dn(rdns);
  417|       |
  418|  2.79k|   m_rdn = std::move(rdns);
  419|  2.79k|   m_dn_bits = std::move(bits);
  420|  2.79k|   m_canonical_dn_bits = std::move(canonical_bits);
  421|  2.79k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_115canonicalize_dnERKNSt3__16vectorINS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEENS7_IS9_EEEE:
  275|    123|std::vector<uint8_t> canonicalize_dn(const std::vector<std::vector<std::pair<OID, ASN1_String>>>& rdns) {
  276|    123|   auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  277|    123|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  278|    123|      out.insert(out.end(), data_len.begin(), data_len.end());
  279|    123|      out.insert(out.end(), data.begin(), data.end());
  280|    123|   };
  281|       |
  282|    123|   std::vector<uint8_t> canonical_bits;
  283|       |
  284|    369|   for(const auto& rdn : rdns) {
  ------------------
  |  Branch (284:24): [True: 369, False: 123]
  ------------------
  285|    369|      std::vector<uint8_t> rdn_bits;
  286|       |
  287|    369|      for(const auto& [oid, value] : canonicalize_rdn(rdn)) {
  ------------------
  |  Branch (287:36): [True: 369, False: 369]
  ------------------
  288|    369|         append_canonical_data(rdn_bits, oid.BER_encode());
  289|    369|         append_canonical_data(rdn_bits, value);
  290|    369|      }
  291|       |
  292|    369|      append_canonical_data(canonical_bits, rdn_bits);
  293|    369|   }
  294|       |
  295|    123|   return canonical_bits;
  296|    123|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_116canonicalize_rdnERKNSt3__16vectorINS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEE:
  263|    369|std::vector<std::pair<OID, std::string>> canonicalize_rdn(const std::vector<std::pair<OID, ASN1_String>>& rdn) {
  264|    369|   std::vector<std::pair<OID, std::string>> result;
  265|    369|   result.reserve(rdn.size());
  266|    369|   for(const auto& ava : rdn) {
  ------------------
  |  Branch (266:24): [True: 369, False: 369]
  ------------------
  267|    369|      result.emplace_back(ava.first, X500_Char_Iterator::canonicalize(ava.second.value()));
  268|    369|   }
  269|    369|   if(result.size() != 1) {
  ------------------
  |  Branch (269:7): [True: 0, False: 369]
  ------------------
  270|      0|      std::sort(result.begin(), result.end());
  271|      0|   }
  272|    369|   return result;
  273|    369|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_Iterator12canonicalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   79|    369|      static std::string canonicalize(std::string_view name) {
   80|    369|         std::string result;
   81|    369|         result.reserve(name.size());
   82|       |
   83|    369|         X500_Char_Iterator it(name);
   84|  6.59k|         while(auto c = it.next()) {
  ------------------
  |  Branch (84:21): [True: 6.22k, False: 369]
  ------------------
   85|  6.22k|            result += *c;
   86|  6.22k|         }
   87|       |
   88|    369|         return result;
   89|    369|      }
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_IteratorC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   46|    369|      explicit X500_Char_Iterator(std::string_view s) : m_str(s), m_pos(0) {
   47|       |         // Skip leading whitespace
   48|    369|         while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
  ------------------
  |  Branch (48:16): [True: 369, False: 0]
  |  Branch (48:40): [True: 0, False: 369]
  ------------------
   49|      0|            ++m_pos;
   50|      0|         }
   51|    369|      }
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_Iterator4nextEv:
   54|  6.59k|      std::optional<char> next() {
   55|  6.59k|         if(m_pos >= m_str.size()) {
  ------------------
  |  Branch (55:13): [True: 369, False: 6.22k]
  ------------------
   56|    369|            return std::nullopt;
   57|    369|         }
   58|       |
   59|  6.22k|         if(is_space(m_str[m_pos])) {
  ------------------
  |  Branch (59:13): [True: 486, False: 5.73k]
  ------------------
   60|       |            // Skip the entire whitespace run
   61|    972|            while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
  ------------------
  |  Branch (61:19): [True: 972, False: 0]
  |  Branch (61:43): [True: 486, False: 486]
  ------------------
   62|    486|               ++m_pos;
   63|    486|            }
   64|       |            // Emit a single space only if more content follows (strip trailing ws)
   65|    486|            if(m_pos < m_str.size()) {
  ------------------
  |  Branch (65:16): [True: 486, False: 0]
  ------------------
   66|    486|               return ' ';
   67|    486|            }
   68|      0|            return std::nullopt;
   69|    486|         }
   70|       |
   71|  5.73k|         const char c = m_str[m_pos++];
   72|       |         // Locale-independent ASCII fold; RFC 5280 DN matching does not depend on libc locale
   73|  5.73k|         if(c >= 'A' && c <= 'Z') {
  ------------------
  |  Branch (73:13): [True: 5.59k, False: 141]
  |  Branch (73:25): [True: 3.16k, False: 2.43k]
  ------------------
   74|  3.16k|            return static_cast<char>(c + ('a' - 'A'));
   75|  3.16k|         }
   76|  2.57k|         return c;
   77|  5.73k|      }
x509_dn.cpp:_ZZN5Botan12_GLOBAL__N_115canonicalize_dnERKNSt3__16vectorINS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEENS7_IS9_EEEEENK3$_0clINS2_IhNS7_IhEEEEEEDaRSH_RKT_:
  276|    738|   auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  277|    738|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  278|    738|      out.insert(out.end(), data_len.begin(), data_len.end());
  279|    738|      out.insert(out.end(), data.begin(), data.end());
  280|    738|   };
x509_dn.cpp:_ZZN5Botan12_GLOBAL__N_115canonicalize_dnERKNSt3__16vectorINS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEENS7_IS9_EEEEENK3$_0clINS1_12basic_stringIcNS1_11char_traitsIcEENS7_IcEEEEEEDaRNS2_IhNS7_IhEEEERKT_:
  276|    369|   auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  277|    369|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  278|    369|      out.insert(out.end(), data_len.begin(), data_len.end());
  279|    369|      out.insert(out.end(), data.begin(), data.end());
  280|    369|   };
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_18is_spaceEc:
   25|  7.56k|bool is_space(char c) {
   26|  7.56k|   return c == ' ' || c == '\t';
  ------------------
  |  Branch (26:11): [True: 972, False: 6.59k]
  |  Branch (26:23): [True: 0, False: 6.59k]
  ------------------
   27|  7.56k|}

_ZN5Botan10Extensions15create_extn_objERKNS_3OIDEbRKNSt3__16vectorIhNS4_9allocatorIhEEEENS4_8optionalINS_17Extension_ContextEEE:
  131|  12.6k|                                                                   std::optional<Extension_Context> context) {
  132|  12.6k|   auto extn = extension_from_oid(oid);
  133|       |
  134|  12.6k|   if(!extn) {
  ------------------
  |  Branch (134:7): [True: 9.50k, False: 3.17k]
  ------------------
  135|       |      // some other unknown extension type
  136|  9.50k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  137|  9.50k|   } else {
  138|  3.17k|      if(context.has_value() && !extn->is_appropriate_context(*context)) {
  ------------------
  |  Branch (138:10): [True: 3.17k, False: 0]
  |  Branch (138:33): [True: 32, False: 3.14k]
  ------------------
  139|     32|         throw Decoding_Error(fmt("Extension {} is not allowed in this context", extn->oid_name()));
  140|     32|      }
  141|       |
  142|  3.14k|      try {
  143|  3.14k|         extn->decode_inner(body);
  144|  3.14k|         return extn;
  145|  3.14k|      } catch(const Exception&) {
  146|       |         // OID was recognized but contents failed to decode
  147|    226|         extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical, /*failed_to_decode=*/true);
  148|    226|      }
  149|  3.14k|   }
  150|       |
  151|       |   // This is always Unknown_Extension:
  152|  9.72k|   extn->decode_inner(body);
  153|  9.72k|   return extn;
  154|  12.6k|}
_ZNK5Botan10Extensions15Extensions_Info3objEv:
  156|  3.14k|const Certificate_Extension& Extensions::Extensions_Info::obj() const {
  157|  3.14k|   BOTAN_ASSERT_NONNULL(m_obj.get());
  ------------------
  |  |  116|  3.14k|   do {                                                                                   \
  |  |  117|  3.14k|      if((ptr) == nullptr) {                                                              \
  |  |  ------------------
  |  |  |  Branch (117:10): [True: 0, False: 3.14k]
  |  |  ------------------
  |  |  118|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                              \
  |  |  119|      0|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |  120|      0|      }                                                                                   \
  |  |  121|  3.14k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (121:12): [Folded, False: 3.14k]
  |  |  ------------------
  ------------------
  158|  3.14k|   return *m_obj;
  159|  3.14k|}
_ZNK5Botan10Extensions20get_extension_objectERKNS_3OIDE:
  239|  9.63k|const Certificate_Extension* Extensions::get_extension_object(const OID& oid) const {
  240|  9.63k|   auto extn = m_extension_info.find(oid);
  241|  9.63k|   if(extn == m_extension_info.end()) {
  ------------------
  |  Branch (241:7): [True: 6.48k, False: 3.14k]
  ------------------
  242|  6.48k|      return nullptr;
  243|  6.48k|   }
  244|       |
  245|  3.14k|   return &extn->second.obj();
  246|  9.63k|}
_ZN5Botan10Extensions11decode_fromERNS_11BER_DecoderENSt3__18optionalINS_17Extension_ContextEEE:
  299|  9.56k|void Extensions::decode_from(BER_Decoder& from_source, std::optional<Extension_Context> context) {
  300|  9.56k|   m_extension_oids.clear();
  301|  9.56k|   m_extension_info.clear();
  302|  9.56k|   m_has_unknown_critical_extension = false;
  303|       |
  304|  9.56k|   BER_Decoder sequence = from_source.start_sequence();
  305|       |
  306|  22.2k|   while(sequence.more_items()) {
  ------------------
  |  Branch (306:10): [True: 12.6k, False: 9.56k]
  ------------------
  307|  12.6k|      OID oid;
  308|  12.6k|      bool critical = false;
  309|  12.6k|      std::vector<uint8_t> bits;
  310|       |
  311|  12.6k|      sequence.start_sequence()
  312|  12.6k|         .decode(oid)
  313|  12.6k|         .decode_optional(critical, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  314|  12.6k|         .decode(bits, ASN1_Type::OctetString)
  315|  12.6k|         .end_cons();
  316|       |
  317|  12.6k|      auto obj = create_extn_obj(oid, critical, bits, context);
  318|       |      // Unknown_Extension is the only Certificate_Extension with an empty oid_name
  319|  12.6k|      if(critical && obj->oid_name().empty()) {
  ------------------
  |  Branch (319:10): [True: 0, False: 12.6k]
  |  Branch (319:10): [True: 0, False: 12.6k]
  |  Branch (319:22): [True: 0, False: 0]
  ------------------
  320|      0|         m_has_unknown_critical_extension = true;
  321|      0|      }
  322|  12.6k|      Extensions_Info info(critical, bits, std::move(obj));
  323|       |
  324|       |      // RFC 5280 4.2: "A certificate MUST NOT include more than one
  325|       |      // instance of a particular extension."
  326|  12.6k|      if(!m_extension_info.emplace(oid, info).second) {
  ------------------
  |  Branch (326:10): [True: 0, False: 12.6k]
  ------------------
  327|      0|         throw Decoding_Error("Duplicate certificate extension encountered");
  328|      0|      }
  329|  12.6k|      m_extension_oids.push_back(oid);
  330|  12.6k|   }
  331|  9.56k|   sequence.verify_end();
  332|  9.56k|}
_ZNK5Botan14Cert_Extension16Authority_Key_ID22is_appropriate_contextENS_17Extension_ContextE:
  348|     74|bool Authority_Key_ID::is_appropriate_context(Extension_Context context) const {
  349|     74|   return context == Extension_Context::Certificate || context == Extension_Context::CRL;
  ------------------
  |  Branch (349:11): [True: 0, False: 74]
  |  Branch (349:56): [True: 47, False: 27]
  ------------------
  350|     74|}
_ZNK5Botan14Cert_Extension10CRL_Number22is_appropriate_contextENS_17Extension_ContextE:
  376|     49|bool CRL_Number::is_appropriate_context(Extension_Context context) const {
  377|     49|   return context == Extension_Context::CRL;
  378|     49|}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode22is_appropriate_contextENS_17Extension_ContextE:
  380|  3.05k|bool CRL_ReasonCode::is_appropriate_context(Extension_Context context) const {
  381|       |   // RFC 6960 4.4.5: "All the extensions specified as CRL entry extensions
  382|       |   // -- in Section 5.3 of [RFC5280] -- are also supported as singleExtensions."
  383|  3.05k|   return context == Extension_Context::CRL_Entry || context == Extension_Context::OCSP_Response;
  ------------------
  |  Branch (383:11): [True: 3.05k, False: 0]
  |  Branch (383:54): [True: 0, False: 0]
  ------------------
  384|  3.05k|}
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point22is_appropriate_contextENS_17Extension_ContextE:
  390|      4|bool CRL_Issuing_Distribution_Point::is_appropriate_context(Extension_Context context) const {
  391|      4|   return context == Extension_Context::CRL;
  392|      4|}
_ZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  596|     47|void Authority_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  597|       |   /*
  598|       |   * RFC 5280 Section 4.2.1.1
  599|       |   *
  600|       |   * AuthorityKeyIdentifier ::= SEQUENCE {
  601|       |   *    keyIdentifier             [0] KeyIdentifier           OPTIONAL,
  602|       |   *    authorityCertIssuer       [1] GeneralNames            OPTIONAL,
  603|       |   *    authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
  604|       |   */
  605|     47|   BER_Decoder ber(in, BER_Decoder::Limits::DER());
  606|     47|   BER_Decoder seq = ber.start_sequence();
  607|       |
  608|     47|   const bool key_id_present = seq.peek_next_object().is_a(0, ASN1_Class::ContextSpecific);
  609|       |
  610|     47|   seq.decode_optional_string(m_key_id, ASN1_Type::OctetString, 0).discard_remaining().end_cons();
  611|     47|   ber.verify_end();
  612|       |
  613|     47|   if(key_id_present) {
  ------------------
  |  Branch (613:7): [True: 46, False: 1]
  ------------------
  614|     46|      if(m_key_id.empty()) {
  ------------------
  |  Branch (614:10): [True: 0, False: 46]
  ------------------
  615|      0|         throw Decoding_Error("AuthorityKeyIdentifier keyIdentifier must not be empty");
  616|      0|      }
  617|     46|      if(m_key_id.size() > MaximumKeyIdentifierLength) {
  ------------------
  |  Branch (617:10): [True: 0, False: 46]
  ------------------
  618|      0|         throw Decoding_Error(fmt("AuthorityKeyIdentifier keyIdentifier length {} exceeds limit of {} bytes",
  619|      0|                                  m_key_id.size(),
  620|      0|                                  MaximumKeyIdentifierLength));
  621|      0|      }
  622|     46|   }
  623|     47|}
_ZNK5Botan14Cert_Extension10CRL_Number14get_crl_numberEv:
  969|     45|size_t CRL_Number::get_crl_number() const {
  970|     45|   if(!m_has_value) {
  ------------------
  |  Branch (970:7): [True: 0, False: 45]
  ------------------
  971|      0|      throw Invalid_State("CRL_Number::get_crl_number: Not set");
  972|      0|   }
  973|     45|   return m_crl_number;
  974|     45|}
_ZN5Botan14Cert_Extension10CRL_Number12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  995|     48|void CRL_Number::decode_inner(const std::vector<uint8_t>& in) {
  996|       |   /* RFC 5280 Section 5.2.3 - CRLNumber ::= INTEGER (0..MAX) */
  997|     48|   BER_Decoder(in, BER_Decoder::Limits::DER()).decode(m_crl_number).verify_end();
  998|     48|   m_has_value = true;
  999|     48|}
_ZN5Botan14Cert_Extension14CRL_ReasonCode12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1013|  3.05k|void CRL_ReasonCode::decode_inner(const std::vector<uint8_t>& in) {
 1014|       |   /*
 1015|       |   * RFC 5280 Section 5.3.1
 1016|       |   *
 1017|       |   * CRLReason ::= ENUMERATED {
 1018|       |   *      unspecified             (0),
 1019|       |   *      keyCompromise           (1),
 1020|       |   *      cACompromise            (2),
 1021|       |   *      affiliationChanged      (3),
 1022|       |   *      superseded              (4),
 1023|       |   *      cessationOfOperation    (5),
 1024|       |   *      certificateHold         (6),
 1025|       |   *           -- value 7 is not used
 1026|       |   *      removeFromCRL           (8),
 1027|       |   *      privilegeWithdrawn      (9),
 1028|       |   *      aACompromise           (10) }
 1029|       |   */
 1030|  3.05k|   size_t reason_code = 0;
 1031|  3.05k|   BER_Decoder(in, BER_Decoder::Limits::DER())
 1032|  3.05k|      .decode(reason_code, ASN1_Type::Enumerated, ASN1_Class::Universal)
 1033|  3.05k|      .verify_end();
 1034|       |
 1035|  3.05k|   if(reason_code == 7 || reason_code > 10) {
  ------------------
  |  Branch (1035:7): [True: 208, False: 2.84k]
  |  Branch (1035:27): [True: 14, False: 2.83k]
  ------------------
 1036|     14|      throw Decoding_Error(fmt("CRLReason has unknown enumeration value {}", reason_code));
 1037|     14|   }
 1038|       |
 1039|  3.03k|   m_reason = static_cast<CRL_Code>(reason_code);
 1040|  3.03k|}
_ZN5Botan14Cert_Extension17Unknown_Extension12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 2120|  9.72k|void Unknown_Extension::decode_inner(const std::vector<uint8_t>& bytes) {
 2121|       |   // Just treat as an opaque blob at this level
 2122|  9.72k|   m_bytes = bytes;
 2123|  9.72k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_118extension_from_oidERKNS_3OIDE:
   38|  12.6k|std::unique_ptr<Certificate_Extension> extension_from_oid(const OID& oid) {
   39|  12.6k|   if(auto iso_ext = is_sub_element_of(oid, {2, 5, 29})) {
  ------------------
  |  Branch (39:12): [True: 12.2k, False: 425]
  ------------------
   40|       |      // NOLINTNEXTLINE(*-switch-missing-default-case)
   41|  12.2k|      switch(*iso_ext) {
  ------------------
  |  Branch (41:14): [True: 3.17k, False: 9.07k]
  ------------------
   42|      0|         case 14:
  ------------------
  |  Branch (42:10): [True: 0, False: 12.2k]
  ------------------
   43|      0|            return make_extension<Cert_Extension::Subject_Key_ID>(oid);
   44|      0|         case 15:
  ------------------
  |  Branch (44:10): [True: 0, False: 12.2k]
  ------------------
   45|      0|            return make_extension<Cert_Extension::Key_Usage>(oid);
   46|      0|         case 17:
  ------------------
  |  Branch (46:10): [True: 0, False: 12.2k]
  ------------------
   47|      0|            return make_extension<Cert_Extension::Subject_Alternative_Name>(oid);
   48|      0|         case 18:
  ------------------
  |  Branch (48:10): [True: 0, False: 12.2k]
  ------------------
   49|      0|            return make_extension<Cert_Extension::Issuer_Alternative_Name>(oid);
   50|      0|         case 19:
  ------------------
  |  Branch (50:10): [True: 0, False: 12.2k]
  ------------------
   51|      0|            return make_extension<Cert_Extension::Basic_Constraints>(oid);
   52|     49|         case 20:
  ------------------
  |  Branch (52:10): [True: 49, False: 12.2k]
  ------------------
   53|     49|            return make_extension<Cert_Extension::CRL_Number>(oid);
   54|  3.05k|         case 21:
  ------------------
  |  Branch (54:10): [True: 3.05k, False: 9.20k]
  ------------------
   55|  3.05k|            return make_extension<Cert_Extension::CRL_ReasonCode>(oid);
   56|      4|         case 28:
  ------------------
  |  Branch (56:10): [True: 4, False: 12.2k]
  ------------------
   57|      4|            return make_extension<Cert_Extension::CRL_Issuing_Distribution_Point>(oid);
   58|      0|         case 30:
  ------------------
  |  Branch (58:10): [True: 0, False: 12.2k]
  ------------------
   59|      0|            return make_extension<Cert_Extension::Name_Constraints>(oid);
   60|      0|         case 31:
  ------------------
  |  Branch (60:10): [True: 0, False: 12.2k]
  ------------------
   61|      0|            return make_extension<Cert_Extension::CRL_Distribution_Points>(oid);
   62|      0|         case 32:
  ------------------
  |  Branch (62:10): [True: 0, False: 12.2k]
  ------------------
   63|      0|            return make_extension<Cert_Extension::Certificate_Policies>(oid);
   64|     74|         case 35:
  ------------------
  |  Branch (64:10): [True: 74, False: 12.1k]
  ------------------
   65|     74|            return make_extension<Cert_Extension::Authority_Key_ID>(oid);
   66|      0|         case 37:
  ------------------
  |  Branch (66:10): [True: 0, False: 12.2k]
  ------------------
   67|      0|            return make_extension<Cert_Extension::Extended_Key_Usage>(oid);
   68|      0|         case 56:
  ------------------
  |  Branch (68:10): [True: 0, False: 12.2k]
  ------------------
   69|      0|            return make_extension<Cert_Extension::NoRevocationAvailable>(oid);
   70|  12.2k|      }
   71|  12.2k|   }
   72|       |
   73|  9.50k|   if(auto pkix_ext = is_sub_element_of(oid, {1, 3, 6, 1, 5, 5, 7, 1})) {
  ------------------
  |  Branch (73:12): [True: 0, False: 9.50k]
  ------------------
   74|       |      // NOLINTNEXTLINE(*-switch-missing-default-case)
   75|      0|      switch(*pkix_ext) {
  ------------------
  |  Branch (75:14): [True: 0, False: 0]
  ------------------
   76|      0|         case 1:
  ------------------
  |  Branch (76:10): [True: 0, False: 0]
  ------------------
   77|      0|            return make_extension<Cert_Extension::Authority_Information_Access>(oid);
   78|      0|         case 7:
  ------------------
  |  Branch (78:10): [True: 0, False: 0]
  ------------------
   79|      0|            return make_extension<Cert_Extension::IPAddressBlocks>(oid);
   80|      0|         case 8:
  ------------------
  |  Branch (80:10): [True: 0, False: 0]
  ------------------
   81|      0|            return make_extension<Cert_Extension::ASBlocks>(oid);
   82|      0|         case 26:
  ------------------
  |  Branch (82:10): [True: 0, False: 0]
  ------------------
   83|      0|            return make_extension<Cert_Extension::TNAuthList>(oid);
   84|      0|      }
   85|      0|   }
   86|       |
   87|  9.50k|   if(oid == Cert_Extension::OCSP_NoCheck::static_oid()) {
  ------------------
  |  Branch (87:7): [True: 0, False: 9.50k]
  ------------------
   88|      0|      return make_extension<Cert_Extension::OCSP_NoCheck>(oid);
   89|      0|   }
   90|       |
   91|  9.50k|   return nullptr;  // unknown
   92|  9.50k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension10CRL_NumberEEEDaRKNS_3OIDE:
   33|     49|auto make_extension([[maybe_unused]] const OID& oid) {
   34|     49|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  130|     49|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  131|     49|      } while(0)
  |  |  ------------------
  |  |  |  Branch (131:15): [Folded, False: 49]
  |  |  ------------------
  ------------------
   35|     49|   return std::make_unique<T>();
   36|     49|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension14CRL_ReasonCodeEEEDaRKNS_3OIDE:
   33|  3.05k|auto make_extension([[maybe_unused]] const OID& oid) {
   34|  3.05k|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  130|  3.05k|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  131|  3.05k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (131:15): [Folded, False: 3.05k]
  |  |  ------------------
  ------------------
   35|  3.05k|   return std::make_unique<T>();
   36|  3.05k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension30CRL_Issuing_Distribution_PointEEEDaRKNS_3OIDE:
   33|      4|auto make_extension([[maybe_unused]] const OID& oid) {
   34|      4|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  130|      4|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  131|      4|      } while(0)
  |  |  ------------------
  |  |  |  Branch (131:15): [Folded, False: 4]
  |  |  ------------------
  ------------------
   35|      4|   return std::make_unique<T>();
   36|      4|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension16Authority_Key_IDEEEDaRKNS_3OIDE:
   33|     74|auto make_extension([[maybe_unused]] const OID& oid) {
   34|     74|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  130|     74|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  131|     74|      } while(0)
  |  |  ------------------
  |  |  |  Branch (131:15): [Folded, False: 74]
  |  |  ------------------
  ------------------
   35|     74|   return std::make_unique<T>();
   36|     74|}

_ZN5Botan11X509_Object9load_dataERNS_10DataSourceE:
   24|  4.06k|void X509_Object::load_data(DataSource& in) {
   25|  4.06k|   try {
   26|  4.06k|      if(ASN1::maybe_BER(in) && !PEM_Code::matches(in)) {
  ------------------
  |  Branch (26:10): [True: 3.75k, False: 314]
  |  Branch (26:33): [True: 3.74k, False: 10]
  ------------------
   27|  3.74k|         BER_Decoder dec(in, BER_Decoder::Limits::DER());
   28|  3.74k|         decode_from(dec);
   29|       |         // Call to verify_end omitted here since we have to sometimes decode
   30|       |         // multiple certificates encoded sequentially in a DataSource
   31|  3.74k|      } else {
   32|    324|         std::string got_label;
   33|    324|         DataSource_Memory ber(PEM_Code::decode(in, got_label));
   34|       |
   35|    324|         if(got_label != PEM_label()) {
  ------------------
  |  Branch (35:13): [True: 61, False: 263]
  ------------------
   36|     61|            bool is_alternate = false;
   37|     61|            for(const std::string_view alt_label : alternate_PEM_labels()) {
  ------------------
  |  Branch (37:50): [True: 61, False: 60]
  ------------------
   38|     61|               if(got_label == alt_label) {
  ------------------
  |  Branch (38:19): [True: 1, False: 60]
  ------------------
   39|      1|                  is_alternate = true;
   40|      1|                  break;
   41|      1|               }
   42|     61|            }
   43|       |
   44|     61|            if(!is_alternate) {
  ------------------
  |  Branch (44:16): [True: 60, False: 1]
  ------------------
   45|     60|               throw Decoding_Error("Unexpected PEM label for " + PEM_label() + " of " + got_label);
   46|     60|            }
   47|     61|         }
   48|       |
   49|    264|         BER_Decoder dec(ber, BER_Decoder::Limits::DER());
   50|    264|         decode_from(dec);
   51|       |         // Call to verify_end omitted here since we have to sometimes decode
   52|       |         // multiple certificates encoded sequentially in a DataSource
   53|    264|      }
   54|  4.06k|   } catch(Decoding_Error& e) {
   55|  3.92k|      throw Decoding_Error(PEM_label() + " decoding", e);
   56|  3.92k|   }
   57|  4.06k|}
_ZNK5Botan11X509_Object11signed_bodyEv:
   66|  3.08k|const std::vector<uint8_t>& X509_Object::signed_body() const {
   67|  3.08k|   if(!m_signed_data) {
  ------------------
  |  Branch (67:7): [True: 0, False: 3.08k]
  ------------------
   68|      0|      throw Invalid_State("X509_Object uninitialized");
   69|      0|   }
   70|  3.08k|   return m_signed_data->m_tbs_bits;
   71|  3.08k|}
_ZNK5Botan11X509_Object19signature_algorithmEv:
   73|  3.08k|const AlgorithmIdentifier& X509_Object::signature_algorithm() const {
   74|  3.08k|   if(!m_signed_data) {
  ------------------
  |  Branch (74:7): [True: 0, False: 3.08k]
  ------------------
   75|      0|      throw Invalid_State("X509_Object uninitialized");
   76|      0|   }
   77|  3.08k|   return m_signed_data->m_sig_algo;
   78|  3.08k|}
_ZN5Botan11X509_Object11decode_fromERNS_11BER_DecoderE:
   93|  3.74k|void X509_Object::decode_from(BER_Decoder& from) {
   94|  3.74k|   auto data = std::make_shared<Signed_Data>();
   95|       |
   96|  3.74k|   from.start_sequence()
   97|  3.74k|      .start_sequence()
   98|  3.74k|      .raw_bytes(data->m_tbs_bits)
   99|  3.74k|      .end_cons()
  100|  3.74k|      .decode(data->m_sig_algo)
  101|  3.74k|      .decode(data->m_sig, ASN1_Type::BitString)
  102|  3.74k|      .end_cons();
  103|       |
  104|  3.74k|   m_signed_data = std::move(data);
  105|  3.74k|   force_decode();
  106|  3.74k|}