_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EED2Ev:
   65|    134|      ~AlignmentBuffer() { secure_scrub_memory(m_buffer.data(), m_buffer.size()); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EEC2Ev:
   63|    134|      AlignmentBuffer() : m_position(0) {}
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE5clearEv:
   72|    259|      void clear() {
   73|    259|         clear_mem(m_buffer.data(), m_buffer.size());
   74|    259|         m_position = 0;
   75|    259|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE21handle_unaligned_dataERNS_12BufferSlicerE:
  167|    325|      [[nodiscard]] std::optional<std::span<const T>> handle_unaligned_data(BufferSlicer& slicer) {
  168|       |         // When the final block is to be deferred, we would need to store and
  169|       |         // hold a buffer that contains exactly one block until more data is
  170|       |         // passed or it is explicitly consumed.
  171|    325|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (171:31): [True: 0, False: 325]
  ------------------
  172|       |
  173|    325|         if(in_alignment() && slicer.remaining() >= m_buffer.size() + defer) {
  ------------------
  |  Branch (173:13): [True: 207, False: 118]
  |  Branch (173:31): [True: 23, False: 184]
  ------------------
  174|       |            // We are currently in alignment and the passed-in data source
  175|       |            // contains enough data to benefit from aligned processing.
  176|       |            // Therefore, we don't copy anything into the intermittent buffer.
  177|     23|            return std::nullopt;
  178|     23|         }
  179|       |
  180|       |         // Fill the buffer with as much input data as needed to reach alignment
  181|       |         // or until the input source is depleted.
  182|    302|         const auto elements_to_consume = std::min(m_buffer.size() - m_position, slicer.remaining());
  183|    302|         append(slicer.take(elements_to_consume));
  184|       |
  185|       |         // If we collected enough data, we push out one full block. When
  186|       |         // deferring the final block is enabled, we additionally check that
  187|       |         // more input data is available to continue processing a consecutive
  188|       |         // block.
  189|    302|         if(ready_to_consume() && (!defers_final_block() || !slicer.empty())) {
  ------------------
  |  Branch (189:13): [True: 76, False: 226]
  |  Branch (189:36): [True: 76, False: 0]
  |  Branch (189:61): [True: 0, False: 0]
  ------------------
  190|     76|            return consume();
  191|    226|         } else {
  192|    226|            return std::nullopt;
  193|    226|         }
  194|    302|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18defers_final_blockEv:
  234|    500|      constexpr bool defers_final_block() const {
  235|    500|         return FINAL_BLOCK_STRATEGY == AlignmentBufferFinalBlock::must_be_deferred;
  236|    500|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE6appendENSt3__14spanIKhLm18446744073709551615EEE:
   91|    427|      void append(std::span<const T> elements) {
   92|    427|         BOTAN_ASSERT_NOMSG(elements.size() <= elements_until_alignment());
  ------------------
  |  |   60|    427|   do {                                                                     \
  |  |   61|    427|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 427]
  |  |  ------------------
  |  |   62|    427|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    427|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   93|    427|         std::copy(elements.begin(), elements.end(), m_buffer.begin() + m_position);
   94|    427|         m_position += elements.size();
   95|    427|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE24elements_until_alignmentEv:
  222|    822|      size_t elements_until_alignment() const { return m_buffer.size() - m_position; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE16ready_to_consumeEv:
  232|    803|      bool ready_to_consume() const { return m_position == m_buffer.size(); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE7consumeEv:
  201|    226|      [[nodiscard]] std::span<const T> consume() {
  202|    226|         BOTAN_ASSERT_NOMSG(ready_to_consume());
  ------------------
  |  |   60|    226|   do {                                                                     \
  |  |   61|    226|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 226]
  |  |  ------------------
  |  |   62|    226|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    226|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  203|    226|         m_position = 0;
  204|    226|         return m_buffer;
  205|    226|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE12in_alignmentEv:
  227|    749|      bool in_alignment() const { return m_position == 0; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE23aligned_data_to_processERNS_12BufferSlicerE:
  127|     99|      [[nodiscard]] std::tuple<std::span<const uint8_t>, size_t> aligned_data_to_process(BufferSlicer& slicer) const {
  128|     99|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|     99|   do {                                                                     \
  |  |   61|     99|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 99]
  |  |  ------------------
  |  |   62|     99|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     99|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|       |
  130|       |         // When the final block is to be deferred, the last block must not be
  131|       |         // selected for processing if there is no (unaligned) extra input data.
  132|     99|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (132:31): [True: 0, False: 99]
  ------------------
  133|     99|         const size_t full_blocks_to_process = (slicer.remaining() - defer) / m_buffer.size();
  134|     99|         return {slicer.take(full_blocks_to_process * m_buffer.size()), full_blocks_to_process};
  135|     99|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18fill_up_with_zerosEv:
   80|    150|      void fill_up_with_zeros() {
   81|    150|         if(!ready_to_consume()) {
  ------------------
  |  Branch (81:13): [True: 145, False: 5]
  ------------------
   82|    145|            clear_mem(&m_buffer[m_position], elements_until_alignment());
   83|    145|            m_position = m_buffer.size();
   84|    145|         }
   85|    150|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE20directly_modify_lastEm:
  114|    125|      std::span<T> directly_modify_last(size_t elements) {
  115|    125|         BOTAN_ASSERT_NOMSG(size() >= elements);
  ------------------
  |  |   60|    125|   do {                                                                     \
  |  |   61|    125|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 125]
  |  |  ------------------
  |  |   62|    125|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    125|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|    125|         return std::span(m_buffer).last(elements);
  117|    125|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE4sizeEv:
  218|    125|      constexpr size_t size() const { return m_buffer.size(); }

_ZN5Botan6chooseIjEET_S1_S1_S1_:
  180|   355k|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   355k|   return (b ^ (mask & (a ^ b)));
  183|   355k|}
_ZN5Botan8majorityIjEET_S1_S1_S1_:
  186|   177k|inline constexpr T majority(T a, T b, T c) {
  187|       |   /*
  188|       |   Considering each bit of a, b, c individually
  189|       |
  190|       |   If a xor b is set, then c is the deciding vote.
  191|       |
  192|       |   If a xor b is not set then either a and b are both set or both unset.
  193|       |   In either case the value of c doesn't matter, and examining b (or a)
  194|       |   allows us to determine which case we are in.
  195|       |   */
  196|   177k|   return choose(a ^ b, c, b);
  197|   177k|}

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

_ZN5Botan5CPUID13has_cpuid_bitENS0_10CPUID_bitsE:
  333|    927|      static bool has_cpuid_bit(CPUID_bits elem) {
  334|    927|         const uint32_t elem32 = static_cast<uint32_t>(elem);
  335|    927|         return state().has_bit(elem32);
  336|    927|      }
_ZN5Botan5CPUID5stateEv:
  362|    927|      static CPUID_Data& state() {
  363|    927|         static CPUID::CPUID_Data g_cpuid;
  364|    927|         return g_cpuid;
  365|    927|      }
_ZNK5Botan5CPUID10CPUID_Data7has_bitEj:
  350|    927|            bool has_bit(uint32_t bit) const { return (m_processor_features & bit) == bit; }
_ZN5Botan5CPUID8has_sse2Ev:
  208|    309|      static bool has_sse2() { return has_cpuid_bit(CPUID_SSE2_BIT); }
_ZN5Botan5CPUID8has_bmi2Ev:
  240|    309|      static bool has_bmi2() { return has_cpuid_bit(CPUID_BMI_BIT); }
_ZN5Botan5CPUID13has_intel_shaEv:
  255|    309|      static bool has_intel_sha() { return has_sse2() && has_cpuid_bit(CPUID_SHA_BIT); }
  ------------------
  |  Branch (255:44): [True: 309, False: 0]
  |  Branch (255:58): [True: 0, False: 309]
  ------------------

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

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

_ZN5Botan3fmtIJPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEENS3_12basic_stringIcS6_NS3_9allocatorIcEEEES7_DpRKT_:
   53|    582|std::string fmt(std::string_view format, const T&... args) {
   54|    582|   std::ostringstream oss;
   55|    582|   oss.imbue(std::locale::classic());
   56|    582|   fmt_detail::do_fmt(oss, format, args...);
   57|    582|   return oss.str();
   58|    582|}
_ZN5Botan10fmt_detail6do_fmtIPKcJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEvRNS4_19basic_ostringstreamIcS7_NS4_9allocatorIcEEEES8_RKT_DpRKT0_:
   25|    582|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    582|   size_t i = 0;
   27|       |
   28|  5.23k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 5.23k, False: 0]
  ------------------
   29|  5.23k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 582, False: 4.65k]
  |  Branch (29:30): [True: 582, False: 0]
  |  Branch (29:59): [True: 582, False: 0]
  ------------------
   30|    582|         oss << val;
   31|    582|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  4.65k|      } else {
   33|  4.65k|         oss << format[i];
   34|  4.65k|      }
   35|       |
   36|  4.65k|      i += 1;
   37|  4.65k|   }
   38|    582|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  1.24k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.24k|   size_t i = 0;
   27|       |
   28|  5.69k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 5.69k, False: 0]
  ------------------
   29|  5.69k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.24k, False: 4.45k]
  |  Branch (29:30): [True: 1.24k, False: 0]
  |  Branch (29:59): [True: 1.24k, False: 0]
  ------------------
   30|  1.24k|         oss << val;
   31|  1.24k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  4.45k|      } else {
   33|  4.45k|         oss << format[i];
   34|  4.45k|      }
   35|       |
   36|  4.45k|      i += 1;
   37|  4.45k|   }
   38|  1.24k|}
_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  1.43k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  1.43k|   oss << format;
   22|  1.43k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|    658|std::string fmt(std::string_view format, const T&... args) {
   54|    658|   std::ostringstream oss;
   55|    658|   oss.imbue(std::locale::classic());
   56|    658|   fmt_detail::do_fmt(oss, format, args...);
   57|    658|   return oss.str();
   58|    658|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|     16|std::string fmt(std::string_view format, const T&... args) {
   54|     16|   std::ostringstream oss;
   55|     16|   oss.imbue(std::locale::classic());
   56|     16|   fmt_detail::do_fmt(oss, format, args...);
   57|     16|   return oss.str();
   58|     16|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|     16|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     16|   size_t i = 0;
   27|       |
   28|    336|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 336, False: 0]
  ------------------
   29|    336|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 16, False: 320]
  |  Branch (29:30): [True: 16, False: 0]
  |  Branch (29:59): [True: 16, False: 0]
  ------------------
   30|     16|         oss << val;
   31|     16|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    320|      } else {
   33|    320|         oss << format[i];
   34|    320|      }
   35|       |
   36|    320|      i += 1;
   37|    320|   }
   38|     16|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|     16|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     16|   size_t i = 0;
   27|       |
   28|    240|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 240, False: 0]
  ------------------
   29|    240|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 16, False: 224]
  |  Branch (29:30): [True: 16, False: 0]
  |  Branch (29:59): [True: 16, False: 0]
  ------------------
   30|     16|         oss << val;
   31|     16|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    224|      } else {
   33|    224|         oss << format[i];
   34|    224|      }
   35|       |
   36|    224|      i += 1;
   37|    224|   }
   38|     16|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|     16|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     16|   size_t i = 0;
   27|       |
   28|     32|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 32, False: 0]
  ------------------
   29|     32|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 16, False: 16]
  |  Branch (29:30): [True: 16, False: 0]
  |  Branch (29:59): [True: 16, False: 0]
  ------------------
   30|     16|         oss << val;
   31|     16|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     16|      } else {
   33|     16|         oss << format[i];
   34|     16|      }
   35|       |
   36|     16|      i += 1;
   37|     16|   }
   38|     16|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|     68|std::string fmt(std::string_view format, const T&... args) {
   54|     68|   std::ostringstream oss;
   55|     68|   oss.imbue(std::locale::classic());
   56|     68|   fmt_detail::do_fmt(oss, format, args...);
   57|     68|   return oss.str();
   58|     68|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|     68|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     68|   size_t i = 0;
   27|       |
   28|     68|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 68, False: 0]
  ------------------
   29|     68|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 68, False: 0]
  |  Branch (29:30): [True: 68, False: 0]
  |  Branch (29:59): [True: 68, False: 0]
  ------------------
   30|     68|         oss << val;
   31|     68|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     68|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|     68|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    180|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    180|   size_t i = 0;
   27|       |
   28|  4.01k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.01k, False: 0]
  ------------------
   29|  4.01k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 180, False: 3.83k]
  |  Branch (29:30): [True: 180, False: 0]
  |  Branch (29:59): [True: 180, False: 0]
  ------------------
   30|    180|         oss << val;
   31|    180|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.83k|      } else {
   33|  3.83k|         oss << format[i];
   34|  3.83k|      }
   35|       |
   36|  3.83k|      i += 1;
   37|  3.83k|   }
   38|    180|}
_ZN5Botan3fmtIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    112|std::string fmt(std::string_view format, const T&... args) {
   54|    112|   std::ostringstream oss;
   55|    112|   oss.imbue(std::locale::classic());
   56|    112|   fmt_detail::do_fmt(oss, format, args...);
   57|    112|   return oss.str();
   58|    112|}

_ZN5Botan8store_beIjEEvT_Ph:
  408|  1.00k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|  1.00k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|  1.00k|}
_ZN5Botan8store_beIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  358|  1.00k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|  1.00k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|  1.00k|   std::span out{out_range};
  361|  1.00k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|  1.00k|      out[0] = static_cast<uint8_t>(in);
  363|  1.00k|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|  1.00k|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|  1.00k|   }
  375|  1.00k|}
_ZN5Botan7load_beIhEET_PKhm:
  226|   931k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|   931k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|   931k|}
_ZN5Botan7load_beIhNSt3__14spanIKhLm1EEEEET_OT0_:
   92|   931k|inline constexpr T load_be(InR&& in_range) {
   93|   931k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|   931k|   std::span in{in_range};
   95|   931k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|   931k|      return static_cast<T>(in[0]);
   97|   931k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|   931k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|   931k|   }
  109|   931k|}
_ZN5Botan11make_uint16Ehh:
   50|  34.6k|inline constexpr uint16_t make_uint16(uint8_t i0, uint8_t i1) {
   51|  34.6k|   return static_cast<uint16_t>((static_cast<uint16_t>(i0) << 8) | i1);
   52|  34.6k|}
_ZN5Botan11make_uint32Ehhhh:
   62|  4.42k|inline constexpr uint32_t make_uint32(uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3) {
   63|  4.42k|   return ((static_cast<uint32_t>(i0) << 24) | (static_cast<uint32_t>(i1) << 16) | (static_cast<uint32_t>(i2) << 8) |
   64|  4.42k|           (static_cast<uint32_t>(i3)));
   65|  4.42k|}
_ZN5Botan7load_beItEET_PKhm:
  226|  20.2k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  20.2k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  20.2k|}
_ZN5Botan7load_beItNSt3__14spanIKhLm2EEEEET_OT0_:
   92|  20.2k|inline constexpr T load_be(InR&& in_range) {
   93|  20.2k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  20.2k|   std::span in{in_range};
   95|  20.2k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  20.2k|      return static_cast<T>(in[0]);
   97|  20.2k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  20.2k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  20.2k|   }
  109|  20.2k|}
_ZN5Botan8store_beImEEvT_Ph:
  408|    125|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|    125|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|    125|}
_ZN5Botan8store_beImNSt3__14spanIhLm8EEEEEvT_OT0_:
  358|    125|inline constexpr void store_be(T in, OutR&& out_range) {
  359|    125|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|    125|   std::span out{out_range};
  361|    125|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|    125|      out[0] = static_cast<uint8_t>(in);
  363|    125|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|    125|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|    125|   }
  375|    125|}
_ZN5Botan7load_beIjEET_PKhm:
  226|  44.9k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  44.9k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  44.9k|}
_ZN5Botan7load_beIjNSt3__14spanIKhLm4EEEEET_OT0_:
   92|  44.9k|inline constexpr T load_be(InR&& in_range) {
   93|  44.9k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  44.9k|   std::span in{in_range};
   95|  44.9k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  44.9k|      return static_cast<T>(in[0]);
   97|  44.9k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  44.9k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  44.9k|   }
  109|  44.9k|}
_ZN5Botan8get_byteILm0EmEEhT0_:
   39|  1.96k|{
   40|  1.96k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  1.96k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  1.96k|}
_ZN5Botan15copy_out_vec_beIjNS_16secure_allocatorIjEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  521|    125|void copy_out_vec_be(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  522|    125|   copy_out_be(out, out_bytes, in.data());
  523|    125|}
_ZN5Botan11copy_out_beIjEEvPhmPKT_:
  507|    125|void copy_out_be(uint8_t out[], size_t out_bytes, const T in[]) {
  508|  1.12k|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (508:10): [True: 1.00k, False: 125]
  ------------------
  509|  1.00k|      store_be(in[0], out);
  510|  1.00k|      out += sizeof(T);
  511|  1.00k|      out_bytes -= sizeof(T);
  512|  1.00k|      in += 1;
  513|  1.00k|   }
  514|       |
  515|    125|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (515:22): [True: 0, False: 125]
  ------------------
  516|      0|      out[i] = get_byte_var(i % 8, in[0]);
  517|      0|   }
  518|    125|}

_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EEC2Ev:
   42|    134|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5clearEv:
   70|    259|      void clear() {
   71|    259|         MD::init(m_digest);
   72|    259|         m_buffer.clear();
   73|    259|         m_count = 0;
   74|    259|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|    259|      void update(std::span<const uint8_t> input) {
   45|    259|         BufferSlicer in(input);
   46|       |
   47|    584|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 325, False: 259]
  ------------------
   48|    325|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 76, False: 249]
  ------------------
   49|     76|               MD::compress_n(m_digest, one_block.value(), 1);
   50|     76|            }
   51|       |
   52|    325|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 99, False: 226]
  ------------------
   53|     99|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     99|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 83, False: 16]
  ------------------
   55|     83|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     83|               }
   57|     99|            }
   58|    325|         }
   59|       |
   60|    259|         m_count += input.size();
   61|    259|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|    125|      void final(std::span<uint8_t> output) {
   64|    125|         append_padding_bit();
   65|    125|         append_counter_and_finalize();
   66|    125|         copy_output(output);
   67|    125|         clear();
   68|    125|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE18append_padding_bitEv:
   77|    125|      void append_padding_bit() {
   78|    125|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|    125|   do {                                                                     \
  |  |   61|    125|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 125]
  |  |  ------------------
  |  |   62|    125|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    125|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|    125|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|    125|            const uint8_t final_byte = 0x80;
   81|    125|            m_buffer.append({&final_byte, 1});
   82|    125|         } else {
   83|    125|            const uint8_t final_byte = 0x01;
   84|    125|            m_buffer.append({&final_byte, 1});
   85|    125|         }
   86|    125|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE27append_counter_and_finalizeEv:
   88|    125|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|    125|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 25, False: 100]
  ------------------
   92|     25|            m_buffer.fill_up_with_zeros();
   93|     25|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|     25|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|    125|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|    125|   do {                                                                     \
  |  |   61|    125|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 125]
  |  |  ------------------
  |  |   62|    125|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    125|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|    125|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|    125|         const uint64_t bit_count = m_count * 8;
  102|    125|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|    125|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|    125|            store_be(bit_count, last_bytes.data());
  105|    125|         } else {
  106|    125|            store_le(bit_count, last_bytes.data());
  107|    125|         }
  108|       |
  109|       |         // Compress the very last block.
  110|    125|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|    125|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|    125|      void copy_output(std::span<uint8_t> output) {
  114|    125|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|    125|   do {                                                                     \
  |  |   61|    125|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 125]
  |  |  ------------------
  |  |   62|    125|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    125|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|    125|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|    125|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|    125|         } else {
  119|    125|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|    125|         }
  121|    125|      }

_ZN5Botan4rotrILm18EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm6EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm2EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm22EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm7EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm13EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan3rhoILm2ELm13ELm22EjEET2_S1_:
   51|   177k|inline constexpr T rho(T x) {
   52|   177k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|   177k|}
_ZN5Botan3rhoILm6ELm11ELm25EjEET2_S1_:
   51|   177k|inline constexpr T rho(T x) {
   52|   177k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|   177k|}
_ZN5Botan4rotrILm11EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm25EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan5sigmaILm7ELm18ELm3EjEET2_S1_:
   43|   177k|inline constexpr T sigma(T x) {
   44|   177k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|   177k|}
_ZN5Botan5sigmaILm17ELm19ELm10EjEET2_S1_:
   43|   177k|inline constexpr T sigma(T x) {
   44|   177k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|   177k|}
_ZN5Botan4rotrILm17EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}
_ZN5Botan4rotrILm19EjEET0_S1_:
   35|   177k|{
   36|   177k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|   177k|}

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

_ZNK5Botan7SHA_25613output_lengthEv:
   75|    125|      size_t output_length() const override { return output_bytes; }

_ZN5Botan9SHA2_32_FEjjjRjjjjS0_S0_jjjj:
   31|   177k|                                  uint32_t magic) {
   32|   177k|   uint32_t A_rho = rho<2, 13, 22>(A);
   33|   177k|   uint32_t E_rho = rho<6, 11, 25>(E);
   34|   177k|   uint32_t M2_sigma = sigma<17, 19, 10>(M2);
   35|   177k|   uint32_t M4_sigma = sigma<7, 18, 3>(M4);
   36|   177k|   H += magic + E_rho + choose(E, F, G) + M1;
   37|   177k|   D += H;
   38|   177k|   H += A_rho + majority(A, B, C);
   39|   177k|   M1 += M2_sigma + M3 + M4_sigma;
   40|   177k|}

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

_ZN5Botan12BufferSlicerC2ENSt3__14spanIKhLm18446744073709551615EEE:
  143|    568|      BufferSlicer(std::span<const uint8_t> buffer) : m_remaining(buffer) {}
_ZN5Botan12BufferSlicer4takeEm:
  155|  3.17k|      std::span<const uint8_t> take(const size_t count) {
  156|  3.17k|         BOTAN_STATE_CHECK(remaining() >= count);
  ------------------
  |  |   42|  3.17k|   do {                                                         \
  |  |   43|  3.17k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 3.17k]
  |  |  ------------------
  |  |   44|  3.17k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|  3.17k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|  3.17k|         auto result = m_remaining.first(count);
  158|  3.17k|         m_remaining = m_remaining.subspan(count);
  159|  3.17k|         return result;
  160|  3.17k|      }
_ZNK5Botan12BufferSlicer9remainingEv:
  184|  3.78k|      size_t remaining() const { return m_remaining.size(); }
_ZNK5Botan12BufferSlicer5emptyEv:
  186|    584|      bool empty() const { return m_remaining.empty(); }
_ZN5Botan12value_existsINS_3TLS12Group_ParamsES2_EEbRKNSt3__16vectorIT_NS3_9allocatorIS5_EEEERKT0_:
  117|  3.98k|bool value_exists(const std::vector<T>& vec, const OT& val) {
  118|   700k|   for(size_t i = 0; i != vec.size(); ++i) {
  ------------------
  |  Branch (118:22): [True: 697k, False: 2.31k]
  ------------------
  119|   697k|      if(vec[i] == val) {
  ------------------
  |  Branch (119:10): [True: 1.66k, False: 696k]
  ------------------
  120|  1.66k|         return true;
  121|  1.66k|      }
  122|   697k|   }
  123|  2.31k|   return false;
  124|  3.98k|}

_ZN5Botan3TLS15TLS_Data_ReaderC2EPKcNSt3__14spanIKhLm18446744073709551615EEE:
   27|  8.42k|            m_typename(type), m_buf(buf_in), m_offset(0) {}
_ZN5Botan3TLS15TLS_Data_Reader8get_byteEv:
   78|  40.3k|      uint8_t get_byte() {
   79|  40.3k|         assert_at_least(1);
   80|  40.3k|         uint8_t result = m_buf[m_offset];
   81|  40.3k|         m_offset += 1;
   82|  40.3k|         return result;
   83|  40.3k|      }
_ZNK5Botan3TLS15TLS_Data_Reader15assert_at_leastEm:
  160|   136k|      void assert_at_least(size_t n) const {
  161|   136k|         if(m_buf.size() - m_offset < n) {
  ------------------
  |  Branch (161:13): [True: 460, False: 136k]
  ------------------
  162|    460|            throw_decode_error("Expected " + std::to_string(n) + " bytes remaining, only " +
  163|    460|                               std::to_string(m_buf.size() - m_offset) + " left");
  164|    460|         }
  165|   136k|      }
_ZNK5Botan3TLS15TLS_Data_Reader18throw_decode_errorENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  167|    582|      [[noreturn]] void throw_decode_error(std::string_view why) const {
  168|    582|         throw Decoding_Error(fmt("Invalid {}: {}", m_typename, why));
  169|    582|      }
_ZN5Botan3TLS15TLS_Data_Reader9get_fixedIhEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEm:
  125|  22.7k|      std::vector<T> get_fixed(size_t size) {
  126|  22.7k|         return get_elem<T, std::vector<T>>(size);
  127|  22.7k|      }
_ZN5Botan3TLS15TLS_Data_Reader8get_elemIhNSt3__16vectorIhNS3_9allocatorIhEEEEEET0_m:
   86|  31.7k|      Container get_elem(size_t num_elems) {
   87|  31.7k|         assert_at_least(num_elems * sizeof(T));
   88|       |
   89|  31.7k|         Container result(num_elems);
   90|       |
   91|   963k|         for(size_t i = 0; i != num_elems; ++i) {
  ------------------
  |  Branch (91:28): [True: 931k, False: 31.7k]
  ------------------
   92|   931k|            result[i] = load_be<T>(&m_buf[m_offset], i);
   93|   931k|         }
   94|       |
   95|  31.7k|         m_offset += num_elems * sizeof(T);
   96|       |
   97|  31.7k|         return result;
   98|  31.7k|      }
_ZN5Botan3TLS15TLS_Data_Reader9get_rangeIhEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEmmm:
  105|  2.88k|      std::vector<T> get_range(size_t len_bytes, size_t min_elems, size_t max_elems) {
  106|  2.88k|         const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
  107|       |
  108|  2.88k|         return get_elem<T, std::vector<T>>(num_elems);
  109|  2.88k|      }
_ZN5Botan3TLS15TLS_Data_Reader13get_num_elemsEmmmm:
  144|  11.7k|      size_t get_num_elems(size_t len_bytes, size_t T_size, size_t min_elems, size_t max_elems) {
  145|  11.7k|         const size_t byte_length = get_length_field(len_bytes);
  146|       |
  147|  11.7k|         if(byte_length % T_size != 0) {
  ------------------
  |  Branch (147:13): [True: 20, False: 11.7k]
  ------------------
  148|     20|            throw_decode_error("Size isn't multiple of T");
  149|     20|         }
  150|       |
  151|  11.7k|         const size_t num_elems = byte_length / T_size;
  152|       |
  153|  11.7k|         if(num_elems < min_elems || num_elems > max_elems) {
  ------------------
  |  Branch (153:13): [True: 113, False: 11.6k]
  |  Branch (153:38): [True: 6, False: 11.6k]
  ------------------
  154|     49|            throw_decode_error("Length field outside parameters");
  155|     49|         }
  156|       |
  157|  11.7k|         return num_elems;
  158|  11.7k|      }
_ZN5Botan3TLS15TLS_Data_Reader16get_length_fieldEm:
  130|  22.9k|      size_t get_length_field(size_t len_bytes) {
  131|  22.9k|         assert_at_least(len_bytes);
  132|       |
  133|  22.9k|         if(len_bytes == 1) {
  ------------------
  |  Branch (133:13): [True: 10.8k, False: 12.0k]
  ------------------
  134|  10.8k|            return get_byte();
  135|  12.0k|         } else if(len_bytes == 2) {
  ------------------
  |  Branch (135:20): [True: 11.9k, False: 96]
  ------------------
  136|  11.9k|            return get_uint16_t();
  137|  11.9k|         } else if(len_bytes == 3) {
  ------------------
  |  Branch (137:20): [True: 0, False: 96]
  ------------------
  138|      0|            return get_uint24_t();
  139|      0|         }
  140|       |
  141|     96|         throw_decode_error("Bad length size");
  142|     96|      }
_ZN5Botan3TLS15TLS_Data_Reader12get_uint16_tEv:
   66|  34.7k|      uint16_t get_uint16_t() {
   67|  34.7k|         assert_at_least(2);
   68|  34.7k|         uint16_t result = make_uint16(m_buf[m_offset], m_buf[m_offset + 1]);
   69|  34.7k|         m_offset += 2;
   70|  34.7k|         return result;
   71|  34.7k|      }
_ZN5Botan3TLS15TLS_Data_Reader20get_data_read_so_farEv:
   43|    134|      std::vector<uint8_t> get_data_read_so_far() {
   44|    134|         return std::vector<uint8_t>(m_buf.begin(), m_buf.begin() + m_offset);
   45|    134|      }
_ZN5Botan3TLS15TLS_Data_Reader13get_remainingEv:
   41|    125|      std::vector<uint8_t> get_remaining() { return std::vector<uint8_t>(m_buf.begin() + m_offset, m_buf.end()); }
_ZN5Botan3TLS15TLS_Data_Reader16get_range_vectorItEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEmmm:
  112|  2.68k|      std::vector<T> get_range_vector(size_t len_bytes, size_t min_elems, size_t max_elems) {
  113|  2.68k|         const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
  114|       |
  115|  2.68k|         return get_elem<T, std::vector<T>>(num_elems);
  116|  2.68k|      }
_ZN5Botan3TLS15TLS_Data_Reader8get_elemItNSt3__16vectorItNS3_9allocatorItEEEEEET0_m:
   86|  2.68k|      Container get_elem(size_t num_elems) {
   87|  2.68k|         assert_at_least(num_elems * sizeof(T));
   88|       |
   89|  2.68k|         Container result(num_elems);
   90|       |
   91|  21.0k|         for(size_t i = 0; i != num_elems; ++i) {
  ------------------
  |  Branch (91:28): [True: 18.4k, False: 2.68k]
  ------------------
   92|  18.4k|            result[i] = load_be<T>(&m_buf[m_offset], i);
   93|  18.4k|         }
   94|       |
   95|  2.68k|         m_offset += num_elems * sizeof(T);
   96|       |
   97|  2.68k|         return result;
   98|  2.68k|      }
_ZN5Botan3TLS15TLS_Data_Reader16get_range_vectorIhEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEmmm:
  112|  6.10k|      std::vector<T> get_range_vector(size_t len_bytes, size_t min_elems, size_t max_elems) {
  113|  6.10k|         const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
  114|       |
  115|  6.10k|         return get_elem<T, std::vector<T>>(num_elems);
  116|  6.10k|      }
_ZNK5Botan3TLS15TLS_Data_Reader11assert_doneEv:
   29|  3.93k|      void assert_done() const {
   30|  3.93k|         if(has_remaining()) {
  ------------------
  |  Branch (30:13): [True: 53, False: 3.88k]
  ------------------
   31|     53|            throw_decode_error("Extra bytes at end of message");
   32|     53|         }
   33|  3.93k|      }
_ZNK5Botan3TLS15TLS_Data_Reader11read_so_farEv:
   35|  9.09k|      size_t read_so_far() const { return m_offset; }
_ZNK5Botan3TLS15TLS_Data_Reader15remaining_bytesEv:
   37|  33.7k|      size_t remaining_bytes() const { return m_buf.size() - m_offset; }
_ZNK5Botan3TLS15TLS_Data_Reader13has_remainingEv:
   39|  24.3k|      bool has_remaining() const { return (remaining_bytes() > 0); }
_ZN5Botan3TLS15TLS_Data_Reader12discard_nextEm:
   47|     55|      void discard_next(size_t bytes) {
   48|     55|         assert_at_least(bytes);
   49|     55|         m_offset += bytes;
   50|     55|      }
_ZN5Botan3TLS15TLS_Data_Reader12get_uint32_tEv:
   52|  4.43k|      uint32_t get_uint32_t() {
   53|  4.43k|         assert_at_least(4);
   54|  4.43k|         uint32_t result = make_uint32(m_buf[m_offset], m_buf[m_offset + 1], m_buf[m_offset + 2], m_buf[m_offset + 3]);
   55|  4.43k|         m_offset += 4;
   56|  4.43k|         return result;
   57|  4.43k|      }
_ZN5Botan3TLS15TLS_Data_Reader20get_tls_length_valueEm:
  100|  11.1k|      std::vector<uint8_t> get_tls_length_value(size_t len_bytes) {
  101|  11.1k|         return get_fixed<uint8_t>(get_length_field(len_bytes));
  102|  11.1k|      }
_ZN5Botan3TLS15TLS_Data_Reader10get_stringEmmm:
  118|  3.52k|      std::string get_string(size_t len_bytes, size_t min_bytes, size_t max_bytes) {
  119|  3.52k|         std::vector<uint8_t> v = get_range_vector<uint8_t>(len_bytes, min_bytes, max_bytes);
  120|       |
  121|  3.52k|         return std::string(cast_uint8_ptr_to_char(v.data()), v.size());
  122|  3.52k|      }
_ZN5Botan3TLS15TLS_Data_Reader9get_rangeItEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEmmm:
  105|     73|      std::vector<T> get_range(size_t len_bytes, size_t min_elems, size_t max_elems) {
  106|     73|         const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
  107|       |
  108|     73|         return get_elem<T, std::vector<T>>(num_elems);
  109|     73|      }

_ZN5Botan10BER_ObjectC2Ev:
  128|  38.6k|      BER_Object() : m_type_tag(ASN1_Type::NoObject), m_class_tag(ASN1_Class::Universal) {}
_ZNK5Botan10BER_Object6is_setEv:
  138|  49.4k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|  29.1k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|  29.1k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|  29.1k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  10.4k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|   201k|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|   432k|      size_t length() const { return m_value.size(); }
_ZN5Botan10BER_Object12mutable_bitsEm:
  169|  23.7k|      uint8_t* mutable_bits(size_t length) {
  170|  23.7k|         m_value.resize(length);
  171|  23.7k|         return m_value.data();
  172|  23.7k|      }
_ZNK5Botan11ASN1_String5emptyEv:
  419|  4.98k|      bool empty() const { return m_utf8_str.empty(); }
_ZN5BotanorENS_10ASN1_ClassES0_:
   78|  10.5k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   79|  10.5k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   80|  10.5k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|  29.1k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|  29.1k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|  29.1k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  5.35k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  5.35k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  5.35k|}
_ZN5Botan11ASN1_ObjectD2Ev:
  120|  36.2k|      virtual ~ASN1_Object() = default;
_ZN5Botan11ASN1_ObjectC2Ev:
  117|  14.6k|      ASN1_Object() = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|  21.6k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan3OIDC2Ev:
  218|  5.46k|      explicit OID() = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  134|  10.2k|      BER_Object(BER_Object&& other) = default;

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

_ZN5Botan11BER_Decoder14start_sequenceEv:
  113|  9.15k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9start_setEv:
  115|  1.67k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EE:
  162|  3.28k|      BER_Decoder& raw_bytes(std::vector<uint8_t, Alloc>& out) {
  163|  3.28k|         out.clear();
  164|  3.28k|         uint8_t buf;
  165|   130k|         while(m_source->read_byte(buf)) {
  ------------------
  |  Branch (165:16): [True: 126k, False: 3.28k]
  ------------------
  166|   126k|            out.push_back(buf);
  167|   126k|         }
  168|  3.28k|         return (*this);
  169|  3.28k|      }

_ZN5Botan20Buffered_Computation6updateENSt3__14spanIKhLm18446744073709551615EEE:
   41|    259|      void update(std::span<const uint8_t> in) { add_data(in); }
_ZN5Botan20Buffered_Computation12final_stdvecEv:
   84|    125|      std::vector<uint8_t> final_stdvec() { return final<std::vector<uint8_t>>(); }
_ZN5Botan20Buffered_Computation5finalINSt3__16vectorIhNS2_9allocatorIhEEEEEET_v:
   78|    125|      T final() {
   79|    125|         T output(output_length());
   80|    125|         final_result(output);
   81|    125|         return output;
   82|    125|      }
_ZN5Botan20Buffered_ComputationD2Ev:
  134|    134|      virtual ~Buffered_Computation() = default;

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

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

_ZN5Botan13Invalid_StateC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  208|     16|      explicit Invalid_State(std::string_view err) : Exception(err) {}

_ZN5Botan11clear_bytesEPvm:
  103|    405|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|    405|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 405, False: 0]
  ------------------
  105|    405|      std::memset(ptr, 0, bytes);
  106|    405|   }
  107|    405|}
_ZN5Botan22cast_uint8_ptr_to_charEPKh:
  276|  2.61k|inline const char* cast_uint8_ptr_to_char(const uint8_t* b) {
  277|  2.61k|   return reinterpret_cast<const char*>(b);
  278|  2.61k|}
_ZN5Botan22cast_uint8_ptr_to_charEPh:
  284|  3.47k|inline char* cast_uint8_ptr_to_char(uint8_t* b) {
  285|  3.47k|   return reinterpret_cast<char*>(b);
  286|  3.47k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEEjEEvOT_RKT0_:
  199|  1.00k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|  1.00k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|  1.00k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEENS2_IKjLm1EEEEEvOT_OT0_:
  176|  1.00k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  1.00k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.00k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.00k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEET_OT0_:
  209|  20.2k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  20.2k|   ToT dst;
  211|  20.2k|   typecast_copy(dst, src);
  212|  20.2k|   return dst;
  213|  20.2k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEEvRT_OT0_:
  188|  20.2k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  20.2k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  20.2k|}
_ZN5Botan13typecast_copyINSt3__14spanItLm1EEERNS2_IKhLm2EEEEEvOT_OT0_:
  176|  20.2k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  20.2k|   ranges::assert_equal_byte_lengths(out, in);
  178|  20.2k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  20.2k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEEmEEvOT_RKT0_:
  199|    125|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|    125|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|    125|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEENS2_IKmLm1EEEEEvOT_OT0_:
  176|    125|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|    125|   ranges::assert_equal_byte_lengths(out, in);
  178|    125|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|    125|}
_ZN5Botan8copy_memIhEEvPT_PKS1_m:
  146|   350k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|   350k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|   350k|   do {                                                                                          \
  |  |   79|   660k|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 330k, False: 19.7k]
  |  |  |  Branch (79:23): [True: 330k, False: 0]
  |  |  |  Branch (79:23): [True: 330k, False: 0]
  |  |  ------------------
  |  |   80|   350k|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|   350k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|   350k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 344k, False: 6.02k]
  |  Branch (149:24): [True: 338k, False: 5.77k]
  |  Branch (149:42): [True: 330k, False: 7.91k]
  ------------------
  150|   330k|      std::memmove(out, in, sizeof(T) * n);
  151|   330k|   }
  152|   350k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEET_OT0_:
  209|  44.9k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  44.9k|   ToT dst;
  211|  44.9k|   typecast_copy(dst, src);
  212|  44.9k|   return dst;
  213|  44.9k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEEvRT_OT0_:
  188|  44.9k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  44.9k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  44.9k|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm1EEERNS2_IKhLm4EEEEEvOT_OT0_:
  176|  44.9k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  44.9k|   ranges::assert_equal_byte_lengths(out, in);
  178|  44.9k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  44.9k|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|    404|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|    404|   clear_bytes(ptr, sizeof(T) * n);
  122|    404|}
_ZN5Botan9clear_memIjEEvPT_m:
  120|      1|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|      1|   clear_bytes(ptr, sizeof(T) * n);
  122|      1|}
_ZN5Botan8copy_memIiEEvPT_PKS1_m:
  146|  1.53k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  1.53k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  1.53k|   do {                                                                                          \
  |  |   79|  3.07k|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  ------------------
  |  |   80|  1.53k|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  1.53k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  1.53k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 1.53k, False: 0]
  |  Branch (149:24): [True: 1.53k, False: 0]
  |  Branch (149:42): [True: 1.53k, False: 0]
  ------------------
  150|  1.53k|      std::memmove(out, in, sizeof(T) * n);
  151|  1.53k|   }
  152|  1.53k|}

_ZN5Botan7X509_DNC2Ev:
   39|  3.69k|      X509_DN() = default;

_ZN5Botan16secure_allocatorIhE8allocateEm:
   45|  52.3k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
   47|  52.3k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPS5_T1_EE:
   98|  9.01k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<T*, L>& in) {
   99|  9.01k|   out.insert(out.end(), in.first, in.first + in.second);
  100|  9.01k|   return out;
  101|  9.01k|}
_ZN5Botan16secure_allocatorIjE10deallocateEPjm:
   47|    134|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIjE8allocateEm:
   45|    134|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }

_ZN5Botan6detail11Strong_BaseINSt3__16vectorIhNS2_9allocatorIhEEEEEC2Ev:
   42|  2.72k|      Strong_Base() = default;
_ZN5Botan6detail11Strong_BaseINSt3__16vectorIhNS2_9allocatorIhEEEEEC2ES6_:
   48|  2.73k|      constexpr explicit Strong_Base(T v) : m_value(std::move(v)) {}
_ZN5Botan6detail11Strong_BaseINSt3__16vectorIhNS2_9allocatorIhEEEEEaSEOS7_:
   46|  2.69k|      Strong_Base& operator=(Strong_Base&&) noexcept = default;

_ZN5Botan3TLS12Group_ParamsC2Ev:
  149|    775|      constexpr Group_Params() : m_code(Group_Params_Code::NONE) {}
_ZN5Botan3TLS12Group_ParamsC2Et:
  153|  4.72k|      constexpr Group_Params(uint16_t code) : m_code(static_cast<Group_Params_Code>(code)) {}
_ZNK5Botan3TLS12Group_ParamseqES1_:
  162|   715k|      constexpr bool operator==(Group_Params other) const { return m_code == other.m_code; }

_ZN5Botan3TLS13TLS_ExceptionC2ENS0_9AlertTypeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   24|    229|            Exception(err_msg), m_alert_type(type) {}

_ZN5Botan3TLS21Server_Name_Indicator11static_typeEv:
  126|  2.77k|      static Extension_Code static_type() { return Extension_Code::ServerNameIndication; }
_ZNK5Botan3TLS21Server_Name_Indicator4typeEv:
  128|  2.77k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS23Renegotiation_Extension11static_typeEv:
  149|    642|      static Extension_Code static_type() { return Extension_Code::SafeRenegotiation; }
_ZNK5Botan3TLS23Renegotiation_Extension4typeEv:
  151|    415|      Extension_Code type() const override { return static_type(); }
_ZNK5Botan3TLS23Renegotiation_Extension18renegotiation_infoEv:
  159|      7|      const std::vector<uint8_t>& renegotiation_info() const { return m_reneg_data; }
_ZN5Botan3TLS39Application_Layer_Protocol_Notification11static_typeEv:
  174|  1.84k|      static Extension_Code static_type() { return Extension_Code::ApplicationLayerProtocolNegotiation; }
_ZNK5Botan3TLS39Application_Layer_Protocol_Notification4typeEv:
  176|  1.84k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS23Client_Certificate_Type11static_typeEv:
  259|    248|      static Extension_Code static_type() { return Extension_Code::ClientCertificateType; }
_ZNK5Botan3TLS23Client_Certificate_Type4typeEv:
  261|    248|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS23Server_Certificate_Type11static_typeEv:
  273|    248|      static Extension_Code static_type() { return Extension_Code::ServerCertificateType; }
_ZNK5Botan3TLS23Server_Certificate_Type4typeEv:
  275|    248|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS24Session_Ticket_Extension11static_typeEv:
  283|  2.53k|      static Extension_Code static_type() { return Extension_Code::SessionTicket; }
_ZNK5Botan3TLS24Session_Ticket_Extension4typeEv:
  285|  2.53k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS16Supported_Groups11static_typeEv:
  320|    335|      static Extension_Code static_type() { return Extension_Code::SupportedGroups; }
_ZNK5Botan3TLS16Supported_Groups4typeEv:
  322|    335|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS23Supported_Point_Formats11static_typeEv:
  358|    201|      static Extension_Code static_type() { return Extension_Code::EcPointFormats; }
_ZNK5Botan3TLS23Supported_Point_Formats4typeEv:
  360|    201|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS20Signature_Algorithms11static_typeEv:
  381|    213|      static Extension_Code static_type() { return Extension_Code::SignatureAlgorithms; }
_ZNK5Botan3TLS20Signature_Algorithms4typeEv:
  383|    213|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS25Signature_Algorithms_Cert11static_typeEv:
  414|    218|      static Extension_Code static_type() { return Extension_Code::CertSignatureAlgorithms; }
_ZNK5Botan3TLS25Signature_Algorithms_Cert4typeEv:
  416|    218|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS24SRTP_Protection_Profiles11static_typeEv:
  437|    202|      static Extension_Code static_type() { return Extension_Code::UseSrtp; }
_ZNK5Botan3TLS24SRTP_Protection_Profiles4typeEv:
  439|    202|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS22Extended_Master_Secret11static_typeEv:
  462|  1.91k|      static Extension_Code static_type() { return Extension_Code::ExtendedMasterSecret; }
_ZNK5Botan3TLS22Extended_Master_Secret4typeEv:
  464|  1.91k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS16Encrypt_then_MAC11static_typeEv:
  480|  1.79k|      static Extension_Code static_type() { return Extension_Code::EncryptThenMac; }
_ZNK5Botan3TLS16Encrypt_then_MAC4typeEv:
  482|  1.79k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS26Certificate_Status_Request11static_typeEv:
  500|    230|      static Extension_Code static_type() { return Extension_Code::CertificateStatusRequest; }
_ZNK5Botan3TLS26Certificate_Status_Request4typeEv:
  502|    230|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS18Supported_Versions11static_typeEv:
  538|    220|      static Extension_Code static_type() { return Extension_Code::SupportedVersions; }
_ZNK5Botan3TLS18Supported_Versions4typeEv:
  540|    220|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS17Record_Size_Limit11static_typeEv:
  569|    227|      static Extension_Code static_type() { return Extension_Code::RecordSizeLimit; }
_ZNK5Botan3TLS17Record_Size_Limit4typeEv:
  571|    227|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS6Cookie11static_typeEv:
  595|  1.84k|      static Extension_Code static_type() { return Extension_Code::Cookie; }
_ZNK5Botan3TLS6Cookie4typeEv:
  597|  1.84k|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS22PSK_Key_Exchange_Modes11static_typeEv:
  618|    222|      static Extension_Code static_type() { return Extension_Code::PskKeyExchangeModes; }
_ZNK5Botan3TLS22PSK_Key_Exchange_Modes4typeEv:
  620|    222|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS23Certificate_Authorities11static_typeEv:
  641|    488|      static Extension_Code static_type() { return Extension_Code::CertificateAuthorities; }
_ZNK5Botan3TLS23Certificate_Authorities4typeEv:
  643|    488|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS3PSK11static_typeEv:
  663|    209|      static Extension_Code static_type() { return Extension_Code::PresharedKey; }
_ZNK5Botan3TLS3PSK4typeEv:
  665|    209|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS9Key_Share11static_typeEv:
  763|    249|      static Extension_Code static_type() { return Extension_Code::KeyShare; }
_ZNK5Botan3TLS9Key_Share4typeEv:
  765|    249|      Extension_Code type() const override { return static_type(); }
_ZN5Botan3TLS19EarlyDataIndication11static_typeEv:
  857|  2.09k|      static Extension_Code static_type() { return Extension_Code::EarlyData; }
_ZNK5Botan3TLS19EarlyDataIndication4typeEv:
  859|  2.09k|      Extension_Code type() const override { return static_type(); }
_ZNK5Botan3TLS17Unknown_Extension4typeEv:
  896|   200k|      Extension_Code type() const override { return m_type; }
_ZNK5Botan3TLS10Extensions3hasENS0_14Extension_CodeE:
  924|  9.92k|      bool has(Extension_Code type) const { return get(type) != nullptr; }
_ZN5Botan3TLS10Extensions3addEPNS0_9ExtensionE:
  932|    220|      void add(Extension* extn) { add(std::unique_ptr<Extension>(extn)); }
_ZZNK5Botan3TLS10Extensions3getENS0_14Extension_CodeEENKUlRKT_E_clINSt3__110unique_ptrINS0_9ExtensionENS8_14default_deleteISA_EEEEEEDaS5_:
  936|   214k|            m_extensions.cbegin(), m_extensions.cend(), [type](const auto& ext) { return ext->type() == type; });
_ZNK5Botan3TLS10Extensions3getENS0_14Extension_CodeE:
  934|  10.1k|      Extension* get(Extension_Code type) const {
  935|  10.1k|         const auto i = std::find_if(
  936|  10.1k|            m_extensions.cbegin(), m_extensions.cend(), [type](const auto& ext) { return ext->type() == type; });
  937|       |
  938|  10.1k|         return (i != m_extensions.end()) ? i->get() : nullptr;
  ------------------
  |  Branch (938:17): [True: 14, False: 10.1k]
  ------------------
  939|  10.1k|      }
_ZN5Botan3TLS9ExtensionD2Ev:
  118|  5.94k|      virtual ~Extension() = default;
_ZN5Botan3TLS23Renegotiation_ExtensionC2Ev:
  153|    220|      Renegotiation_Extension() = default;
_ZN5Botan3TLS10ExtensionsC2Ev:
  995|  2.72k|      Extensions() = default;
_ZNK5Botan3TLS10Extensions3getINS0_23Renegotiation_ExtensionEEEPT_v:
  915|    227|      T* get() const {
  916|    227|         return dynamic_cast<T*>(get(T::static_type()));
  917|    227|      }

_ZN5Botan3TLS17Handshake_MessageD2Ev:
   50|    580|      virtual ~Handshake_Message() = default;
_ZN5Botan3TLS17Handshake_MessageC2Ev:
   51|    580|      Handshake_Message() = default;

_ZN5Botan3TLS11PskIdentityC2ENSt3__16vectorIhNS2_9allocatorIhEEEEj:
   36|  4.42k|            m_identity(std::move(identity)), m_obfuscated_age(obfuscated_age) {}

_ZN5Botan3TLS16Protocol_VersionC2Ev:
   49|  2.72k|      Protocol_Version() : m_version(0) {}
_ZN5Botan3TLS16Protocol_VersionC2Et:
   51|  3.41k|      explicit Protocol_Version(uint16_t code) : m_version(code) {}
_ZN5Botan3TLS16Protocol_VersionC2Ehh:
   63|  2.70k|            Protocol_Version(static_cast<uint16_t>((static_cast<uint16_t>(major) << 8) | minor)) {}
_ZNK5Botan3TLS16Protocol_Version13major_versionEv:
   78|  2.69k|      uint8_t major_version() const { return static_cast<uint8_t>(m_version >> 8); }

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

_Z4fuzzPKhm:
   11|  2.72k|void fuzz(const uint8_t in[], size_t len) {
   12|  2.72k|   try {
   13|  2.72k|      std::vector<uint8_t> v(in, in + len);
   14|  2.72k|      Botan::TLS::Client_Hello_12 ch(v);  // TODO: We might want to do that for TLS 1.3 as well
   15|  2.72k|   } catch(Botan::Exception& e) {}
   16|  2.72k|}

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

_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  191|  5.36k|void OID::decode_from(BER_Decoder& decoder) {
  192|  5.36k|   BER_Object obj = decoder.get_next_object();
  193|  5.36k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (193:7): [True: 68, False: 5.30k]
  ------------------
  194|     68|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  195|     68|   }
  196|       |
  197|  5.30k|   const size_t length = obj.length();
  198|  5.30k|   const uint8_t* bits = obj.bits();
  199|       |
  200|  5.30k|   if(length < 2 && !(length == 1 && bits[0] == 0)) {
  ------------------
  |  Branch (200:7): [True: 2.80k, False: 2.49k]
  |  Branch (200:23): [True: 2.79k, False: 3]
  |  Branch (200:38): [True: 2.79k, False: 8]
  ------------------
  201|     11|      throw BER_Decoding_Error("OID encoding is too short");
  202|     11|   }
  203|       |
  204|  5.28k|   m_id.clear();
  205|  5.28k|   m_id.push_back(bits[0] / 40);
  206|  5.28k|   m_id.push_back(bits[0] % 40);
  207|       |
  208|  5.28k|   size_t i = 0;
  209|  27.9k|   while(i != length - 1) {
  ------------------
  |  Branch (209:10): [True: 22.7k, False: 5.25k]
  ------------------
  210|  22.7k|      uint32_t component = 0;
  211|  28.5k|      while(i != length - 1) {
  ------------------
  |  Branch (211:13): [True: 26.6k, False: 1.89k]
  ------------------
  212|  26.6k|         ++i;
  213|       |
  214|  26.6k|         if(component >> (32 - 7)) {
  ------------------
  |  Branch (214:13): [True: 32, False: 26.6k]
  ------------------
  215|     32|            throw Decoding_Error("OID component overflow");
  216|     32|         }
  217|       |
  218|  26.6k|         component = (component << 7) + (bits[i] & 0x7F);
  219|       |
  220|  26.6k|         if(!(bits[i] & 0x80)) {
  ------------------
  |  Branch (220:13): [True: 20.7k, False: 5.84k]
  ------------------
  221|  20.7k|            break;
  222|  20.7k|         }
  223|  26.6k|      }
  224|  22.6k|      m_id.push_back(component);
  225|  22.6k|   }
  226|  5.28k|}

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

_ZNK5Botan11BER_Decoder10more_itemsEv:
  195|  11.0k|bool BER_Decoder::more_items() const {
  196|  11.0k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (196:7): [True: 3.89k, False: 7.13k]
  |  Branch (196:34): [True: 3.89k, False: 0]
  ------------------
  197|  3.89k|      return false;
  198|  3.89k|   }
  199|  7.13k|   return true;
  200|  11.0k|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  231|  21.4k|BER_Object BER_Decoder::get_next_object() {
  232|  21.4k|   BER_Object next;
  233|       |
  234|  21.4k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (234:7): [True: 0, False: 21.4k]
  ------------------
  235|      0|      std::swap(next, m_pushed);
  236|      0|      return next;
  237|      0|   }
  238|       |
  239|  24.1k|   for(;;) {
  240|  24.1k|      ASN1_Type type_tag;
  241|  24.1k|      ASN1_Class class_tag;
  242|  24.1k|      decode_tag(m_source, type_tag, class_tag);
  243|  24.1k|      next.set_tagging(type_tag, class_tag);
  244|  24.1k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (244:10): [True: 109, False: 24.0k]
  ------------------
  245|    109|         return next;
  246|    109|      }
  247|       |
  248|  24.0k|      size_t field_size;
  249|  24.0k|      const size_t length = decode_length(m_source, field_size, ALLOWED_EOC_NESTINGS);
  250|  24.0k|      if(!m_source->check_available(length)) {
  ------------------
  |  Branch (250:10): [True: 123, False: 23.8k]
  ------------------
  251|    123|         throw BER_Decoding_Error("Value truncated");
  252|    123|      }
  253|       |
  254|  23.8k|      uint8_t* out = next.mutable_bits(length);
  255|  23.8k|      if(m_source->read(out, length) != length) {
  ------------------
  |  Branch (255:10): [True: 0, False: 23.8k]
  ------------------
  256|      0|         throw BER_Decoding_Error("Value truncated");
  257|      0|      }
  258|       |
  259|  23.8k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (259:10): [True: 2.68k, False: 21.2k]
  ------------------
  260|  2.68k|         continue;
  261|  21.2k|      } else {
  262|  21.2k|         break;
  263|  21.2k|      }
  264|  23.8k|   }
  265|       |
  266|  21.2k|   return next;
  267|  21.4k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  286|  10.8k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  287|  10.8k|   BER_Object obj = get_next_object();
  288|  10.8k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  289|  10.8k|   return BER_Decoder(std::move(obj), this);
  290|  10.8k|}
_ZN5Botan11BER_Decoder8end_consEv:
  295|  8.34k|BER_Decoder& BER_Decoder::end_cons() {
  296|  8.34k|   if(!m_parent) {
  ------------------
  |  Branch (296:7): [True: 0, False: 8.34k]
  ------------------
  297|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  298|      0|   }
  299|  8.34k|   if(!m_source->end_of_data()) {
  ------------------
  |  Branch (299:7): [True: 78, False: 8.26k]
  ------------------
  300|     78|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  301|     78|   }
  302|  8.26k|   return (*m_parent);
  303|  8.34k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  305|  10.2k|BER_Decoder::BER_Decoder(BER_Object&& obj, BER_Decoder* parent) {
  306|  10.2k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  307|  10.2k|   m_source = m_data_src.get();
  308|  10.2k|   m_parent = parent;
  309|  10.2k|}
_ZN5Botan11BER_DecoderC2EPKhm:
  321|  3.69k|BER_Decoder::BER_Decoder(const uint8_t data[], size_t length) {
  322|  3.69k|   m_data_src = std::make_unique<DataSource_Memory>(data, length);
  323|  3.69k|   m_source = m_data_src.get();
  324|  3.69k|}
_ZN5Botan11BER_DecoderC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  337|  3.28k|BER_Decoder::BER_Decoder(const std::vector<uint8_t>& data) {
  338|  3.28k|   m_data_src = std::make_unique<DataSource_Memory>(data.data(), data.size());
  339|  3.28k|   m_source = m_data_src.get();
  340|  3.28k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  356|  14.3k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  357|  14.3k|   obj.decode_from(*this);
  358|  14.3k|   return (*this);
  359|  14.3k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|  72.3k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|  72.3k|   uint8_t b;
   31|  72.3k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (31:7): [True: 9.49k, False: 62.8k]
  ------------------
   32|  9.49k|      type_tag = ASN1_Type::NoObject;
   33|  9.49k|      class_tag = ASN1_Class::NoObject;
   34|  9.49k|      return 0;
   35|  9.49k|   }
   36|       |
   37|  62.8k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (37:7): [True: 61.4k, False: 1.35k]
  ------------------
   38|  61.4k|      type_tag = ASN1_Type(b & 0x1F);
   39|  61.4k|      class_tag = ASN1_Class(b & 0xE0);
   40|  61.4k|      return 1;
   41|  61.4k|   }
   42|       |
   43|  1.35k|   size_t tag_bytes = 1;
   44|  1.35k|   class_tag = ASN1_Class(b & 0xE0);
   45|       |
   46|  1.35k|   size_t tag_buf = 0;
   47|  3.52k|   while(true) {
  ------------------
  |  Branch (47:10): [Folded - Ignored]
  ------------------
   48|  3.52k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (48:10): [True: 13, False: 3.51k]
  ------------------
   49|     13|         throw BER_Decoding_Error("Long-form tag truncated");
   50|     13|      }
   51|  3.51k|      if(tag_buf & 0xFF000000) {
  ------------------
  |  Branch (51:10): [True: 9, False: 3.50k]
  ------------------
   52|      9|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|      9|      }
   54|  3.50k|      ++tag_bytes;
   55|  3.50k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
   56|  3.50k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (56:10): [True: 1.33k, False: 2.17k]
  ------------------
   57|  1.33k|         break;
   58|  1.33k|      }
   59|  3.50k|   }
   60|  1.33k|   type_tag = ASN1_Type(tag_buf);
   61|  1.33k|   return tag_bytes;
   62|  1.35k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceERmm:
   72|  62.8k|size_t decode_length(DataSource* ber, size_t& field_size, size_t allow_indef) {
   73|  62.8k|   uint8_t b;
   74|  62.8k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (74:7): [True: 104, False: 62.6k]
  ------------------
   75|    104|      throw BER_Decoding_Error("Length field not found");
   76|    104|   }
   77|  62.6k|   field_size = 1;
   78|  62.6k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (78:7): [True: 48.2k, False: 14.4k]
  ------------------
   79|  48.2k|      return b;
   80|  48.2k|   }
   81|       |
   82|  14.4k|   field_size += (b & 0x7F);
   83|  14.4k|   if(field_size > 5) {
  ------------------
  |  Branch (83:7): [True: 11, False: 14.4k]
  ------------------
   84|     11|      throw BER_Decoding_Error("Length field is too large");
   85|     11|   }
   86|       |
   87|  14.4k|   if(field_size == 1) {
  ------------------
  |  Branch (87:7): [True: 13.0k, False: 1.40k]
  ------------------
   88|  13.0k|      if(allow_indef == 0) {
  ------------------
  |  Branch (88:10): [True: 1, False: 13.0k]
  ------------------
   89|      1|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
   90|  13.0k|      } else {
   91|  13.0k|         return find_eoc(ber, allow_indef - 1);
   92|  13.0k|      }
   93|  13.0k|   }
   94|       |
   95|  1.40k|   size_t length = 0;
   96|       |
   97|  3.35k|   for(size_t i = 0; i != field_size - 1; ++i) {
  ------------------
  |  Branch (97:22): [True: 1.96k, False: 1.39k]
  ------------------
   98|  1.96k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (98:10): [True: 0, False: 1.96k]
  ------------------
   99|      0|         throw BER_Decoding_Error("Field length overflow");
  100|      0|      }
  101|  1.96k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (101:10): [True: 14, False: 1.95k]
  ------------------
  102|     14|         throw BER_Decoding_Error("Corrupted length field");
  103|     14|      }
  104|  1.95k|      length = (length << 8) | b;
  105|  1.95k|   }
  106|  1.39k|   return length;
  107|  1.40k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEm:
  112|  13.0k|size_t find_eoc(DataSource* ber, size_t allow_indef) {
  113|  13.0k|   secure_vector<uint8_t> buffer(BOTAN_DEFAULT_BUFFER_SIZE), data;
  ------------------
  |  |  388|  13.0k|#define BOTAN_DEFAULT_BUFFER_SIZE 4096
  ------------------
  114|       |
  115|  22.0k|   while(true) {
  ------------------
  |  Branch (115:10): [Folded - Ignored]
  ------------------
  116|  22.0k|      const size_t got = ber->peek(buffer.data(), buffer.size(), data.size());
  117|  22.0k|      if(got == 0) {
  ------------------
  |  Branch (117:10): [True: 13.0k, False: 9.01k]
  ------------------
  118|  13.0k|         break;
  119|  13.0k|      }
  120|       |
  121|  9.01k|      data += std::make_pair(buffer.data(), got);
  122|  9.01k|   }
  123|       |
  124|  13.0k|   DataSource_Memory source(data);
  125|  13.0k|   data.clear();
  126|       |
  127|  13.0k|   size_t length = 0;
  128|  48.3k|   while(true) {
  ------------------
  |  Branch (128:10): [Folded - Ignored]
  ------------------
  129|  48.1k|      ASN1_Type type_tag;
  130|  48.1k|      ASN1_Class class_tag;
  131|  48.1k|      size_t tag_size = decode_tag(&source, type_tag, class_tag);
  132|  48.1k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (132:10): [True: 9.39k, False: 38.8k]
  ------------------
  133|  9.39k|         break;
  134|  9.39k|      }
  135|       |
  136|  38.8k|      size_t length_size = 0;
  137|  38.8k|      size_t item_size = decode_length(&source, length_size, allow_indef);
  138|  38.8k|      source.discard_next(item_size);
  139|       |
  140|  38.8k|      length = BOTAN_CHECKED_ADD(length, item_size);
  ------------------
  |  |   73|  38.8k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  141|  38.8k|      length = BOTAN_CHECKED_ADD(length, tag_size);
  ------------------
  |  |   73|  38.8k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  142|  38.8k|      length = BOTAN_CHECKED_ADD(length, length_size);
  ------------------
  |  |   73|  38.8k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  143|       |
  144|  38.8k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (144:10): [True: 4.84k, False: 33.9k]
  |  Branch (144:40): [True: 3.53k, False: 1.30k]
  ------------------
  145|  3.53k|         break;
  146|  3.53k|      }
  147|  38.8k|   }
  148|  13.0k|   return length;
  149|  13.0k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  183|  10.2k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)), m_offset(0) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  153|   181k|      size_t read(uint8_t out[], size_t length) override {
  154|   181k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|   181k|   do {                                                                     \
  |  |   61|   181k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 181k]
  |  |  ------------------
  |  |   62|   181k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|   181k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  155|   181k|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  156|   181k|         copy_mem(out, m_obj.bits() + m_offset, got);
  157|   181k|         m_offset += got;
  158|   181k|         return got;
  159|   181k|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  174|  16.8k|      bool check_available(size_t n) override {
  175|  16.8k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  16.8k|   do {                                                                     \
  |  |   61|  16.8k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 16.8k]
  |  |  ------------------
  |  |   62|  16.8k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  16.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  176|  16.8k|         return (n <= (m_obj.length() - m_offset));
  177|  16.8k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject4peekEPhmm:
  161|  3.82k|      size_t peek(uint8_t out[], size_t length, size_t peek_offset) const override {
  162|  3.82k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  3.82k|   do {                                                                     \
  |  |   61|  3.82k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.82k]
  |  |  ------------------
  |  |   62|  3.82k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.82k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  3.82k|         const size_t bytes_left = m_obj.length() - m_offset;
  164|       |
  165|  3.82k|         if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (165:13): [True: 2.63k, False: 1.19k]
  ------------------
  166|  2.63k|            return 0;
  167|  2.63k|         }
  168|       |
  169|  1.19k|         const size_t got = std::min(bytes_left - peek_offset, length);
  170|  1.19k|         copy_mem(out, m_obj.bits() + m_offset + peek_offset, got);
  171|  1.19k|         return got;
  172|  3.82k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  179|  14.9k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  181|  14.9k|      size_t get_bytes_read() const override { return m_offset; }

_ZN5Botan12HashFunction6createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
  107|    134|std::unique_ptr<HashFunction> HashFunction::create(std::string_view algo_spec, std::string_view provider) {
  108|       |#if defined(BOTAN_HAS_COMMONCRYPTO)
  109|       |   if(provider.empty() || provider == "commoncrypto") {
  110|       |      if(auto hash = make_commoncrypto_hash(algo_spec))
  111|       |         return hash;
  112|       |
  113|       |      if(!provider.empty())
  114|       |         return nullptr;
  115|       |   }
  116|       |#endif
  117|       |
  118|    134|   if(provider.empty() == false && provider != "base") {
  ------------------
  |  Branch (118:7): [True: 0, False: 134]
  |  Branch (118:36): [True: 0, False: 0]
  ------------------
  119|      0|      return nullptr;  // unknown provider
  120|      0|   }
  121|       |
  122|    134|#if defined(BOTAN_HAS_SHA1)
  123|    134|   if(algo_spec == "SHA-1") {
  ------------------
  |  Branch (123:7): [True: 0, False: 134]
  ------------------
  124|      0|      return std::make_unique<SHA_1>();
  125|      0|   }
  126|    134|#endif
  127|       |
  128|    134|#if defined(BOTAN_HAS_SHA2_32)
  129|    134|   if(algo_spec == "SHA-224") {
  ------------------
  |  Branch (129:7): [True: 0, False: 134]
  ------------------
  130|      0|      return std::make_unique<SHA_224>();
  131|      0|   }
  132|       |
  133|    134|   if(algo_spec == "SHA-256") {
  ------------------
  |  Branch (133:7): [True: 134, False: 0]
  ------------------
  134|    134|      return std::make_unique<SHA_256>();
  135|    134|   }
  136|      0|#endif
  137|       |
  138|      0|#if defined(BOTAN_HAS_SHA2_64)
  139|      0|   if(algo_spec == "SHA-384") {
  ------------------
  |  Branch (139:7): [True: 0, False: 0]
  ------------------
  140|      0|      return std::make_unique<SHA_384>();
  141|      0|   }
  142|       |
  143|      0|   if(algo_spec == "SHA-512") {
  ------------------
  |  Branch (143:7): [True: 0, False: 0]
  ------------------
  144|      0|      return std::make_unique<SHA_512>();
  145|      0|   }
  146|       |
  147|      0|   if(algo_spec == "SHA-512-256") {
  ------------------
  |  Branch (147:7): [True: 0, False: 0]
  ------------------
  148|      0|      return std::make_unique<SHA_512_256>();
  149|      0|   }
  150|      0|#endif
  151|       |
  152|      0|#if defined(BOTAN_HAS_RIPEMD_160)
  153|      0|   if(algo_spec == "RIPEMD-160") {
  ------------------
  |  Branch (153:7): [True: 0, False: 0]
  ------------------
  154|      0|      return std::make_unique<RIPEMD_160>();
  155|      0|   }
  156|      0|#endif
  157|       |
  158|      0|#if defined(BOTAN_HAS_WHIRLPOOL)
  159|      0|   if(algo_spec == "Whirlpool") {
  ------------------
  |  Branch (159:7): [True: 0, False: 0]
  ------------------
  160|      0|      return std::make_unique<Whirlpool>();
  161|      0|   }
  162|      0|#endif
  163|       |
  164|      0|#if defined(BOTAN_HAS_MD5)
  165|      0|   if(algo_spec == "MD5") {
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|      return std::make_unique<MD5>();
  167|      0|   }
  168|      0|#endif
  169|       |
  170|      0|#if defined(BOTAN_HAS_MD4)
  171|      0|   if(algo_spec == "MD4") {
  ------------------
  |  Branch (171:7): [True: 0, False: 0]
  ------------------
  172|      0|      return std::make_unique<MD4>();
  173|      0|   }
  174|      0|#endif
  175|       |
  176|      0|#if defined(BOTAN_HAS_GOST_34_11)
  177|      0|   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11") {
  ------------------
  |  Branch (177:7): [True: 0, False: 0]
  |  Branch (177:41): [True: 0, False: 0]
  ------------------
  178|      0|      return std::make_unique<GOST_34_11>();
  179|      0|   }
  180|      0|#endif
  181|       |
  182|      0|#if defined(BOTAN_HAS_ADLER32)
  183|      0|   if(algo_spec == "Adler32") {
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      0|      return std::make_unique<Adler32>();
  185|      0|   }
  186|      0|#endif
  187|       |
  188|      0|#if defined(BOTAN_HAS_CRC24)
  189|      0|   if(algo_spec == "CRC24") {
  ------------------
  |  Branch (189:7): [True: 0, False: 0]
  ------------------
  190|      0|      return std::make_unique<CRC24>();
  191|      0|   }
  192|      0|#endif
  193|       |
  194|      0|#if defined(BOTAN_HAS_CRC32)
  195|      0|   if(algo_spec == "CRC32") {
  ------------------
  |  Branch (195:7): [True: 0, False: 0]
  ------------------
  196|      0|      return std::make_unique<CRC32>();
  197|      0|   }
  198|      0|#endif
  199|       |
  200|      0|#if defined(BOTAN_HAS_STREEBOG)
  201|      0|   if(algo_spec == "Streebog-256") {
  ------------------
  |  Branch (201:7): [True: 0, False: 0]
  ------------------
  202|      0|      return std::make_unique<Streebog>(256);
  203|      0|   }
  204|      0|   if(algo_spec == "Streebog-512") {
  ------------------
  |  Branch (204:7): [True: 0, False: 0]
  ------------------
  205|      0|      return std::make_unique<Streebog>(512);
  206|      0|   }
  207|      0|#endif
  208|       |
  209|      0|#if defined(BOTAN_HAS_SM3)
  210|      0|   if(algo_spec == "SM3") {
  ------------------
  |  Branch (210:7): [True: 0, False: 0]
  ------------------
  211|      0|      return std::make_unique<SM3>();
  212|      0|   }
  213|      0|#endif
  214|       |
  215|      0|   const SCAN_Name req(algo_spec);
  216|       |
  217|      0|#if defined(BOTAN_HAS_SKEIN_512)
  218|      0|   if(req.algo_name() == "Skein-512") {
  ------------------
  |  Branch (218:7): [True: 0, False: 0]
  ------------------
  219|      0|      return std::make_unique<Skein_512>(req.arg_as_integer(0, 512), req.arg(1, ""));
  220|      0|   }
  221|      0|#endif
  222|       |
  223|      0|#if defined(BOTAN_HAS_BLAKE2B)
  224|      0|   if(req.algo_name() == "Blake2b" || req.algo_name() == "BLAKE2b") {
  ------------------
  |  Branch (224:7): [True: 0, False: 0]
  |  Branch (224:39): [True: 0, False: 0]
  ------------------
  225|      0|      return std::make_unique<BLAKE2b>(req.arg_as_integer(0, 512));
  226|      0|   }
  227|      0|#endif
  228|       |
  229|      0|#if defined(BOTAN_HAS_BLAKE2S)
  230|      0|   if(req.algo_name() == "Blake2s" || req.algo_name() == "BLAKE2s") {
  ------------------
  |  Branch (230:7): [True: 0, False: 0]
  |  Branch (230:39): [True: 0, False: 0]
  ------------------
  231|      0|      return std::make_unique<BLAKE2s>(req.arg_as_integer(0, 256));
  232|      0|   }
  233|      0|#endif
  234|       |
  235|      0|#if defined(BOTAN_HAS_KECCAK)
  236|      0|   if(req.algo_name() == "Keccak-1600") {
  ------------------
  |  Branch (236:7): [True: 0, False: 0]
  ------------------
  237|      0|      return std::make_unique<Keccak_1600>(req.arg_as_integer(0, 512));
  238|      0|   }
  239|      0|#endif
  240|       |
  241|      0|#if defined(BOTAN_HAS_SHA3)
  242|      0|   if(req.algo_name() == "SHA-3") {
  ------------------
  |  Branch (242:7): [True: 0, False: 0]
  ------------------
  243|      0|      return std::make_unique<SHA_3>(req.arg_as_integer(0, 512));
  244|      0|   }
  245|      0|#endif
  246|       |
  247|      0|#if defined(BOTAN_HAS_SHAKE)
  248|      0|   if(req.algo_name() == "SHAKE-128" && req.arg_count() == 1) {
  ------------------
  |  Branch (248:7): [True: 0, False: 0]
  |  Branch (248:41): [True: 0, False: 0]
  ------------------
  249|      0|      return std::make_unique<SHAKE_128>(req.arg_as_integer(0));
  250|      0|   }
  251|      0|   if(req.algo_name() == "SHAKE-256" && req.arg_count() == 1) {
  ------------------
  |  Branch (251:7): [True: 0, False: 0]
  |  Branch (251:41): [True: 0, False: 0]
  ------------------
  252|      0|      return std::make_unique<SHAKE_256>(req.arg_as_integer(0));
  253|      0|   }
  254|      0|#endif
  255|       |
  256|      0|#if defined(BOTAN_HAS_PARALLEL_HASH)
  257|      0|   if(req.algo_name() == "Parallel") {
  ------------------
  |  Branch (257:7): [True: 0, False: 0]
  ------------------
  258|      0|      std::vector<std::unique_ptr<HashFunction>> hashes;
  259|       |
  260|      0|      for(size_t i = 0; i != req.arg_count(); ++i) {
  ------------------
  |  Branch (260:25): [True: 0, False: 0]
  ------------------
  261|      0|         auto h = HashFunction::create(req.arg(i));
  262|      0|         if(!h) {
  ------------------
  |  Branch (262:13): [True: 0, False: 0]
  ------------------
  263|      0|            return nullptr;
  264|      0|         }
  265|      0|         hashes.push_back(std::move(h));
  266|      0|      }
  267|       |
  268|      0|      return std::make_unique<Parallel>(hashes);
  269|      0|   }
  270|      0|#endif
  271|       |
  272|      0|#if defined(BOTAN_HAS_TRUNCATED_HASH)
  273|      0|   if(req.algo_name() == "Truncated" && req.arg_count() == 2) {
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  |  Branch (273:41): [True: 0, False: 0]
  ------------------
  274|      0|      auto hash = HashFunction::create(req.arg(0));
  275|      0|      if(!hash) {
  ------------------
  |  Branch (275:10): [True: 0, False: 0]
  ------------------
  276|      0|         return nullptr;
  277|      0|      }
  278|       |
  279|      0|      return std::make_unique<Truncated_Hash>(std::move(hash), req.arg_as_integer(1));
  280|      0|   }
  281|      0|#endif
  282|       |
  283|      0|#if defined(BOTAN_HAS_COMB4P)
  284|      0|   if(req.algo_name() == "Comb4P" && req.arg_count() == 2) {
  ------------------
  |  Branch (284:7): [True: 0, False: 0]
  |  Branch (284:38): [True: 0, False: 0]
  ------------------
  285|      0|      auto h1 = HashFunction::create(req.arg(0));
  286|      0|      auto h2 = HashFunction::create(req.arg(1));
  287|       |
  288|      0|      if(h1 && h2) {
  ------------------
  |  Branch (288:10): [True: 0, False: 0]
  |  Branch (288:16): [True: 0, False: 0]
  ------------------
  289|      0|         return std::make_unique<Comb4P>(std::move(h1), std::move(h2));
  290|      0|      }
  291|      0|   }
  292|      0|#endif
  293|       |
  294|      0|   return nullptr;
  295|      0|}
_ZN5Botan12HashFunction15create_or_throwENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
  298|    134|std::unique_ptr<HashFunction> HashFunction::create_or_throw(std::string_view algo, std::string_view provider) {
  299|    134|   if(auto hash = HashFunction::create(algo, provider)) {
  ------------------
  |  Branch (299:12): [True: 134, False: 0]
  ------------------
  300|    134|      return hash;
  301|    134|   }
  302|      0|   throw Lookup_Error("Hash", algo, provider);
  303|    134|}

_ZN5Botan7SHA_25615compress_digestERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   49|    309|void SHA_256::compress_digest(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   50|    309|#if defined(BOTAN_HAS_SHA2_32_X86)
   51|    309|   if(CPUID::has_intel_sha()) {
  ------------------
  |  Branch (51:7): [True: 0, False: 309]
  ------------------
   52|      0|      return SHA_256::compress_digest_x86(digest, input, blocks);
   53|      0|   }
   54|    309|#endif
   55|       |
   56|    309|#if defined(BOTAN_HAS_SHA2_32_X86_BMI2)
   57|    309|   if(CPUID::has_bmi2()) {
  ------------------
  |  Branch (57:7): [True: 309, False: 0]
  ------------------
   58|    309|      return SHA_256::compress_digest_x86_bmi2(digest, input, blocks);
   59|    309|   }
   60|      0|#endif
   61|       |
   62|       |#if defined(BOTAN_HAS_SHA2_32_ARMV8)
   63|       |   if(CPUID::has_arm_sha2()) {
   64|       |      return SHA_256::compress_digest_armv8(digest, input, blocks);
   65|       |   }
   66|       |#endif
   67|       |
   68|      0|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4], F = digest[5], G = digest[6],
   69|      0|            H = digest[7];
   70|       |
   71|      0|   BufferSlicer in(input);
   72|       |
   73|      0|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (73:22): [True: 0, False: 0]
  ------------------
   74|      0|      const auto block = in.take(block_bytes);
   75|       |
   76|      0|      uint32_t W00 = load_be<uint32_t>(block.data(), 0);
   77|      0|      uint32_t W01 = load_be<uint32_t>(block.data(), 1);
   78|      0|      uint32_t W02 = load_be<uint32_t>(block.data(), 2);
   79|      0|      uint32_t W03 = load_be<uint32_t>(block.data(), 3);
   80|      0|      uint32_t W04 = load_be<uint32_t>(block.data(), 4);
   81|      0|      uint32_t W05 = load_be<uint32_t>(block.data(), 5);
   82|      0|      uint32_t W06 = load_be<uint32_t>(block.data(), 6);
   83|      0|      uint32_t W07 = load_be<uint32_t>(block.data(), 7);
   84|      0|      uint32_t W08 = load_be<uint32_t>(block.data(), 8);
   85|      0|      uint32_t W09 = load_be<uint32_t>(block.data(), 9);
   86|      0|      uint32_t W10 = load_be<uint32_t>(block.data(), 10);
   87|      0|      uint32_t W11 = load_be<uint32_t>(block.data(), 11);
   88|      0|      uint32_t W12 = load_be<uint32_t>(block.data(), 12);
   89|      0|      uint32_t W13 = load_be<uint32_t>(block.data(), 13);
   90|      0|      uint32_t W14 = load_be<uint32_t>(block.data(), 14);
   91|      0|      uint32_t W15 = load_be<uint32_t>(block.data(), 15);
   92|       |
   93|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98);
   94|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x71374491);
   95|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCF);
   96|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA5);
   97|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25B);
   98|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1);
   99|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4);
  100|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5);
  101|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98);
  102|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B01);
  103|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE);
  104|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3);
  105|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74);
  106|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE);
  107|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A7);
  108|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174);
  109|       |
  110|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C1);
  111|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786);
  112|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC6);
  113|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC);
  114|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F);
  115|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA);
  116|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DC);
  117|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA);
  118|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152);
  119|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D);
  120|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C8);
  121|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7);
  122|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF3);
  123|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147);
  124|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351);
  125|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x14292967);
  126|       |
  127|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A85);
  128|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B2138);
  129|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC);
  130|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D13);
  131|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A7354);
  132|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB);
  133|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E);
  134|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C85);
  135|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A1);
  136|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664B);
  137|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70);
  138|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A3);
  139|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819);
  140|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD6990624);
  141|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E3585);
  142|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA070);
  143|       |
  144|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116);
  145|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C08);
  146|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774C);
  147|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5);
  148|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3);
  149|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4A);
  150|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F);
  151|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3);
  152|      0|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE);
  153|      0|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F);
  154|      0|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814);
  155|      0|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC70208);
  156|      0|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA);
  157|      0|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEB);
  158|      0|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7);
  159|      0|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2);
  160|       |
  161|      0|      A = (digest[0] += A);
  162|      0|      B = (digest[1] += B);
  163|      0|      C = (digest[2] += C);
  164|      0|      D = (digest[3] += D);
  165|      0|      E = (digest[4] += E);
  166|      0|      F = (digest[5] += F);
  167|      0|      G = (digest[6] += G);
  168|      0|      H = (digest[7] += H);
  169|      0|   }
  170|      0|}
_ZN5Botan7SHA_25610compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
  204|    309|void SHA_256::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  205|    309|   SHA_256::compress_digest(digest, input, blocks);
  206|    309|}
_ZN5Botan7SHA_2564initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  208|    259|void SHA_256::init(digest_type& digest) {
  209|    259|   digest.assign({0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19});
  210|    259|}
_ZN5Botan7SHA_2568add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  220|    259|void SHA_256::add_data(std::span<const uint8_t> input) {
  221|    259|   m_md.update(input);
  222|    259|}
_ZN5Botan7SHA_25612final_resultENSt3__14spanIhLm18446744073709551615EEE:
  224|    125|void SHA_256::final_result(std::span<uint8_t> output) {
  225|    125|   m_md.final(output);
  226|    125|}

_ZN5Botan7SHA_25624compress_digest_x86_bmi2ERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   24|    309|void SHA_256::compress_digest_x86_bmi2(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   25|    309|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4], F = digest[5], G = digest[6],
   26|    309|            H = digest[7];
   27|       |
   28|    309|   BufferSlicer in(input);
   29|       |
   30|  3.08k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (30:22): [True: 2.77k, False: 309]
  ------------------
   31|  2.77k|      const auto block = in.take(block_bytes);
   32|       |
   33|  2.77k|      uint32_t W00 = load_be<uint32_t>(block.data(), 0);
   34|  2.77k|      uint32_t W01 = load_be<uint32_t>(block.data(), 1);
   35|  2.77k|      uint32_t W02 = load_be<uint32_t>(block.data(), 2);
   36|  2.77k|      uint32_t W03 = load_be<uint32_t>(block.data(), 3);
   37|  2.77k|      uint32_t W04 = load_be<uint32_t>(block.data(), 4);
   38|  2.77k|      uint32_t W05 = load_be<uint32_t>(block.data(), 5);
   39|  2.77k|      uint32_t W06 = load_be<uint32_t>(block.data(), 6);
   40|  2.77k|      uint32_t W07 = load_be<uint32_t>(block.data(), 7);
   41|  2.77k|      uint32_t W08 = load_be<uint32_t>(block.data(), 8);
   42|  2.77k|      uint32_t W09 = load_be<uint32_t>(block.data(), 9);
   43|  2.77k|      uint32_t W10 = load_be<uint32_t>(block.data(), 10);
   44|  2.77k|      uint32_t W11 = load_be<uint32_t>(block.data(), 11);
   45|  2.77k|      uint32_t W12 = load_be<uint32_t>(block.data(), 12);
   46|  2.77k|      uint32_t W13 = load_be<uint32_t>(block.data(), 13);
   47|  2.77k|      uint32_t W14 = load_be<uint32_t>(block.data(), 14);
   48|  2.77k|      uint32_t W15 = load_be<uint32_t>(block.data(), 15);
   49|       |
   50|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98);
   51|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x71374491);
   52|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCF);
   53|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA5);
   54|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25B);
   55|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1);
   56|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4);
   57|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5);
   58|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98);
   59|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B01);
   60|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE);
   61|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3);
   62|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74);
   63|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE);
   64|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A7);
   65|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174);
   66|       |
   67|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C1);
   68|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786);
   69|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC6);
   70|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC);
   71|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F);
   72|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA);
   73|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DC);
   74|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA);
   75|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152);
   76|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D);
   77|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C8);
   78|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7);
   79|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF3);
   80|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147);
   81|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351);
   82|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x14292967);
   83|       |
   84|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A85);
   85|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B2138);
   86|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC);
   87|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D13);
   88|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A7354);
   89|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB);
   90|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E);
   91|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C85);
   92|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A1);
   93|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664B);
   94|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70);
   95|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A3);
   96|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819);
   97|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD6990624);
   98|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E3585);
   99|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA070);
  100|       |
  101|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116);
  102|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C08);
  103|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774C);
  104|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5);
  105|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3);
  106|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4A);
  107|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F);
  108|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3);
  109|  2.77k|      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE);
  110|  2.77k|      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F);
  111|  2.77k|      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814);
  112|  2.77k|      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC70208);
  113|  2.77k|      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA);
  114|  2.77k|      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEB);
  115|  2.77k|      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7);
  116|  2.77k|      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2);
  117|       |
  118|  2.77k|      A = (digest[0] += A);
  119|  2.77k|      B = (digest[1] += B);
  120|  2.77k|      C = (digest[2] += C);
  121|  2.77k|      D = (digest[3] += D);
  122|  2.77k|      E = (digest[4] += E);
  123|  2.77k|      F = (digest[5] += F);
  124|  2.77k|      G = (digest[6] += G);
  125|  2.77k|      H = (digest[7] += H);
  126|  2.77k|   }
  127|    309|}

_ZN5Botan3TLS12Client_HelloD2Ev:
  172|    580|Client_Hello::~Client_Hello() = default;
_ZN5Botan3TLS12Client_HelloC2ENSt3__110unique_ptrINS0_21Client_Hello_InternalENS2_14default_deleteIS4_EEEE:
  179|    580|Client_Hello::Client_Hello(std::unique_ptr<Client_Hello_Internal> data) : m_data(std::move(data)) {
  180|    580|   BOTAN_ASSERT_NONNULL(m_data);
  ------------------
  |  |   87|    580|   do {                                                                                   \
  |  |   88|    580|      if((ptr) == nullptr)                                                                \
  |  |  ------------------
  |  |  |  Branch (88:10): [True: 0, False: 580]
  |  |  ------------------
  |  |   89|    580|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |   90|    580|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  181|    580|}
_ZNK5Botan3TLS12Client_Hello13offered_suiteEt:
  261|    580|bool Client_Hello::offered_suite(uint16_t ciphersuite) const {
  262|    580|   return std::find(m_data->ciphersuites().cbegin(), m_data->ciphersuites().cend(), ciphersuite) !=
  263|    580|          m_data->ciphersuites().cend();
  264|    580|}
_ZN5Botan3TLS15Client_Hello_12C2ENSt3__110unique_ptrINS0_21Client_Hello_InternalENS2_14default_deleteIS4_EEEE:
  438|    580|Client_Hello_12::Client_Hello_12(std::unique_ptr<Client_Hello_Internal> data) : Client_Hello(std::move(data)) {
  439|    580|   if(offered_suite(static_cast<uint16_t>(TLS_EMPTY_RENEGOTIATION_INFO_SCSV))) {
  ------------------
  |  Branch (439:7): [True: 227, False: 353]
  ------------------
  440|    227|      if(Renegotiation_Extension* reneg = m_data->extensions().get<Renegotiation_Extension>()) {
  ------------------
  |  Branch (440:35): [True: 7, False: 220]
  ------------------
  441|      7|         if(!reneg->renegotiation_info().empty()) {
  ------------------
  |  Branch (441:13): [True: 3, False: 4]
  ------------------
  442|      3|            throw TLS_Exception(Alert::HandshakeFailure, "Client sent renegotiation SCSV and non-empty extension");
  443|      3|         }
  444|    220|      } else {
  445|       |         // add fake extension
  446|    220|         m_data->extensions().add(new Renegotiation_Extension());
  447|    220|      }
  448|    227|   }
  449|    580|}
_ZN5Botan3TLS15Client_Hello_12C2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  454|  2.72k|      Client_Hello_12(std::make_unique<Client_Hello_Internal>(buf)) {}
_ZNK5Botan3TLS21Client_Hello_Internal12ciphersuitesEv:
  144|  1.74k|      const std::vector<uint16_t>& ciphersuites() const { return m_suites; }
_ZN5Botan3TLS21Client_Hello_Internal10extensionsEv:
  154|    447|      Extensions& extensions() { return m_extensions; }
_ZN5Botan3TLS21Client_Hello_InternalC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
   71|  2.72k|      Client_Hello_Internal(const std::vector<uint8_t>& buf) {
   72|  2.72k|         if(buf.size() < 41) {
  ------------------
  |  Branch (72:13): [True: 16, False: 2.70k]
  ------------------
   73|     16|            throw Decoding_Error("Client_Hello: Packet corrupted");
   74|     16|         }
   75|       |
   76|  2.70k|         TLS_Data_Reader reader("ClientHello", buf);
   77|       |
   78|  2.70k|         const uint8_t major_version = reader.get_byte();
   79|  2.70k|         const uint8_t minor_version = reader.get_byte();
   80|       |
   81|  2.70k|         m_legacy_version = Protocol_Version(major_version, minor_version);
   82|  2.70k|         m_random = reader.get_fixed<uint8_t>(32);
   83|  2.70k|         m_session_id = Session_ID(reader.get_range<uint8_t>(1, 0, 32));
   84|       |
   85|  2.70k|         if(m_legacy_version.is_datagram_protocol()) {
  ------------------
  |  Branch (85:13): [True: 134, False: 2.57k]
  ------------------
   86|    134|            auto sha256 = HashFunction::create_or_throw("SHA-256");
   87|    134|            sha256->update(reader.get_data_read_so_far());
   88|       |
   89|    134|            m_hello_cookie = reader.get_range<uint8_t>(1, 0, 255);
   90|       |
   91|    134|            sha256->update(reader.get_remaining());
   92|    134|            m_cookie_input_bits = sha256->final_stdvec();
   93|    134|         }
   94|       |
   95|  2.70k|         m_suites = reader.get_range_vector<uint16_t>(2, 1, 32767);
   96|  2.70k|         m_comp_methods = reader.get_range_vector<uint8_t>(1, 1, 255);
   97|       |
   98|  2.70k|         m_extensions.deserialize(reader, Connection_Side::Client, Handshake_Type::ClientHello);
   99|  2.70k|      }

_ZN5Botan3TLS9Key_ShareC2ERNS0_15TLS_Data_ReaderEtNS0_14Handshake_TypeE:
  411|    143|Key_Share::Key_Share(TLS_Data_Reader& reader, uint16_t extension_size, Handshake_Type message_type) {
  412|    143|   if(message_type == Handshake_Type::ClientHello) {
  ------------------
  |  Branch (412:7): [True: 143, False: 0]
  ------------------
  413|    143|      m_impl = std::make_unique<Key_Share_Impl>(Key_Share_ClientHello(reader, extension_size));
  414|    143|   } else if(message_type == Handshake_Type::HelloRetryRequest)  // Connection_Side::Server
  ------------------
  |  Branch (414:14): [True: 0, False: 0]
  ------------------
  415|      0|   {
  416|      0|      m_impl = std::make_unique<Key_Share_Impl>(Key_Share_HelloRetryRequest(reader, extension_size));
  417|      0|   } else if(message_type == Handshake_Type::ServerHello)  // Connection_Side::Server
  ------------------
  |  Branch (417:14): [True: 0, False: 0]
  ------------------
  418|      0|   {
  419|      0|      m_impl = std::make_unique<Key_Share_Impl>(Key_Share_ServerHello(reader, extension_size));
  420|      0|   } else {
  421|      0|      throw Invalid_Argument(std::string("cannot create a Key_Share extension for message of type: ") +
  422|      0|                             handshake_type_to_string(message_type));
  423|      0|   }
  424|    143|}
_ZN5Botan3TLS9Key_ShareD2Ev:
  443|     18|Key_Share::~Key_Share() = default;
tls_extensions_key_share.cpp:_ZN5Botan3TLS12_GLOBAL__N_121Key_Share_ClientHelloC2ERNS0_15TLS_Data_ReaderEt:
  185|    143|      Key_Share_ClientHello(TLS_Data_Reader& reader, uint16_t /* extension_size */) {
  186|       |         // This construction is a crutch to make working with the incoming
  187|       |         // TLS_Data_Reader bearable. Currently, this reader spans the entire
  188|       |         // Client_Hello message. Hence, if offset or length fields are skewed
  189|       |         // or maliciously fabricated, it is possible to read further than the
  190|       |         // bounds of the current extension.
  191|       |         // Note that this aplies to many locations in the code base.
  192|       |         //
  193|       |         // TODO: Overhaul the TLS_Data_Reader to allow for cheap "sub-readers"
  194|       |         //       that enforce read bounds of sub-structures while parsing.
  195|    143|         const auto client_key_share_length = reader.get_uint16_t();
  196|    143|         const auto read_bytes_so_far_begin = reader.read_so_far();
  197|    143|         auto remaining = [&] {
  198|    143|            const auto read_so_far = reader.read_so_far() - read_bytes_so_far_begin;
  199|    143|            BOTAN_STATE_CHECK(read_so_far <= client_key_share_length);
  200|    143|            return client_key_share_length - read_so_far;
  201|    143|         };
  202|       |
  203|    914|         while(reader.has_remaining() && remaining() > 0) {
  ------------------
  |  Branch (203:16): [True: 796, False: 118]
  |  Branch (203:42): [True: 777, False: 19]
  ------------------
  204|    777|            if(remaining() < 4) {
  ------------------
  |  Branch (204:16): [True: 2, False: 775]
  ------------------
  205|      2|               throw TLS_Exception(Alert::DecodeError, "Not enough data to read another KeyShareEntry");
  206|      2|            }
  207|       |
  208|    775|            Key_Share_Entry new_entry(reader);
  209|       |
  210|       |            // RFC 8446 4.2.8
  211|       |            //    Clients MUST NOT offer multiple KeyShareEntry values for the same
  212|       |            //    group. [...]
  213|       |            //    Servers MAY check for violations of these rules and abort the
  214|       |            //    handshake with an "illegal_parameter" alert if one is violated.
  215|    775|            if(std::find_if(m_client_shares.begin(), m_client_shares.end(), [&](const auto& entry) {
  ------------------
  |  Branch (215:16): [True: 4, False: 771]
  ------------------
  216|    775|                  return entry.group() == new_entry.group();
  217|    775|               }) != m_client_shares.end()) {
  218|      4|               throw TLS_Exception(Alert::IllegalParameter, "Received multiple key share entries for the same group");
  219|      4|            }
  220|       |
  221|    771|            m_client_shares.emplace_back(std::move(new_entry));
  222|    771|         }
  223|       |
  224|    137|         if((reader.read_so_far() - read_bytes_so_far_begin) != client_key_share_length) {
  ------------------
  |  Branch (224:13): [True: 64, False: 73]
  ------------------
  225|     64|            throw Decoding_Error("Read bytes are not equal client KeyShare length");
  226|     64|         }
  227|    137|      }
tls_extensions_key_share.cpp:_ZZN5Botan3TLS12_GLOBAL__N_121Key_Share_ClientHelloC1ERNS0_15TLS_Data_ReaderEtENKUlvE_clEv:
  197|  1.57k|         auto remaining = [&] {
  198|  1.57k|            const auto read_so_far = reader.read_so_far() - read_bytes_so_far_begin;
  199|  1.57k|            BOTAN_STATE_CHECK(read_so_far <= client_key_share_length);
  ------------------
  |  |   42|  1.57k|   do {                                                         \
  |  |   43|  1.57k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 16, False: 1.55k]
  |  |  ------------------
  |  |   44|  1.57k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|  1.57k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  200|  1.57k|            return client_key_share_length - read_so_far;
  201|  1.57k|         };
tls_extensions_key_share.cpp:_ZN5Botan3TLS12_GLOBAL__N_115Key_Share_EntryC2ERNS0_15TLS_Data_ReaderE:
   39|    775|      Key_Share_Entry(TLS_Data_Reader& reader) {
   40|       |         // TODO check that the group actually exists before casting...
   41|    775|         m_group = static_cast<Named_Group>(reader.get_uint16_t());
   42|    775|         m_key_exchange = reader.get_tls_length_value(2);
   43|    775|      }
tls_extensions_key_share.cpp:_ZZN5Botan3TLS12_GLOBAL__N_121Key_Share_ClientHelloC1ERNS0_15TLS_Data_ReaderEtENKUlRKT_E_clINS1_15Key_Share_EntryEEEDaS7_:
  215|  17.2k|            if(std::find_if(m_client_shares.begin(), m_client_shares.end(), [&](const auto& entry) {
  216|  17.2k|                  return entry.group() == new_entry.group();
  217|  17.2k|               }) != m_client_shares.end()) {
tls_extensions_key_share.cpp:_ZNK5Botan3TLS12_GLOBAL__N_115Key_Share_Entry5groupEv:
   96|  34.5k|      Named_Group group() const { return m_group; }
tls_extensions_key_share.cpp:_ZN5Botan3TLS12_GLOBAL__N_121Key_Share_ClientHelloD2Ev:
  252|     54|      ~Key_Share_ClientHello() = default;
tls_extensions_key_share.cpp:_ZN5Botan3TLS12_GLOBAL__N_121Key_Share_ClientHelloC2EOS2_:
  257|     36|      Key_Share_ClientHello(Key_Share_ClientHello&&) = default;
tls_extensions_key_share.cpp:_ZN5Botan3TLS9Key_Share14Key_Share_ImplC2ENSt3__17variantIJNS0_12_GLOBAL__N_121Key_Share_ClientHelloENS5_21Key_Share_ServerHelloENS5_27Key_Share_HelloRetryRequestEEEE:
  405|     18|      Key_Share_Impl(Key_Share_Type ks) : key_share(std::move(ks)) {}

_ZN5Botan3TLS3PSKC2ERNS0_15TLS_Data_ReaderEtNS0_14Handshake_TypeE:
  141|    210|PSK::PSK(TLS_Data_Reader& reader, uint16_t extension_size, Handshake_Type message_type) {
  142|    210|   if(message_type == Handshake_Type::ServerHello) {
  ------------------
  |  Branch (142:7): [True: 0, False: 210]
  ------------------
  143|      0|      if(extension_size != 2) {
  ------------------
  |  Branch (143:10): [True: 0, False: 0]
  ------------------
  144|      0|         throw TLS_Exception(Alert::DecodeError, "Server provided a malformed PSK extension");
  145|      0|      }
  146|       |
  147|      0|      const uint16_t selected_id = reader.get_uint16_t();
  148|      0|      m_impl = std::make_unique<PSK_Internal>(Server_PSK(selected_id));
  149|    210|   } else if(message_type == Handshake_Type::ClientHello) {
  ------------------
  |  Branch (149:14): [True: 210, False: 0]
  ------------------
  150|    210|      const auto identities_length = reader.get_uint16_t();
  151|    210|      const auto identities_offset = reader.read_so_far();
  152|       |
  153|    210|      std::vector<PskIdentity> psk_identities;
  154|  4.67k|      while(reader.has_remaining() && (reader.read_so_far() - identities_offset) < identities_length) {
  ------------------
  |  Branch (154:13): [True: 4.59k, False: 76]
  |  Branch (154:39): [True: 4.46k, False: 134]
  ------------------
  155|  4.46k|         auto identity = reader.get_tls_length_value(2);
  156|  4.46k|         const auto obfuscated_ticket_age = reader.get_uint32_t();
  157|  4.46k|         psk_identities.emplace_back(std::move(identity), obfuscated_ticket_age);
  158|  4.46k|      }
  159|       |
  160|    210|      if(psk_identities.empty()) {
  ------------------
  |  Branch (160:10): [True: 2, False: 208]
  ------------------
  161|      2|         throw TLS_Exception(Alert::DecodeError, "Empty PSK list");
  162|      2|      }
  163|       |
  164|    208|      if(reader.read_so_far() - identities_offset != identities_length) {
  ------------------
  |  Branch (164:10): [True: 51, False: 157]
  ------------------
  165|     51|         throw TLS_Exception(Alert::DecodeError, "Inconsistent PSK identity list");
  166|     51|      }
  167|       |
  168|    157|      const auto binders_length = reader.get_uint16_t();
  169|    157|      const auto binders_offset = reader.read_so_far();
  170|       |
  171|    157|      if(binders_length == 0) {
  ------------------
  |  Branch (171:10): [True: 1, False: 156]
  ------------------
  172|      1|         throw TLS_Exception(Alert::DecodeError, "Empty PSK binders list");
  173|      1|      }
  174|       |
  175|    156|      std::vector<Client_PSK> psks;
  176|  2.15k|      for(auto& psk_identity : psk_identities) {
  ------------------
  |  Branch (176:30): [True: 2.15k, False: 125]
  ------------------
  177|  2.15k|         if(!reader.has_remaining() || reader.read_so_far() - binders_offset >= binders_length) {
  ------------------
  |  Branch (177:13): [True: 21, False: 2.13k]
  |  Branch (177:40): [True: 10, False: 2.12k]
  ------------------
  178|     31|            throw TLS_Exception(Alert::IllegalParameter, "Not enough PSK binders");
  179|     31|         }
  180|       |
  181|  2.12k|         psks.emplace_back(std::move(psk_identity), reader.get_tls_length_value(1));
  182|  2.12k|      }
  183|       |
  184|    125|      if(reader.read_so_far() - binders_offset != binders_length) {
  ------------------
  |  Branch (184:10): [True: 59, False: 66]
  ------------------
  185|     59|         throw TLS_Exception(Alert::IllegalParameter, "Too many PSK binders");
  186|     59|      }
  187|       |
  188|     66|      m_impl = std::make_unique<PSK_Internal>(std::move(psks));
  189|     66|   } else {
  190|      0|      throw TLS_Exception(Alert::DecodeError, "Found a PSK extension in an unexpected handshake message");
  191|      0|   }
  192|    210|}
_ZN5Botan3TLS3PSKD2Ev:
  214|     13|PSK::~PSK() = default;
tls_extensions_psk.cpp:_ZN5Botan3TLS12_GLOBAL__N_110Client_PSKC2ENS0_11PskIdentityENSt3__16vectorIhNS4_9allocatorIhEEEE:
   55|  2.12k|            m_identity(std::move(id)), m_binder(std::move(bndr)), m_is_resumption(false) {}
tls_extensions_psk.cpp:_ZN5Botan3TLS3PSK12PSK_InternalC2ENSt3__16vectorINS0_12_GLOBAL__N_110Client_PSKENS3_9allocatorIS6_EEEE:
  135|     13|      PSK_Internal(std::vector<Client_PSK> clt_psks) : psk(std::move(clt_psks)) {}

_ZN5Botan3TLS10Extensions3addENSt3__110unique_ptrINS0_9ExtensionENS2_14default_deleteIS4_EEEE:
  110|  4.15k|void Extensions::add(std::unique_ptr<Extension> extn) {
  111|  4.15k|   if(has(extn->type())) {
  ------------------
  |  Branch (111:7): [True: 0, False: 4.15k]
  ------------------
  112|      0|      throw Invalid_Argument("cannot add the same extension twice: " +
  113|      0|                             std::to_string(static_cast<uint16_t>(extn->type())));
  114|      0|   }
  115|       |
  116|  4.15k|   m_extensions.emplace_back(extn.release());
  117|  4.15k|}
_ZN5Botan3TLS10Extensions11deserializeERNS0_15TLS_Data_ReaderENS0_15Connection_SideENS0_14Handshake_TypeE:
  119|  2.54k|void Extensions::deserialize(TLS_Data_Reader& reader, const Connection_Side from, const Handshake_Type message_type) {
  120|  2.54k|   if(reader.has_remaining()) {
  ------------------
  |  Branch (120:7): [True: 2.51k, False: 33]
  ------------------
  121|  2.51k|      const uint16_t all_extn_size = reader.get_uint16_t();
  122|       |
  123|  2.51k|      if(reader.remaining_bytes() != all_extn_size) {
  ------------------
  |  Branch (123:10): [True: 48, False: 2.46k]
  ------------------
  124|     48|         throw Decoding_Error("Bad extension size");
  125|     48|      }
  126|       |
  127|  8.24k|      while(reader.has_remaining()) {
  ------------------
  |  Branch (127:13): [True: 5.79k, False: 2.45k]
  ------------------
  128|  5.79k|         const uint16_t extension_code = reader.get_uint16_t();
  129|  5.79k|         const uint16_t extension_size = reader.get_uint16_t();
  130|       |
  131|  5.79k|         const auto type = static_cast<Extension_Code>(extension_code);
  132|       |
  133|  5.79k|         if(this->has(type)) {
  ------------------
  |  Branch (133:13): [True: 7, False: 5.78k]
  ------------------
  134|      7|            throw TLS_Exception(TLS::Alert::DecodeError, "Peer sent duplicated extensions");
  135|      7|         }
  136|       |
  137|       |         // TODO offer a function on reader that returns a byte range as a reference
  138|       |         // to avoid this copy of the extension data
  139|  5.78k|         const std::vector<uint8_t> extn_data = reader.get_fixed<uint8_t>(extension_size);
  140|  5.78k|         TLS_Data_Reader extn_reader("Extension", extn_data);
  141|  5.78k|         this->add(make_extension(extn_reader, type, from, message_type));
  142|  5.78k|         extn_reader.assert_done();
  143|  5.78k|      }
  144|  2.46k|   }
  145|  2.54k|}
_ZN5Botan3TLS17Unknown_ExtensionC2ENS0_14Extension_CodeERNS0_15TLS_Data_ReaderEt:
  227|  3.09k|      m_type(type), m_value(reader.get_fixed<uint8_t>(extension_size)) {}
_ZN5Botan3TLS21Server_Name_IndicatorC2ERNS0_15TLS_Data_ReaderEt:
  233|    186|Server_Name_Indicator::Server_Name_Indicator(TLS_Data_Reader& reader, uint16_t extension_size) {
  234|       |   /*
  235|       |   * This is used by the server to confirm that it knew the name
  236|       |   */
  237|    186|   if(extension_size == 0) {
  ------------------
  |  Branch (237:7): [True: 94, False: 92]
  ------------------
  238|     94|      return;
  239|     94|   }
  240|       |
  241|     92|   uint16_t name_bytes = reader.get_uint16_t();
  242|       |
  243|     92|   if(name_bytes + 2 != extension_size) {
  ------------------
  |  Branch (243:7): [True: 26, False: 66]
  ------------------
  244|     26|      throw Decoding_Error("Bad encoding of SNI extension");
  245|     26|   }
  246|       |
  247|    433|   while(name_bytes) {
  ------------------
  |  Branch (247:10): [True: 367, False: 66]
  ------------------
  248|    367|      uint8_t name_type = reader.get_byte();
  249|    367|      name_bytes--;
  250|       |
  251|    367|      if(name_type == 0)  // DNS
  ------------------
  |  Branch (251:10): [True: 340, False: 27]
  ------------------
  252|    340|      {
  253|    340|         m_sni_host_name = reader.get_string(2, 1, 65535);
  254|    340|         name_bytes -= static_cast<uint16_t>(2 + m_sni_host_name.size());
  255|    340|      } else  // some other unknown name type
  256|     27|      {
  257|     27|         reader.discard_next(name_bytes);
  258|     27|         name_bytes = 0;
  259|     27|      }
  260|    367|   }
  261|     66|}
_ZN5Botan3TLS23Renegotiation_ExtensionC2ERNS0_15TLS_Data_ReaderEt:
  289|     22|      m_reneg_data(reader.get_range<uint8_t>(1, 0, 255)) {
  290|     22|   if(m_reneg_data.size() + 1 != extension_size) {
  ------------------
  |  Branch (290:7): [True: 13, False: 9]
  ------------------
  291|     13|      throw Decoding_Error("Bad encoding for secure renegotiation extn");
  292|     13|   }
  293|     22|}
_ZN5Botan3TLS39Application_Layer_Protocol_NotificationC2ERNS0_15TLS_Data_ReaderEtNS0_15Connection_SideE:
  303|    153|                                                                                 Connection_Side from) {
  304|    153|   if(extension_size == 0) {
  ------------------
  |  Branch (304:7): [True: 44, False: 109]
  ------------------
  305|     44|      return;  // empty extension
  306|     44|   }
  307|       |
  308|    109|   const uint16_t name_bytes = reader.get_uint16_t();
  309|       |
  310|    109|   size_t bytes_remaining = extension_size - 2;
  311|       |
  312|    109|   if(name_bytes != bytes_remaining) {
  ------------------
  |  Branch (312:7): [True: 34, False: 75]
  ------------------
  313|     34|      throw Decoding_Error("Bad encoding of ALPN extension, bad length field");
  314|     34|   }
  315|       |
  316|  3.24k|   while(bytes_remaining) {
  ------------------
  |  Branch (316:10): [True: 3.18k, False: 60]
  ------------------
  317|  3.18k|      const std::string p = reader.get_string(1, 0, 255);
  318|       |
  319|  3.18k|      if(bytes_remaining < p.size() + 1) {
  ------------------
  |  Branch (319:10): [True: 0, False: 3.18k]
  ------------------
  320|      0|         throw Decoding_Error("Bad encoding of ALPN, length field too long");
  321|      0|      }
  322|       |
  323|  3.18k|      if(p.empty()) {
  ------------------
  |  Branch (323:10): [True: 15, False: 3.17k]
  ------------------
  324|     15|         throw Decoding_Error("Empty ALPN protocol not allowed");
  325|     15|      }
  326|       |
  327|  3.17k|      bytes_remaining -= (p.size() + 1);
  328|       |
  329|  3.17k|      m_protocols.push_back(p);
  330|  3.17k|   }
  331|       |
  332|       |   // RFC 7301 3.1
  333|       |   //    The "extension_data" field of the [...] extension is structured the
  334|       |   //    same as described above for the client "extension_data", except that
  335|       |   //    the "ProtocolNameList" MUST contain exactly one "ProtocolName".
  336|     60|   if(from == Connection_Side::Server && m_protocols.size() != 1) {
  ------------------
  |  Branch (336:7): [True: 0, False: 60]
  |  Branch (336:42): [True: 0, False: 0]
  ------------------
  337|      0|      throw TLS_Exception(
  338|      0|         Alert::DecodeError,
  339|      0|         "Server sent " + std::to_string(m_protocols.size()) + " protocols in ALPN extension response");
  340|      0|   }
  341|     60|}
_ZN5Botan3TLS21Certificate_Type_BaseC2ERNS0_15TLS_Data_ReaderEtNS0_15Connection_SideE:
  423|     76|      m_from(from) {
  424|     76|   if(extension_size == 0) {
  ------------------
  |  Branch (424:7): [True: 3, False: 73]
  ------------------
  425|      3|      throw Decoding_Error("Certificate type extension cannot be empty");
  426|      3|   }
  427|       |
  428|     73|   if(from == Connection_Side::Client) {
  ------------------
  |  Branch (428:7): [True: 73, False: 0]
  ------------------
  429|     73|      const auto type_bytes = reader.get_tls_length_value(1);
  430|     73|      if(static_cast<size_t>(extension_size) != type_bytes.size() + 1) {
  ------------------
  |  Branch (430:10): [True: 20, False: 53]
  ------------------
  431|     20|         throw Decoding_Error("certificate type extension had inconsistent length");
  432|     20|      }
  433|     53|      std::transform(
  434|     53|         type_bytes.begin(), type_bytes.end(), std::back_inserter(m_certificate_types), [](const auto type_byte) {
  435|     53|            return static_cast<Certificate_Type>(type_byte);
  436|     53|         });
  437|     53|   } else {
  438|       |      // RFC 7250 4.2
  439|       |      //    Note that only a single value is permitted in the
  440|       |      //    server_certificate_type extension when carried in the server hello.
  441|      0|      if(extension_size != 1) {
  ------------------
  |  Branch (441:10): [True: 0, False: 0]
  ------------------
  442|      0|         throw Decoding_Error("Server's certificate type extension must be of length 1");
  443|      0|      }
  444|      0|      const auto type_byte = reader.get_byte();
  445|      0|      m_certificate_types.push_back(static_cast<Certificate_Type>(type_byte));
  446|      0|   }
  447|     73|}
_ZN5Botan3TLS16Supported_GroupsC2ERNS0_15TLS_Data_ReaderEt:
  530|     94|Supported_Groups::Supported_Groups(TLS_Data_Reader& reader, uint16_t extension_size) {
  531|     94|   const uint16_t len = reader.get_uint16_t();
  532|       |
  533|     94|   if(len + 2 != extension_size) {
  ------------------
  |  Branch (533:7): [True: 20, False: 74]
  ------------------
  534|     20|      throw Decoding_Error("Inconsistent length field in supported groups list");
  535|     20|   }
  536|       |
  537|     74|   if(len % 2 == 1) {
  ------------------
  |  Branch (537:7): [True: 1, False: 73]
  ------------------
  538|      1|      throw Decoding_Error("Supported groups list of strange size");
  539|      1|   }
  540|       |
  541|     73|   const size_t elems = len / 2;
  542|       |
  543|  4.05k|   for(size_t i = 0; i != elems; ++i) {
  ------------------
  |  Branch (543:22): [True: 3.98k, False: 73]
  ------------------
  544|  3.98k|      const auto group = static_cast<Group_Params>(reader.get_uint16_t());
  545|       |      // Note: RFC 8446 does not explicitly enforce that groups must be unique.
  546|  3.98k|      if(!value_exists(m_groups, group)) {
  ------------------
  |  Branch (546:10): [True: 2.31k, False: 1.66k]
  ------------------
  547|  2.31k|         m_groups.push_back(group);
  548|  2.31k|      }
  549|  3.98k|   }
  550|     73|}
_ZN5Botan3TLS23Supported_Point_FormatsC2ERNS0_15TLS_Data_ReaderEt:
  561|     62|Supported_Point_Formats::Supported_Point_Formats(TLS_Data_Reader& reader, uint16_t extension_size) {
  562|     62|   uint8_t len = reader.get_byte();
  563|       |
  564|     62|   if(len + 1 != extension_size) {
  ------------------
  |  Branch (564:7): [True: 14, False: 48]
  ------------------
  565|     14|      throw Decoding_Error("Inconsistent length field in supported point formats list");
  566|     14|   }
  567|       |
  568|     48|   bool includes_uncompressed = false;
  569|    440|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (569:22): [True: 421, False: 19]
  ------------------
  570|    421|      uint8_t format = reader.get_byte();
  571|       |
  572|    421|      if(static_cast<ECPointFormat>(format) == UNCOMPRESSED) {
  ------------------
  |  Branch (572:10): [True: 8, False: 413]
  ------------------
  573|      8|         m_prefers_compressed = false;
  574|      8|         reader.discard_next(len - i - 1);
  575|      8|         return;
  576|    413|      } else if(static_cast<ECPointFormat>(format) == ANSIX962_COMPRESSED_PRIME) {
  ------------------
  |  Branch (576:17): [True: 21, False: 392]
  ------------------
  577|     21|         m_prefers_compressed = true;
  578|     21|         std::vector<uint8_t> remaining_formats = reader.get_fixed<uint8_t>(len - i - 1);
  579|     21|         includes_uncompressed =
  580|     21|            std::any_of(std::begin(remaining_formats), std::end(remaining_formats), [](uint8_t remaining_format) {
  581|     21|               return static_cast<ECPointFormat>(remaining_format) == UNCOMPRESSED;
  582|     21|            });
  583|     21|         break;
  584|     21|      }
  585|       |
  586|       |      // ignore ANSIX962_COMPRESSED_CHAR2, we don't support these curves
  587|    421|   }
  588|       |
  589|       |   // RFC 4492 5.1.:
  590|       |   //   If the Supported Point Formats Extension is indeed sent, it MUST contain the value 0 (uncompressed)
  591|       |   //   as one of the items in the list of point formats.
  592|       |   // Note:
  593|       |   //   RFC 8422 5.1.2. explicitly requires this check,
  594|       |   //   but only if the Supported Groups extension was sent.
  595|     40|   if(!includes_uncompressed) {
  ------------------
  |  Branch (595:7): [True: 37, False: 3]
  ------------------
  596|     37|      throw TLS_Exception(Alert::IllegalParameter,
  597|     37|                          "Supported Point Formats Extension must contain the uncompressed point format");
  598|     37|   }
  599|     40|}
_ZN5Botan3TLS20Signature_AlgorithmsC2ERNS0_15TLS_Data_ReaderEt:
  645|     18|      m_schemes(parse_signature_algorithms(reader, extension_size)) {}
_ZN5Botan3TLS25Signature_Algorithms_CertC2ERNS0_15TLS_Data_ReaderEt:
  652|     48|      m_schemes(parse_signature_algorithms(reader, extension_size)) {}
_ZN5Botan3TLS24Session_Ticket_ExtensionC2ERNS0_15TLS_Data_ReaderEt:
  655|     43|      m_ticket(Session_Ticket(reader.get_elem<uint8_t, std::vector<uint8_t>>(extension_size))) {}
_ZN5Botan3TLS24SRTP_Protection_ProfilesC2ERNS0_15TLS_Data_ReaderEt:
  658|     26|      m_pp(reader.get_range<uint16_t>(2, 0, 65535)) {
  659|     26|   const std::vector<uint8_t> mki = reader.get_range<uint8_t>(1, 0, 255);
  660|       |
  661|     26|   if(m_pp.size() * 2 + mki.size() + 3 != extension_size) {
  ------------------
  |  Branch (661:7): [True: 11, False: 15]
  ------------------
  662|     11|      throw Decoding_Error("Bad encoding for SRTP protection extension");
  663|     11|   }
  664|       |
  665|     15|   if(!mki.empty()) {
  ------------------
  |  Branch (665:7): [True: 1, False: 14]
  ------------------
  666|      1|      throw Decoding_Error("Unhandled non-empty MKI for SRTP protection extension");
  667|      1|   }
  668|     15|}
_ZN5Botan3TLS22Extended_Master_SecretC2ERNS0_15TLS_Data_ReaderEt:
  687|     38|Extended_Master_Secret::Extended_Master_Secret(TLS_Data_Reader& /*unused*/, uint16_t extension_size) {
  688|     38|   if(extension_size != 0) {
  ------------------
  |  Branch (688:7): [True: 3, False: 35]
  ------------------
  689|      3|      throw Decoding_Error("Invalid extended_master_secret extension");
  690|      3|   }
  691|     38|}
_ZN5Botan3TLS16Encrypt_then_MACC2ERNS0_15TLS_Data_ReaderEt:
  697|     45|Encrypt_then_MAC::Encrypt_then_MAC(TLS_Data_Reader& /*unused*/, uint16_t extension_size) {
  698|     45|   if(extension_size != 0) {
  ------------------
  |  Branch (698:7): [True: 11, False: 34]
  ------------------
  699|     11|      throw Decoding_Error("Invalid encrypt_then_mac extension");
  700|     11|   }
  701|     45|}
_ZN5Botan3TLS18Supported_VersionsC2ERNS0_15TLS_Data_ReaderEtNS0_15Connection_SideE:
  750|     47|Supported_Versions::Supported_Versions(TLS_Data_Reader& reader, uint16_t extension_size, Connection_Side from) {
  751|     47|   if(from == Connection_Side::Server) {
  ------------------
  |  Branch (751:7): [True: 0, False: 47]
  ------------------
  752|      0|      if(extension_size != 2) {
  ------------------
  |  Branch (752:10): [True: 0, False: 0]
  ------------------
  753|      0|         throw Decoding_Error("Server sent invalid supported_versions extension");
  754|      0|      }
  755|      0|      m_versions.push_back(Protocol_Version(reader.get_uint16_t()));
  756|     47|   } else {
  757|     47|      auto versions = reader.get_range<uint16_t>(1, 1, 127);
  758|       |
  759|    709|      for(auto v : versions) {
  ------------------
  |  Branch (759:18): [True: 709, False: 47]
  ------------------
  760|    709|         m_versions.push_back(Protocol_Version(v));
  761|    709|      }
  762|       |
  763|     47|      if(extension_size != 1 + 2 * versions.size()) {
  ------------------
  |  Branch (763:10): [True: 12, False: 35]
  ------------------
  764|     12|         throw Decoding_Error("Client sent invalid supported_versions extension");
  765|     12|      }
  766|     47|   }
  767|     47|}
_ZN5Botan3TLS17Record_Size_LimitC2ERNS0_15TLS_Data_ReaderEtNS0_15Connection_SideE:
  784|     49|Record_Size_Limit::Record_Size_Limit(TLS_Data_Reader& reader, uint16_t extension_size, Connection_Side from) {
  785|     49|   if(extension_size != 2) {
  ------------------
  |  Branch (785:7): [True: 13, False: 36]
  ------------------
  786|     13|      throw TLS_Exception(Alert::DecodeError, "invalid record_size_limit extension");
  787|     13|   }
  788|       |
  789|     36|   m_limit = reader.get_uint16_t();
  790|       |
  791|       |   // RFC 8449 4.
  792|       |   //    This value is the length of the plaintext of a protected record.
  793|       |   //    The value includes the content type and padding added in TLS 1.3 (that
  794|       |   //    is, the complete length of TLSInnerPlaintext).
  795|       |   //
  796|       |   //    A server MUST NOT enforce this restriction; a client might advertise
  797|       |   //    a higher limit that is enabled by an extension or version the server
  798|       |   //    does not understand. A client MAY abort the handshake with an
  799|       |   //    "illegal_parameter" alert.
  800|       |   //
  801|       |   // Note: We are currently supporting this extension in TLS 1.3 only, hence
  802|       |   //       we check for the TLS 1.3 limit. The TLS 1.2 limit would not include
  803|       |   //       the "content type byte" and hence be one byte less!
  804|     36|   if(m_limit > MAX_PLAINTEXT_SIZE + 1 /* encrypted content type byte */ && from == Connection_Side::Server) {
  ------------------
  |  Branch (804:7): [True: 10, False: 26]
  |  Branch (804:77): [True: 0, False: 10]
  ------------------
  805|      0|      throw TLS_Exception(Alert::IllegalParameter,
  806|      0|                          "Server requested a record size limit larger than the protocol's maximum");
  807|      0|   }
  808|       |
  809|       |   // RFC 8449 4.
  810|       |   //    Endpoints MUST NOT send a "record_size_limit" extension with a value
  811|       |   //    smaller than 64.  An endpoint MUST treat receipt of a smaller value
  812|       |   //    as a fatal error and generate an "illegal_parameter" alert.
  813|     36|   if(m_limit < 64) {
  ------------------
  |  Branch (813:7): [True: 8, False: 28]
  ------------------
  814|      8|      throw TLS_Exception(Alert::IllegalParameter, "Received a record size limit smaller than 64 bytes");
  815|      8|   }
  816|     36|}
_ZN5Botan3TLS6CookieC2ERNS0_15TLS_Data_ReaderEt:
  830|     93|Cookie::Cookie(TLS_Data_Reader& reader, uint16_t extension_size) {
  831|     93|   if(extension_size == 0) {
  ------------------
  |  Branch (831:7): [True: 29, False: 64]
  ------------------
  832|     29|      return;
  833|     29|   }
  834|       |
  835|     64|   const uint16_t len = reader.get_uint16_t();
  836|       |
  837|     64|   if(len == 0) {
  ------------------
  |  Branch (837:7): [True: 1, False: 63]
  ------------------
  838|       |      // Based on RFC 8446 4.2.2, len of the Cookie buffer must be at least 1
  839|      1|      throw Decoding_Error("Cookie length must be at least 1 byte");
  840|      1|   }
  841|       |
  842|     63|   if(len > reader.remaining_bytes()) {
  ------------------
  |  Branch (842:7): [True: 19, False: 44]
  ------------------
  843|     19|      throw Decoding_Error("Not enough bytes in the buffer to decode Cookie");
  844|     19|   }
  845|       |
  846|  21.1k|   for(size_t i = 0; i < len; ++i) {
  ------------------
  |  Branch (846:22): [True: 21.0k, False: 44]
  ------------------
  847|  21.0k|      m_cookie.push_back(reader.get_byte());
  848|  21.0k|   }
  849|     44|}
_ZN5Botan3TLS22PSK_Key_Exchange_ModesC2ERNS0_15TLS_Data_ReaderEt:
  878|     80|PSK_Key_Exchange_Modes::PSK_Key_Exchange_Modes(TLS_Data_Reader& reader, uint16_t extension_size) {
  879|     80|   if(extension_size < 2) {
  ------------------
  |  Branch (879:7): [True: 2, False: 78]
  ------------------
  880|      2|      throw Decoding_Error("Empty psk_key_exchange_modes extension is illegal");
  881|      2|   }
  882|       |
  883|     78|   const auto mode_count = reader.get_byte();
  884|  2.12k|   for(uint16_t i = 0; i < mode_count; ++i) {
  ------------------
  |  Branch (884:24): [True: 2.04k, False: 78]
  ------------------
  885|  2.04k|      const auto mode = static_cast<PSK_Key_Exchange_Mode>(reader.get_byte());
  886|  2.04k|      if(mode == PSK_Key_Exchange_Mode::PSK_KE || mode == PSK_Key_Exchange_Mode::PSK_DHE_KE) {
  ------------------
  |  Branch (886:10): [True: 977, False: 1.07k]
  |  Branch (886:51): [True: 315, False: 756]
  ------------------
  887|  1.24k|         m_modes.push_back(mode);
  888|  1.24k|      }
  889|  2.04k|   }
  890|     78|}
_ZN5Botan3TLS23Certificate_AuthoritiesC2ERNS0_15TLS_Data_ReaderEt:
  908|  1.10k|Certificate_Authorities::Certificate_Authorities(TLS_Data_Reader& reader, uint16_t extension_size) {
  909|  1.10k|   if(extension_size < 2) {
  ------------------
  |  Branch (909:7): [True: 2, False: 1.10k]
  ------------------
  910|      2|      throw Decoding_Error("Empty certificate_authorities extension is illegal");
  911|      2|   }
  912|       |
  913|  1.10k|   const uint16_t purported_size = reader.get_uint16_t();
  914|       |
  915|  1.10k|   if(reader.remaining_bytes() != purported_size) {
  ------------------
  |  Branch (915:7): [True: 8, False: 1.09k]
  ------------------
  916|      8|      throw Decoding_Error("Inconsistent length in certificate_authorities extension");
  917|      8|   }
  918|       |
  919|  4.85k|   while(reader.has_remaining()) {
  ------------------
  |  Branch (919:10): [True: 3.76k, False: 1.09k]
  ------------------
  920|  3.76k|      std::vector<uint8_t> name_bits = reader.get_tls_length_value(2);
  921|       |
  922|  3.76k|      BER_Decoder decoder(name_bits.data(), name_bits.size());
  923|  3.76k|      m_distinguished_names.emplace_back();
  924|  3.76k|      decoder.decode(m_distinguished_names.back());
  925|  3.76k|   }
  926|  1.09k|}
_ZN5Botan3TLS19EarlyDataIndicationC2ERNS0_15TLS_Data_ReaderEtNS0_14Handshake_TypeE:
  945|     54|                                         Handshake_Type message_type) {
  946|     54|   if(message_type == Handshake_Type::NewSessionTicket) {
  ------------------
  |  Branch (946:7): [True: 0, False: 54]
  ------------------
  947|      0|      if(extension_size != 4) {
  ------------------
  |  Branch (947:10): [True: 0, False: 0]
  ------------------
  948|      0|         throw TLS_Exception(Alert::DecodeError,
  949|      0|                             "Received an early_data extension in a NewSessionTicket message "
  950|      0|                             "without maximum early data size indication");
  951|      0|      }
  952|       |
  953|      0|      m_max_early_data_size = reader.get_uint32_t();
  954|     54|   } else if(extension_size != 0) {
  ------------------
  |  Branch (954:14): [True: 11, False: 43]
  ------------------
  955|     11|      throw TLS_Exception(Alert::DecodeError,
  956|     11|                          "Received an early_data extension containing an unexpected data "
  957|     11|                          "size indication");
  958|     11|   }
  959|     54|}
tls_extensions.cpp:_ZN5Botan3TLS12_GLOBAL__N_114make_extensionERNS0_15TLS_Data_ReaderENS0_14Extension_CodeENS0_15Connection_SideENS0_14Handshake_TypeE:
   31|  5.72k|                                          const Handshake_Type message_type) {
   32|       |   // This cast is safe because we read exactly a 16 bit length field for
   33|       |   // the extension in Extensions::deserialize
   34|  5.72k|   const uint16_t size = static_cast<uint16_t>(reader.remaining_bytes());
   35|  5.72k|   switch(code) {
  ------------------
  |  Branch (35:11): [True: 3.09k, False: 2.62k]
  ------------------
   36|    186|      case Extension_Code::ServerNameIndication:
  ------------------
  |  Branch (36:7): [True: 186, False: 5.53k]
  ------------------
   37|    186|         return std::make_unique<Server_Name_Indicator>(reader, size);
   38|       |
   39|     94|      case Extension_Code::SupportedGroups:
  ------------------
  |  Branch (39:7): [True: 94, False: 5.62k]
  ------------------
   40|     94|         return std::make_unique<Supported_Groups>(reader, size);
   41|       |
   42|     32|      case Extension_Code::CertificateStatusRequest:
  ------------------
  |  Branch (42:7): [True: 32, False: 5.68k]
  ------------------
   43|     32|         return std::make_unique<Certificate_Status_Request>(reader, size, message_type, from);
   44|       |
   45|     62|      case Extension_Code::EcPointFormats:
  ------------------
  |  Branch (45:7): [True: 62, False: 5.65k]
  ------------------
   46|     62|         return std::make_unique<Supported_Point_Formats>(reader, size);
   47|       |
   48|     22|      case Extension_Code::SafeRenegotiation:
  ------------------
  |  Branch (48:7): [True: 22, False: 5.69k]
  ------------------
   49|     22|         return std::make_unique<Renegotiation_Extension>(reader, size);
   50|       |
   51|     18|      case Extension_Code::SignatureAlgorithms:
  ------------------
  |  Branch (51:7): [True: 18, False: 5.70k]
  ------------------
   52|     18|         return std::make_unique<Signature_Algorithms>(reader, size);
   53|       |
   54|     48|      case Extension_Code::CertSignatureAlgorithms:
  ------------------
  |  Branch (54:7): [True: 48, False: 5.67k]
  ------------------
   55|     48|         return std::make_unique<Signature_Algorithms_Cert>(reader, size);
   56|       |
   57|     26|      case Extension_Code::UseSrtp:
  ------------------
  |  Branch (57:7): [True: 26, False: 5.69k]
  ------------------
   58|     26|         return std::make_unique<SRTP_Protection_Profiles>(reader, size);
   59|       |
   60|    153|      case Extension_Code::ApplicationLayerProtocolNegotiation:
  ------------------
  |  Branch (60:7): [True: 153, False: 5.56k]
  ------------------
   61|    153|         return std::make_unique<Application_Layer_Protocol_Notification>(reader, size, from);
   62|       |
   63|     35|      case Extension_Code::ClientCertificateType:
  ------------------
  |  Branch (63:7): [True: 35, False: 5.68k]
  ------------------
   64|     35|         return std::make_unique<Client_Certificate_Type>(reader, size, from);
   65|       |
   66|     41|      case Extension_Code::ServerCertificateType:
  ------------------
  |  Branch (66:7): [True: 41, False: 5.67k]
  ------------------
   67|     41|         return std::make_unique<Server_Certificate_Type>(reader, size, from);
   68|       |
   69|     38|      case Extension_Code::ExtendedMasterSecret:
  ------------------
  |  Branch (69:7): [True: 38, False: 5.68k]
  ------------------
   70|     38|         return std::make_unique<Extended_Master_Secret>(reader, size);
   71|       |
   72|     49|      case Extension_Code::RecordSizeLimit:
  ------------------
  |  Branch (72:7): [True: 49, False: 5.67k]
  ------------------
   73|     49|         return std::make_unique<Record_Size_Limit>(reader, size, from);
   74|       |
   75|     45|      case Extension_Code::EncryptThenMac:
  ------------------
  |  Branch (75:7): [True: 45, False: 5.67k]
  ------------------
   76|     45|         return std::make_unique<Encrypt_then_MAC>(reader, size);
   77|       |
   78|     43|      case Extension_Code::SessionTicket:
  ------------------
  |  Branch (78:7): [True: 43, False: 5.67k]
  ------------------
   79|     43|         return std::make_unique<Session_Ticket_Extension>(reader, size);
   80|       |
   81|     47|      case Extension_Code::SupportedVersions:
  ------------------
  |  Branch (81:7): [True: 47, False: 5.67k]
  ------------------
   82|     47|         return std::make_unique<Supported_Versions>(reader, size, from);
   83|       |
   84|      0|#if defined(BOTAN_HAS_TLS_13)
   85|    210|      case Extension_Code::PresharedKey:
  ------------------
  |  Branch (85:7): [True: 210, False: 5.51k]
  ------------------
   86|    210|         return std::make_unique<PSK>(reader, size, message_type);
   87|       |
   88|     54|      case Extension_Code::EarlyData:
  ------------------
  |  Branch (88:7): [True: 54, False: 5.66k]
  ------------------
   89|     54|         return std::make_unique<EarlyDataIndication>(reader, size, message_type);
   90|       |
   91|     93|      case Extension_Code::Cookie:
  ------------------
  |  Branch (91:7): [True: 93, False: 5.62k]
  ------------------
   92|     93|         return std::make_unique<Cookie>(reader, size);
   93|       |
   94|     80|      case Extension_Code::PskKeyExchangeModes:
  ------------------
  |  Branch (94:7): [True: 80, False: 5.64k]
  ------------------
   95|     80|         return std::make_unique<PSK_Key_Exchange_Modes>(reader, size);
   96|       |
   97|  1.10k|      case Extension_Code::CertificateAuthorities:
  ------------------
  |  Branch (97:7): [True: 1.10k, False: 4.61k]
  ------------------
   98|  1.10k|         return std::make_unique<Certificate_Authorities>(reader, size);
   99|       |
  100|    143|      case Extension_Code::KeyShare:
  ------------------
  |  Branch (100:7): [True: 143, False: 5.57k]
  ------------------
  101|    143|         return std::make_unique<Key_Share>(reader, size, message_type);
  102|  5.72k|#endif
  103|  5.72k|   }
  104|       |
  105|  3.09k|   return std::make_unique<Unknown_Extension>(static_cast<Extension_Code>(code), reader, size);
  106|  5.72k|}
tls_extensions.cpp:_ZZN5Botan3TLS21Certificate_Type_BaseC1ERNS0_15TLS_Data_ReaderEtNS0_15Connection_SideEENK3$_3clIhEEDaT_:
  434|  1.30k|         type_bytes.begin(), type_bytes.end(), std::back_inserter(m_certificate_types), [](const auto type_byte) {
  435|  1.30k|            return static_cast<Certificate_Type>(type_byte);
  436|  1.30k|         });
tls_extensions.cpp:_ZZN5Botan3TLS23Supported_Point_FormatsC1ERNS0_15TLS_Data_ReaderEtENK3$_5clEh:
  580|    213|            std::any_of(std::begin(remaining_formats), std::end(remaining_formats), [](uint8_t remaining_format) {
  581|    213|               return static_cast<ECPointFormat>(remaining_format) == UNCOMPRESSED;
  582|    213|            });
tls_extensions.cpp:_ZN5Botan3TLS12_GLOBAL__N_126parse_signature_algorithmsERNS0_15TLS_Data_ReaderEt:
  621|     66|std::vector<Signature_Scheme> parse_signature_algorithms(TLS_Data_Reader& reader, uint16_t extension_size) {
  622|     66|   uint16_t len = reader.get_uint16_t();
  623|       |
  624|     66|   if(len + 2 != extension_size || len % 2 == 1 || len == 0) {
  ------------------
  |  Branch (624:7): [True: 27, False: 39]
  |  Branch (624:36): [True: 1, False: 38]
  |  Branch (624:52): [True: 1, False: 37]
  ------------------
  625|     25|      throw Decoding_Error("Bad encoding on signature algorithms extension");
  626|     25|   }
  627|       |
  628|     41|   std::vector<Signature_Scheme> schemes;
  629|     41|   schemes.reserve(len / 2);
  630|  1.97k|   while(len) {
  ------------------
  |  Branch (630:10): [True: 1.93k, False: 41]
  ------------------
  631|  1.93k|      schemes.emplace_back(reader.get_uint16_t());
  632|  1.93k|      len -= 2;
  633|  1.93k|   }
  634|       |
  635|     41|   return schemes;
  636|     66|}

_ZN5Botan3TLS26Certificate_Status_RequestC2ERNS0_15TLS_Data_ReaderEtNS0_14Handshake_TypeENS0_15Connection_SideE:
   89|     32|                                                       Connection_Side from) {
   90|       |   // This parser needs to take TLS 1.2 and TLS 1.3 into account. The
   91|       |   // extension's content and structure is dependent on the context it
   92|       |   // was sent in (i.e. the enclosing handshake message). Below is a list
   93|       |   // of handshake messages this can appear in.
   94|       |   //
   95|       |   // TLS 1.2
   96|       |   //  * Client Hello
   97|       |   //  * Server Hello
   98|       |   //
   99|       |   // TLS 1.3
  100|       |   //  * Client Hello
  101|       |   //  * Certificate Request
  102|       |   //  * Certificate (Entry)
  103|       |
  104|       |   // RFC 6066 8.
  105|       |   //    In order to indicate their desire to receive certificate status
  106|       |   //    information, clients MAY include an extension of type "status_request"
  107|       |   //    in the (extended) client hello.
  108|     32|   if(message_type == Handshake_Type::ClientHello) {
  ------------------
  |  Branch (108:7): [True: 32, False: 0]
  ------------------
  109|     32|      m_impl = std::make_unique<Certificate_Status_Request_Internal>(
  110|     32|         RFC6066_Certificate_Status_Request(reader, extension_size));
  111|     32|   }
  112|       |
  113|       |   // RFC 6066 8.
  114|       |   //    If a server returns a "CertificateStatus" message, then the server MUST
  115|       |   //    have included an extension of type "status_request" with empty
  116|       |   //    "extension_data" in the extended server hello.
  117|       |   //
  118|       |   // RFC 8446 4.4.2.1
  119|       |   //    A server MAY request that a client present an OCSP response with its
  120|       |   //    certificate by sending an empty "status_request" extension in its
  121|       |   //    CertificateRequest message.
  122|      0|   else if(message_type == Handshake_Type::ServerHello || message_type == Handshake_Type::CertificateRequest) {
  ------------------
  |  Branch (122:12): [True: 0, False: 0]
  |  Branch (122:59): [True: 0, False: 0]
  ------------------
  123|      0|      m_impl = std::make_unique<Certificate_Status_Request_Internal>(
  124|      0|         RFC6066_Empty_Certificate_Status_Request(extension_size));
  125|      0|   }
  126|       |
  127|       |   // RFC 8446 4.4.2.1
  128|       |   //    In TLS 1.3, the server's OCSP information is carried in an extension
  129|       |   //    in the CertificateEntry [in a Certificate handshake message] [...].
  130|       |   //    Specifically, the body of the "status_request" extension from the
  131|       |   //    server MUST be a CertificateStatus structure as defined in [RFC6066]
  132|       |   //    [...].
  133|       |   //
  134|       |   // RFC 8446 4.4.2.1
  135|       |   //    If the client opts to send an OCSP response, the body of its
  136|       |   //    "status_request" extension MUST be a CertificateStatus structure as
  137|       |   //    defined in [RFC6066].
  138|      0|   else if(message_type == Handshake_Type::Certificate) {
  ------------------
  |  Branch (138:12): [True: 0, False: 0]
  ------------------
  139|      0|      m_impl = std::make_unique<Certificate_Status_Request_Internal>(
  140|      0|         Certificate_Status(reader.get_fixed<uint8_t>(extension_size), from));
  141|      0|   }
  142|       |
  143|       |   // all other contexts are not allowed for this extension
  144|      0|   else {
  145|      0|      throw TLS_Exception(Alert::UnsupportedExtension,
  146|      0|                          "Server sent a Certificate_Status_Request extension in an unsupported context");
  147|      0|   }
  148|     32|}
_ZN5Botan3TLS26Certificate_Status_RequestD2Ev:
  161|     25|Certificate_Status_Request::~Certificate_Status_Request() = default;
tls_extensions_cert_status_req.cpp:_ZN5Botan3TLS12_GLOBAL__N_134RFC6066_Certificate_Status_RequestC2ERNS0_15TLS_Data_ReaderEt:
   38|     32|      RFC6066_Certificate_Status_Request(TLS_Data_Reader& reader, uint16_t extension_size) {
   39|     32|         if(extension_size == 0) {
  ------------------
  |  Branch (39:13): [True: 1, False: 31]
  ------------------
   40|      1|            throw Decoding_Error("Received an unexpectedly empty Certificate_Status_Request");
   41|      1|         }
   42|       |
   43|     31|         const uint8_t type = reader.get_byte();
   44|     31|         if(type == 1 /* ocsp */) {
  ------------------
  |  Branch (44:13): [True: 11, False: 20]
  ------------------
   45|     11|            const size_t len_resp_id_list = reader.get_uint16_t();
   46|     11|            ocsp_names = reader.get_fixed<uint8_t>(len_resp_id_list);
   47|     11|            const size_t len_requ_ext = reader.get_uint16_t();
   48|     11|            extension_bytes = reader.get_fixed<uint8_t>(len_requ_ext);
   49|     20|         } else {
   50|       |            // RFC 6066 does not specify anything but 'ocsp' and we
   51|       |            // don't support anything else either.
   52|     20|            reader.discard_next(extension_size - 1);
   53|     20|         }
   54|     31|      }
tls_extensions_cert_status_req.cpp:_ZN5Botan3TLS35Certificate_Status_Request_InternalC2ENSt3__17variantIJNS0_12_GLOBAL__N_140RFC6066_Empty_Certificate_Status_RequestENS4_34RFC6066_Certificate_Status_RequestENS0_18Certificate_StatusEEEE:
   81|     25|      Certificate_Status_Request_Internal(Contents c) : content(std::move(c)) {}

_ZN5Botan3TLS16Signature_SchemeC2Et:
   53|  1.93k|Signature_Scheme::Signature_Scheme(uint16_t wire_code) : Signature_Scheme(Signature_Scheme::Code(wire_code)) {}
_ZN5Botan3TLS16Signature_SchemeC2ENS1_4CodeE:
   55|  1.93k|Signature_Scheme::Signature_Scheme(Signature_Scheme::Code wire_code) : m_code(wire_code) {}

_ZNK5Botan3TLS16Protocol_Version20is_datagram_protocolEv:
   36|  2.69k|bool Protocol_Version::is_datagram_protocol() const {
   37|  2.69k|   return major_version() > 250;
   38|  2.69k|}

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

_ZN5Botan19throw_invalid_stateEPKcS1_S1_:
   25|     16|void throw_invalid_state(const char* expr, const char* func, const char* file) {
   26|     16|   throw Invalid_State(fmt("Invalid state: expr {} was false in {}:{}", expr, func, file));
   27|     16|}

_ZN5Botan12ucs2_to_utf8EPKhm:
   54|    674|std::string ucs2_to_utf8(const uint8_t ucs2[], size_t len) {
   55|    674|   if(len % 2 != 0) {
  ------------------
  |  Branch (55:7): [True: 3, False: 671]
  ------------------
   56|      3|      throw Decoding_Error("Invalid length for UCS-2 string");
   57|      3|   }
   58|       |
   59|    671|   const size_t chars = len / 2;
   60|       |
   61|    671|   std::string s;
   62|  2.46k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (62:22): [True: 1.79k, False: 671]
  ------------------
   63|  1.79k|      const uint32_t c = load_be<uint16_t>(ucs2, i);
   64|  1.79k|      append_utf8_for(s, c);
   65|  1.79k|   }
   66|       |
   67|    671|   return s;
   68|    674|}
_ZN5Botan12ucs4_to_utf8EPKhm:
   70|    662|std::string ucs4_to_utf8(const uint8_t ucs4[], size_t len) {
   71|    662|   if(len % 4 != 0) {
  ------------------
  |  Branch (71:7): [True: 1, False: 661]
  ------------------
   72|      1|      throw Decoding_Error("Invalid length for UCS-4 string");
   73|      1|   }
   74|       |
   75|    661|   const size_t chars = len / 4;
   76|       |
   77|    661|   std::string s;
   78|  1.19k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (78:22): [True: 529, False: 661]
  ------------------
   79|    529|      const uint32_t c = load_be<uint32_t>(ucs4, i);
   80|    529|      append_utf8_for(s, c);
   81|    529|   }
   82|       |
   83|    661|   return s;
   84|    662|}
_ZN5Botan14latin1_to_utf8EPKhm:
   89|  1.17k|std::string latin1_to_utf8(const uint8_t chars[], size_t len) {
   90|  1.17k|   std::string s;
   91|  16.9k|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (91:22): [True: 15.7k, False: 1.17k]
  ------------------
   92|  15.7k|      const uint32_t c = static_cast<uint8_t>(chars[i]);
   93|  15.7k|      append_utf8_for(s, c);
   94|  15.7k|   }
   95|  1.17k|   return s;
   96|  1.17k|}
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   18|  18.1k|void append_utf8_for(std::string& s, uint32_t c) {
   19|  18.1k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (19:7): [True: 1.01k, False: 17.0k]
  |  Branch (19:22): [True: 17, False: 996]
  ------------------
   20|     17|      throw Decoding_Error("Invalid Unicode character");
   21|     17|   }
   22|       |
   23|  18.0k|   if(c <= 0x7F) {
  ------------------
  |  Branch (23:7): [True: 12.5k, False: 5.53k]
  ------------------
   24|  12.5k|      const uint8_t b0 = static_cast<uint8_t>(c);
   25|  12.5k|      s.push_back(static_cast<char>(b0));
   26|  12.5k|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (26:14): [True: 3.90k, False: 1.63k]
  ------------------
   27|  3.90k|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   28|  3.90k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   29|  3.90k|      s.push_back(static_cast<char>(b0));
   30|  3.90k|      s.push_back(static_cast<char>(b1));
   31|  3.90k|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (31:14): [True: 1.15k, False: 479]
  ------------------
   32|  1.15k|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   33|  1.15k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   34|  1.15k|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   35|  1.15k|      s.push_back(static_cast<char>(b0));
   36|  1.15k|      s.push_back(static_cast<char>(b1));
   37|  1.15k|      s.push_back(static_cast<char>(b2));
   38|  1.15k|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (38:14): [True: 434, False: 45]
  ------------------
   39|    434|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   40|    434|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   41|    434|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   42|    434|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   43|    434|      s.push_back(static_cast<char>(b0));
   44|    434|      s.push_back(static_cast<char>(b1));
   45|    434|      s.push_back(static_cast<char>(b2));
   46|    434|      s.push_back(static_cast<char>(b3));
   47|    434|   } else {
   48|     45|      throw Decoding_Error("Invalid Unicode character");
   49|     45|   }
   50|  18.0k|}

_ZN5Botan5CPUID10CPUID_DataC2Ev:
  122|      1|CPUID::CPUID_Data::CPUID_Data() {
  123|      1|   m_processor_features = 0;
  124|       |
  125|      1|#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) || defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY) || \
  126|      1|   defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
  127|       |
  128|      1|   m_processor_features = detect_cpu_features();
  129|       |
  130|      1|#endif
  131|       |
  132|      1|   m_processor_features |= CPUID::CPUID_INITIALIZED_BIT;
  133|       |
  134|      1|   if(runtime_check_if_big_endian()) {
  ------------------
  |  Branch (134:7): [True: 0, False: 1]
  ------------------
  135|      0|      m_processor_features |= CPUID::CPUID_IS_BIG_ENDIAN_BIT;
  136|      0|   }
  137|       |
  138|      1|   std::string clear_cpuid_env;
  139|      1|   if(OS::read_env_variable(clear_cpuid_env, "BOTAN_CLEAR_CPUID")) {
  ------------------
  |  Branch (139:7): [True: 0, False: 1]
  ------------------
  140|      0|      for(const auto& cpuid : split_on(clear_cpuid_env, ',')) {
  ------------------
  |  Branch (140:29): [True: 0, False: 0]
  ------------------
  141|      0|         for(auto& bit : CPUID::bit_from_string(cpuid)) {
  ------------------
  |  Branch (141:24): [True: 0, False: 0]
  ------------------
  142|      0|            const uint32_t cleared = ~static_cast<uint32_t>(bit);
  143|      0|            m_processor_features &= cleared;
  144|      0|         }
  145|      0|      }
  146|      0|   }
  147|      1|}
cpuid.cpp:_ZN5Botan12_GLOBAL__N_127runtime_check_if_big_endianEv:
   95|      1|bool runtime_check_if_big_endian() {
   96|       |   // Check runtime endian
   97|      1|   const uint32_t endian32 = 0x01234567;
   98|      1|   const uint8_t* e8 = reinterpret_cast<const uint8_t*>(&endian32);
   99|       |
  100|      1|   bool is_big_endian = false;
  101|       |
  102|      1|   if(e8[0] == 0x01 && e8[1] == 0x23 && e8[2] == 0x45 && e8[3] == 0x67) {
  ------------------
  |  Branch (102:7): [True: 0, False: 1]
  |  Branch (102:24): [True: 0, False: 0]
  |  Branch (102:41): [True: 0, False: 0]
  |  Branch (102:58): [True: 0, False: 0]
  ------------------
  103|      0|      is_big_endian = true;
  104|      1|   } else if(e8[0] == 0x67 && e8[1] == 0x45 && e8[2] == 0x23 && e8[3] == 0x01) {
  ------------------
  |  Branch (104:14): [True: 1, False: 0]
  |  Branch (104:31): [True: 1, False: 0]
  |  Branch (104:48): [True: 1, False: 0]
  |  Branch (104:65): [True: 1, False: 0]
  ------------------
  105|      1|      is_big_endian = false;
  106|      1|   } else {
  107|      0|      throw Internal_Error("Unexpected endian at runtime, neither big nor little");
  108|      0|   }
  109|       |
  110|       |   // If we were compiled with a known endian, verify it matches at runtime
  111|      1|#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  112|      1|   BOTAN_ASSERT(!is_big_endian, "Build and runtime endian match");
  ------------------
  |  |   51|      1|   do {                                                                                 \
  |  |   52|      1|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 1]
  |  |  ------------------
  |  |   53|      1|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|      1|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  113|       |#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  114|       |   BOTAN_ASSERT(is_big_endian, "Build and runtime endian match");
  115|       |#endif
  116|       |
  117|      1|   return is_big_endian;
  118|      1|}

_ZN5Botan5CPUID10CPUID_Data19detect_cpu_featuresEv:
   71|      1|uint32_t CPUID::CPUID_Data::detect_cpu_features() {
   72|      1|   uint32_t features_detected = 0;
   73|      1|   uint32_t cpuid[4] = {0};
   74|      1|   bool has_os_ymm_support = false;
   75|      1|   bool has_os_zmm_support = false;
   76|       |
   77|       |   // CPUID 0: vendor identification, max sublevel
   78|      1|   invoke_cpuid(0, cpuid);
   79|       |
   80|      1|   const uint32_t max_supported_sublevel = cpuid[0];
   81|       |
   82|      1|   if(max_supported_sublevel >= 1) {
  ------------------
  |  Branch (82:7): [True: 1, False: 0]
  ------------------
   83|       |      // CPUID 1: feature bits
   84|      1|      invoke_cpuid(1, cpuid);
   85|      1|      const uint64_t flags0 = (static_cast<uint64_t>(cpuid[2]) << 32) | cpuid[3];
   86|       |
   87|      1|      enum x86_CPUID_1_bits : uint64_t {
   88|      1|         RDTSC = (1ULL << 4),
   89|      1|         SSE2 = (1ULL << 26),
   90|      1|         CLMUL = (1ULL << 33),
   91|      1|         SSSE3 = (1ULL << 41),
   92|      1|         AESNI = (1ULL << 57),
   93|      1|         OSXSAVE = (1ULL << 59),
   94|      1|         AVX = (1ULL << 60),
   95|      1|         RDRAND = (1ULL << 62)
   96|      1|      };
   97|       |
   98|      1|      if(flags0 & x86_CPUID_1_bits::RDTSC) {
  ------------------
  |  Branch (98:10): [True: 1, False: 0]
  ------------------
   99|      1|         features_detected |= CPUID::CPUID_RDTSC_BIT;
  100|      1|      }
  101|      1|      if(flags0 & x86_CPUID_1_bits::SSE2) {
  ------------------
  |  Branch (101:10): [True: 1, False: 0]
  ------------------
  102|      1|         features_detected |= CPUID::CPUID_SSE2_BIT;
  103|      1|      }
  104|      1|      if(flags0 & x86_CPUID_1_bits::CLMUL) {
  ------------------
  |  Branch (104:10): [True: 1, False: 0]
  ------------------
  105|      1|         features_detected |= CPUID::CPUID_CLMUL_BIT;
  106|      1|      }
  107|      1|      if(flags0 & x86_CPUID_1_bits::SSSE3) {
  ------------------
  |  Branch (107:10): [True: 1, False: 0]
  ------------------
  108|      1|         features_detected |= CPUID::CPUID_SSSE3_BIT;
  109|      1|      }
  110|      1|      if(flags0 & x86_CPUID_1_bits::AESNI) {
  ------------------
  |  Branch (110:10): [True: 1, False: 0]
  ------------------
  111|      1|         features_detected |= CPUID::CPUID_AESNI_BIT;
  112|      1|      }
  113|      1|      if(flags0 & x86_CPUID_1_bits::RDRAND) {
  ------------------
  |  Branch (113:10): [True: 1, False: 0]
  ------------------
  114|      1|         features_detected |= CPUID::CPUID_RDRAND_BIT;
  115|      1|      }
  116|       |
  117|      1|      if((flags0 & x86_CPUID_1_bits::AVX) && (flags0 & x86_CPUID_1_bits::OSXSAVE)) {
  ------------------
  |  Branch (117:10): [True: 1, False: 0]
  |  Branch (117:46): [True: 1, False: 0]
  ------------------
  118|      1|         const uint64_t xcr_flags = xgetbv();
  119|      1|         if((xcr_flags & 0x6) == 0x6) {
  ------------------
  |  Branch (119:13): [True: 1, False: 0]
  ------------------
  120|      1|            has_os_ymm_support = true;
  121|      1|            has_os_zmm_support = (xcr_flags & 0xE0) == 0xE0;
  122|      1|         }
  123|      1|      }
  124|      1|   }
  125|       |
  126|      1|   if(max_supported_sublevel >= 7) {
  ------------------
  |  Branch (126:7): [True: 1, False: 0]
  ------------------
  127|      1|      clear_mem(cpuid, 4);
  128|      1|      invoke_cpuid_sublevel(7, 0, cpuid);
  129|       |
  130|      1|      enum x86_CPUID_7_bits : uint64_t {
  131|      1|         BMI1 = (1ULL << 3),
  132|      1|         AVX2 = (1ULL << 5),
  133|      1|         BMI2 = (1ULL << 8),
  134|      1|         AVX512_F = (1ULL << 16),
  135|      1|         AVX512_DQ = (1ULL << 17),
  136|      1|         RDSEED = (1ULL << 18),
  137|      1|         ADX = (1ULL << 19),
  138|      1|         AVX512_IFMA = (1ULL << 21),
  139|      1|         SHA = (1ULL << 29),
  140|      1|         AVX512_BW = (1ULL << 30),
  141|      1|         AVX512_VL = (1ULL << 31),
  142|      1|         AVX512_VBMI = (1ULL << 33),
  143|      1|         AVX512_VBMI2 = (1ULL << 38),
  144|      1|         AVX512_VAES = (1ULL << 41),
  145|      1|         AVX512_VCLMUL = (1ULL << 42),
  146|      1|         AVX512_VBITALG = (1ULL << 44),
  147|      1|      };
  148|       |
  149|      1|      const uint64_t flags7 = (static_cast<uint64_t>(cpuid[2]) << 32) | cpuid[1];
  150|       |
  151|      1|      if((flags7 & x86_CPUID_7_bits::AVX2) && has_os_ymm_support) {
  ------------------
  |  Branch (151:10): [True: 1, False: 0]
  |  Branch (151:47): [True: 1, False: 0]
  ------------------
  152|      1|         features_detected |= CPUID::CPUID_AVX2_BIT;
  153|      1|      }
  154|      1|      if(flags7 & x86_CPUID_7_bits::RDSEED) {
  ------------------
  |  Branch (154:10): [True: 1, False: 0]
  ------------------
  155|      1|         features_detected |= CPUID::CPUID_RDSEED_BIT;
  156|      1|      }
  157|      1|      if(flags7 & x86_CPUID_7_bits::ADX) {
  ------------------
  |  Branch (157:10): [True: 1, False: 0]
  ------------------
  158|      1|         features_detected |= CPUID::CPUID_ADX_BIT;
  159|      1|      }
  160|      1|      if(flags7 & x86_CPUID_7_bits::SHA) {
  ------------------
  |  Branch (160:10): [True: 0, False: 1]
  ------------------
  161|      0|         features_detected |= CPUID::CPUID_SHA_BIT;
  162|      0|      }
  163|       |
  164|       |      /*
  165|       |      We only set the BMI bit if both BMI1 and BMI2 are supported, since
  166|       |      typically we want to use both extensions in the same code.
  167|       |      */
  168|      1|      if((flags7 & x86_CPUID_7_bits::BMI1) && (flags7 & x86_CPUID_7_bits::BMI2)) {
  ------------------
  |  Branch (168:10): [True: 1, False: 0]
  |  Branch (168:47): [True: 1, False: 0]
  ------------------
  169|      1|         features_detected |= CPUID::CPUID_BMI_BIT;
  170|      1|      }
  171|       |
  172|      1|      if((flags7 & x86_CPUID_7_bits::AVX512_F) && has_os_zmm_support) {
  ------------------
  |  Branch (172:10): [True: 0, False: 1]
  |  Branch (172:51): [True: 0, False: 0]
  ------------------
  173|      0|         const uint64_t AVX512_PROFILE_FLAGS = x86_CPUID_7_bits::AVX512_F | x86_CPUID_7_bits::AVX512_DQ |
  174|      0|                                               x86_CPUID_7_bits::AVX512_IFMA | x86_CPUID_7_bits::AVX512_BW |
  175|      0|                                               x86_CPUID_7_bits::AVX512_VL | x86_CPUID_7_bits::AVX512_VBMI |
  176|      0|                                               x86_CPUID_7_bits::AVX512_VBMI2 | x86_CPUID_7_bits::AVX512_VBITALG;
  177|       |
  178|       |         /*
  179|       |         We only enable AVX512 support if all of the above flags are available
  180|       |
  181|       |         This is more than we strictly need for most uses, however it also has
  182|       |         the effect of preventing execution of AVX512 codepaths on cores that
  183|       |         have serious downclocking problems when AVX512 code executes,
  184|       |         especially Intel Skylake.
  185|       |
  186|       |         VBMI2/VBITALG are the key flags here as they restrict us to Intel Ice
  187|       |         Lake/Rocket Lake, or AMD Zen4, all of which do not have penalties for
  188|       |         executing AVX512.
  189|       |
  190|       |         There is nothing stopping some future processor from supporting the
  191|       |         above flags and having AVX512 penalties, but maybe you should not have
  192|       |         bought such a processor.
  193|       |         */
  194|      0|         if((flags7 & AVX512_PROFILE_FLAGS) == AVX512_PROFILE_FLAGS) {
  ------------------
  |  Branch (194:13): [True: 0, False: 0]
  ------------------
  195|      0|            features_detected |= CPUID::CPUID_AVX512_BIT;
  196|       |
  197|      0|            if(flags7 & x86_CPUID_7_bits::AVX512_VAES) {
  ------------------
  |  Branch (197:16): [True: 0, False: 0]
  ------------------
  198|      0|               features_detected |= CPUID::CPUID_AVX512_AES_BIT;
  199|      0|            }
  200|      0|            if(flags7 & x86_CPUID_7_bits::AVX512_VCLMUL) {
  ------------------
  |  Branch (200:16): [True: 0, False: 0]
  ------------------
  201|      0|               features_detected |= CPUID::CPUID_AVX512_CLMUL_BIT;
  202|      0|            }
  203|      0|         }
  204|      0|      }
  205|      1|   }
  206|       |
  207|       |   /*
  208|       |   * If we don't have access to CPUID, we can still safely assume that
  209|       |   * any x86-64 processor has SSE2 and RDTSC
  210|       |   */
  211|      1|   #if defined(BOTAN_TARGET_ARCH_IS_X86_64)
  212|      1|   if(features_detected == 0) {
  ------------------
  |  Branch (212:7): [True: 0, False: 1]
  ------------------
  213|      0|      features_detected |= CPUID::CPUID_SSE2_BIT;
  214|      0|      features_detected |= CPUID::CPUID_RDTSC_BIT;
  215|      0|   }
  216|      1|   #endif
  217|       |
  218|      1|   return features_detected;
  219|      1|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_112invoke_cpuidEjPj:
   33|      2|void invoke_cpuid(uint32_t type, uint32_t out[4]) {
   34|       |   #if defined(BOTAN_BUILD_COMPILER_IS_MSVC) || defined(BOTAN_BUILD_COMPILER_IS_INTEL)
   35|       |   __cpuid((int*)out, type);
   36|       |
   37|       |   #elif defined(BOTAN_BUILD_COMPILER_IS_GCC) || defined(BOTAN_BUILD_COMPILER_IS_CLANG)
   38|      2|   __get_cpuid(type, out, out + 1, out + 2, out + 3);
   39|       |
   40|       |   #elif defined(BOTAN_USE_GCC_INLINE_ASM)
   41|       |   asm("cpuid\n\t" : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3]) : "0"(type));
   42|       |
   43|       |   #else
   44|       |      #warning "No way of calling x86 cpuid instruction for this compiler"
   45|       |   clear_mem(out, 4);
   46|       |   #endif
   47|      2|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_16xgetbvEv:
   49|      1|BOTAN_FUNC_ISA("xsave") uint64_t xgetbv() {
   50|      1|   return _xgetbv(0);
   51|      1|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_121invoke_cpuid_sublevelEjjPj:
   53|      1|void invoke_cpuid_sublevel(uint32_t type, uint32_t level, uint32_t out[4]) {
   54|       |   #if defined(BOTAN_BUILD_COMPILER_IS_MSVC)
   55|       |   __cpuidex((int*)out, type, level);
   56|       |
   57|       |   #elif defined(BOTAN_BUILD_COMPILER_IS_GCC) || defined(BOTAN_BUILD_COMPILER_IS_CLANG)
   58|      1|   __cpuid_count(type, level, out[0], out[1], out[2], out[3]);
   59|       |
   60|       |   #elif defined(BOTAN_USE_GCC_INLINE_ASM)
   61|       |   asm("cpuid\n\t" : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3]) : "0"(type), "2"(level));
   62|       |
   63|       |   #else
   64|       |      #warning "No way of calling x86 cpuid instruction for this compiler"
   65|       |   clear_mem(out, 4);
   66|       |   #endif
   67|      1|}

_ZN5Botan10DataSource9read_byteERh:
   26|   270k|size_t DataSource::read_byte(uint8_t& out) {
   27|   270k|   return read(&out, 1);
   28|   270k|}
_ZN5Botan10DataSource12discard_nextEm:
   40|  38.6k|size_t DataSource::discard_next(size_t n) {
   41|  38.6k|   uint8_t buf[64] = {0};
   42|  38.6k|   size_t discarded = 0;
   43|       |
   44|  85.0k|   while(n) {
  ------------------
  |  Branch (44:10): [True: 46.5k, False: 38.5k]
  ------------------
   45|  46.5k|      const size_t got = this->read(buf, std::min(n, sizeof(buf)));
   46|  46.5k|      discarded += got;
   47|  46.5k|      n -= got;
   48|       |
   49|  46.5k|      if(got == 0) {
  ------------------
  |  Branch (49:10): [True: 92, False: 46.4k]
  ------------------
   50|     92|         break;
   51|     92|      }
   52|  46.5k|   }
   53|       |
   54|  38.6k|   return discarded;
   55|  38.6k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   60|   159k|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   61|   159k|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   62|   159k|   copy_mem(out, m_source.data() + m_offset, got);
   63|   159k|   m_offset += got;
   64|   159k|   return got;
   65|   159k|}
_ZN5Botan17DataSource_Memory15check_availableEm:
   67|  7.03k|bool DataSource_Memory::check_available(size_t n) {
   68|  7.03k|   return (n <= (m_source.size() - m_offset));
   69|  7.03k|}
_ZNK5Botan17DataSource_Memory4peekEPhmm:
   74|  18.2k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   75|  18.2k|   const size_t bytes_left = m_source.size() - m_offset;
   76|  18.2k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (76:7): [True: 10.4k, False: 7.81k]
  ------------------
   77|  10.4k|      return 0;
   78|  10.4k|   }
   79|       |
   80|  7.81k|   const size_t got = std::min(bytes_left - peek_offset, length);
   81|  7.81k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   82|  7.81k|   return got;
   83|  18.2k|}
_ZNK5Botan17DataSource_Memory11end_of_dataEv:
   88|  4.42k|bool DataSource_Memory::end_of_data() const {
   89|  4.42k|   return (m_offset == m_source.size());
   90|  4.42k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  2.14k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  1.89k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}

_ZN5Botan19secure_scrub_memoryEPvm:
   87|  52.6k|void secure_scrub_memory(void* ptr, size_t n) {
   88|       |#if defined(BOTAN_TARGET_OS_HAS_RTLSECUREZEROMEMORY)
   89|       |   ::RtlSecureZeroMemory(ptr, n);
   90|       |
   91|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_BZERO)
   92|  52.6k|   ::explicit_bzero(ptr, n);
   93|       |
   94|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_MEMSET)
   95|       |   (void)::explicit_memset(ptr, 0, n);
   96|       |
   97|       |#elif defined(BOTAN_USE_VOLATILE_MEMSET_FOR_ZERO) && (BOTAN_USE_VOLATILE_MEMSET_FOR_ZERO == 1)
   98|       |   /*
   99|       |   Call memset through a static volatile pointer, which the compiler
  100|       |   should not elide. This construct should be safe in conforming
  101|       |   compilers, but who knows. I did confirm that on x86-64 GCC 6.1 and
  102|       |   Clang 3.8 both create code that saves the memset address in the
  103|       |   data segment and unconditionally loads and jumps to that address.
  104|       |   */
  105|       |   static void* (*const volatile memset_ptr)(void*, int, size_t) = std::memset;
  106|       |   (memset_ptr)(ptr, 0, n);
  107|       |#else
  108|       |
  109|       |   volatile uint8_t* p = reinterpret_cast<volatile uint8_t*>(ptr);
  110|       |
  111|       |   for(size_t i = 0; i != n; ++i)
  112|       |      p[i] = 0;
  113|       |#endif
  114|  52.6k|}
_ZN5Botan2OS10get_auxvalEm:
  128|      1|unsigned long OS::get_auxval(unsigned long id) {
  129|      1|#if defined(BOTAN_TARGET_OS_HAS_GETAUXVAL)
  130|      1|   return ::getauxval(id);
  131|       |#elif defined(BOTAN_TARGET_OS_IS_ANDROID) && defined(BOTAN_TARGET_ARCH_IS_ARM32)
  132|       |
  133|       |   if(id == 0)
  134|       |      return 0;
  135|       |
  136|       |   char** p = environ;
  137|       |
  138|       |   while(*p++ != nullptr)
  139|       |      ;
  140|       |
  141|       |   Elf32_auxv_t* e = reinterpret_cast<Elf32_auxv_t*>(p);
  142|       |
  143|       |   while(e != nullptr) {
  144|       |      if(e->a_type == id)
  145|       |         return e->a_un.a_val;
  146|       |      e++;
  147|       |   }
  148|       |
  149|       |   return 0;
  150|       |#elif defined(BOTAN_TARGET_OS_HAS_ELF_AUX_INFO)
  151|       |   unsigned long auxinfo = 0;
  152|       |   ::elf_aux_info(static_cast<int>(id), &auxinfo, sizeof(auxinfo));
  153|       |   return auxinfo;
  154|       |#elif defined(BOTAN_TARGET_OS_HAS_AUXINFO)
  155|       |   for(const AuxInfo* auxinfo = static_cast<AuxInfo*>(::_dlauxinfo()); auxinfo != AT_NULL; ++auxinfo) {
  156|       |      if(id == auxinfo->a_type)
  157|       |         return auxinfo->a_v;
  158|       |   }
  159|       |
  160|       |   return 0;
  161|       |#else
  162|       |   BOTAN_UNUSED(id);
  163|       |   return 0;
  164|       |#endif
  165|      1|}
_ZN5Botan2OS27running_in_privileged_stateEv:
  167|      1|bool OS::running_in_privileged_state() {
  168|      1|#if defined(AT_SECURE)
  169|      1|   return OS::get_auxval(AT_SECURE) != 0;
  170|       |#elif defined(BOTAN_TARGET_OS_HAS_POSIX1)
  171|       |   return (::getuid() != ::geteuid()) || (::getgid() != ::getegid());
  172|       |#else
  173|       |   return false;
  174|       |#endif
  175|      1|}
_ZN5Botan2OS17read_env_variableERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
  409|      1|bool OS::read_env_variable(std::string& value_out, std::string_view name_view) {
  410|      1|   value_out = "";
  411|       |
  412|      1|   if(running_in_privileged_state()) {
  ------------------
  |  Branch (412:7): [True: 0, False: 1]
  ------------------
  413|      0|      return false;
  414|      0|   }
  415|       |
  416|       |#if defined(BOTAN_TARGET_OS_HAS_WIN32) && defined(BOTAN_BUILD_COMPILER_IS_MSVC)
  417|       |   const std::string name(name_view);
  418|       |   char val[128] = {0};
  419|       |   size_t req_size = 0;
  420|       |   if(getenv_s(&req_size, val, sizeof(val), name.c_str()) == 0) {
  421|       |      // Microsoft's implementation always writes a terminating \0,
  422|       |      // and includes it in the reported length of the environment variable
  423|       |      // if a value exists.
  424|       |      if(req_size > 0 && val[req_size - 1] == '\0') {
  425|       |         value_out = std::string(val);
  426|       |      } else {
  427|       |         value_out = std::string(val, req_size);
  428|       |      }
  429|       |      return true;
  430|       |   }
  431|       |#else
  432|      1|   const std::string name(name_view);
  433|      1|   if(const char* val = std::getenv(name.c_str())) {
  ------------------
  |  Branch (433:19): [True: 0, False: 1]
  ------------------
  434|      0|      value_out = val;
  435|      0|      return true;
  436|      0|   }
  437|      1|#endif
  438|       |
  439|      1|   return false;
  440|      1|}

_ZN5Botan7X509_DN13add_attributeERKNS_3OIDERKNS_11ASN1_StringE:
  100|  4.98k|void X509_DN::add_attribute(const OID& oid, const ASN1_String& str) {
  101|  4.98k|   if(str.empty()) {
  ------------------
  |  Branch (101:7): [True: 2.18k, False: 2.80k]
  ------------------
  102|  2.18k|      return;
  103|  2.18k|   }
  104|       |
  105|  2.80k|   m_rdn.push_back(std::make_pair(oid, str));
  106|  2.80k|   m_dn_bits.clear();
  107|  2.80k|}
_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  347|  3.69k|void X509_DN::decode_from(BER_Decoder& source) {
  348|  3.69k|   std::vector<uint8_t> bits;
  349|       |
  350|  3.69k|   source.start_sequence().raw_bytes(bits).end_cons();
  351|       |
  352|  3.69k|   BER_Decoder sequence(bits);
  353|       |
  354|  3.69k|   m_rdn.clear();
  355|       |
  356|  5.36k|   while(sequence.more_items()) {
  ------------------
  |  Branch (356:10): [True: 1.67k, False: 3.69k]
  ------------------
  357|  1.67k|      BER_Decoder rdn = sequence.start_set();
  358|       |
  359|  7.13k|      while(rdn.more_items()) {
  ------------------
  |  Branch (359:13): [True: 5.46k, False: 1.67k]
  ------------------
  360|  5.46k|         OID oid;
  361|  5.46k|         ASN1_String str;
  362|       |
  363|  5.46k|         rdn.start_sequence()
  364|  5.46k|            .decode(oid)
  365|  5.46k|            .decode(str)  // TODO support Any
  366|  5.46k|            .end_cons();
  367|       |
  368|  5.46k|         add_attribute(oid, str);
  369|  5.46k|      }
  370|  1.67k|   }
  371|       |
  372|       |   // Have to assign last as add_attribute zaps m_dn_bits
  373|  3.69k|   m_dn_bits = bits;
  374|  3.69k|}