_ZN5Botan8high_bitITkNSt3__117unsigned_integralEjEEmT_:
   73|  2.09k|BOTAN_FORCE_INLINE constexpr size_t high_bit(T n) {
   74|  2.09k|   size_t hb = 0;
   75|       |
   76|  12.5k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (76:38): [True: 10.4k, False: 2.09k]
  ------------------
   77|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   78|  10.4k|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
   79|  10.4k|      hb += z;
   80|  10.4k|      n >>= z;
   81|  10.4k|   }
   82|       |
   83|  2.09k|   hb += static_cast<size_t>(n);
   84|       |
   85|  2.09k|   return hb;
   86|  2.09k|}
_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEjEEmT_m:
   45|  10.4k|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|  10.4k|   const T a = ~x & (x - 1);
   51|  10.4k|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|  10.4k|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|  10.4k|   return mask & s;
   54|  10.4k|}
_ZN5Botan17ct_if_is_zero_retITkNSt3__117unsigned_integralEmEEmT_m:
   45|   137k|BOTAN_FORCE_INLINE constexpr size_t ct_if_is_zero_ret(T x, size_t s) {
   46|       |   /*
   47|       |   Similar to `return ct_is_zero(x) & s` but has to account for possibility that
   48|       |   sizeof(T) is smaller than sizeof(size_t) which would lead to incomplete masking
   49|       |   */
   50|   137k|   const T a = ~x & (x - 1);
   51|   137k|   const size_t a_top = static_cast<size_t>(CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1)));
   52|   137k|   const size_t mask = static_cast<size_t>(0) - a_top;
   53|   137k|   return mask & s;
   54|   137k|}
_ZN5Botan6chooseITkNSt3__117unsigned_integralEmEET_S2_S2_S2_:
  217|  12.5k|BOTAN_FORCE_INLINE constexpr T choose(T mask, T a, T b) {
  218|       |   //return (mask & a) | (~mask & b);
  219|  12.5k|   return (b ^ (mask & (a ^ b)));
  220|  12.5k|}
_ZN5Botan17ct_expand_top_bitITkNSt3__117unsigned_integralEmEET_S2_:
   28|   127k|BOTAN_FORCE_INLINE constexpr T ct_expand_top_bit(T a) {
   29|   127k|   const T top = CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1));
   30|   127k|   return static_cast<T>(0) - top;
   31|   127k|}
_ZN5Botan10ct_is_zeroITkNSt3__117unsigned_integralEmEET_S2_:
   37|   121k|BOTAN_FORCE_INLINE constexpr T ct_is_zero(T x) {
   38|   121k|   return ct_expand_top_bit<T>(~x & (x - 1));
   39|   121k|}
_ZN5Botan12ceil_tobytesITkNSt3__117unsigned_integralEmEET_S2_:
  176|  18.6k|BOTAN_FORCE_INLINE constexpr T ceil_tobytes(T bits) {
  177|  18.6k|   return (bits + 7) / 8;
  178|  18.6k|}
_ZN5Botan8high_bitITkNSt3__117unsigned_integralEmEEmT_:
   73|  22.8k|BOTAN_FORCE_INLINE constexpr size_t high_bit(T n) {
   74|  22.8k|   size_t hb = 0;
   75|       |
   76|   159k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (76:38): [True: 137k, False: 22.8k]
  ------------------
   77|       |      // Equivalent to: ((n >> s) == 0) ? 0 : s;
   78|   137k|      const size_t z = s - ct_if_is_zero_ret<T>(n >> s, s);
   79|   137k|      hb += z;
   80|   137k|      n >>= z;
   81|   137k|   }
   82|       |
   83|  22.8k|   hb += static_cast<size_t>(n);
   84|       |
   85|  22.8k|   return hb;
   86|  22.8k|}
_ZN5Botan13ceil_divisionITkNSt3__117unsigned_integralEmEET_S2_S2_:
  167|  14.4k|BOTAN_FORCE_INLINE constexpr T ceil_division(T a, T b) {
  168|       |   // Same as `(a + b - 1) / b` but avoids possible overflow
  169|  14.4k|   return a / b + ((a % b != 0) ? 1 : 0);
  ------------------
  |  Branch (169:20): [True: 14.3k, False: 166]
  ------------------
  170|  14.4k|}

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

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

_ZN5Botan13nibble_to_hexEh:
   76|     90|inline constexpr char nibble_to_hex(uint8_t b) {
   77|     90|   const uint8_t n = b & 0x0F;
   78|     90|   return static_cast<char>(n < 10 ? '0' + n : 'A' + (n - 10));
  ------------------
  |  Branch (78:29): [True: 51, False: 39]
  ------------------
   79|     90|}
_ZNK5Botan22CharacterValidityTableclEc:
  125|  31.4k|      constexpr bool operator()(char c) const {
  126|  31.4k|         const uint8_t uc = static_cast<uint8_t>(c);
  127|  31.4k|         return ((m_tbl[uc / 32] >> (uc % 32)) & 1) != 0;
  128|  31.4k|      }

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

_ZN5Botan5CPUID5stateEv:
  155|     45|      static CPUID_Data& state() {
  156|     45|         static CPUID::CPUID_Data g_cpuid;
  157|     45|         return g_cpuid;
  158|     45|      }
_ZNK5Botan5CPUID10CPUID_Data7has_bitEj:
  143|     45|            bool has_bit(uint32_t bit) const { return (m_processor_features & bit) == bit; }
_ZN5Botan5CPUID3hasENS_10CPUFeatureES1_:
   98|     45|      static bool has(CPUID::Feature feat1, CPUID::Feature feat2) {
   99|     45|         return state().has_bit(feat1.as_u32() | feat2.as_u32());
  100|     45|      }
_ZN5Botan5CPUID6is_setEjNS_10CPUFeatureE:
  126|      5|      static inline bool is_set(uint32_t allowed, CPUID::Feature bit) {
  127|      5|         const uint32_t feat_bit = bit.as_u32();
  128|      5|         return ((allowed & feat_bit) == feat_bit);
  129|      5|      }
cpuid_x86.cpp:_ZN5Botan5CPUID6if_setIZNS0_10CPUID_Data19detect_cpu_featuresEjE16x86_CPUID_1_bitsEEjmT_NS_10CPUFeatureEj:
  116|      7|      static inline uint32_t if_set(uint64_t cpuid, T flag, CPUID::Feature bit, uint32_t allowed) {
  117|      7|         const uint64_t flag64 = static_cast<uint64_t>(flag);
  118|      7|         if((cpuid & flag64) == flag64) {
  ------------------
  |  Branch (118:13): [True: 7, False: 0]
  ------------------
  119|      7|            return (bit.as_u32() & allowed);
  120|      7|         } else {
  121|      0|            return 0;
  122|      0|         }
  123|      7|      }
cpuid_x86.cpp:_ZN5Botan5CPUID6if_setIZNS0_10CPUID_Data19detect_cpu_featuresEjE16x86_CPUID_7_bitsEEjmT_NS_10CPUFeatureEj:
  116|      8|      static inline uint32_t if_set(uint64_t cpuid, T flag, CPUID::Feature bit, uint32_t allowed) {
  117|      8|         const uint64_t flag64 = static_cast<uint64_t>(flag);
  118|      8|         if((cpuid & flag64) == flag64) {
  ------------------
  |  Branch (118:13): [True: 5, False: 3]
  ------------------
  119|      5|            return (bit.as_u32() & allowed);
  120|      5|         } else {
  121|      3|            return 0;
  122|      3|         }
  123|      8|      }
cpuid_x86.cpp:_ZN5Botan5CPUID6if_setIZNS0_10CPUID_Data19detect_cpu_featuresEjE18x86_CPUID_7_1_bitsEEjmT_NS_10CPUFeatureEj:
  116|      3|      static inline uint32_t if_set(uint64_t cpuid, T flag, CPUID::Feature bit, uint32_t allowed) {
  117|      3|         const uint64_t flag64 = static_cast<uint64_t>(flag);
  118|      3|         if((cpuid & flag64) == flag64) {
  ------------------
  |  Branch (118:13): [True: 0, False: 3]
  ------------------
  119|      0|            return (bit.as_u32() & allowed);
  120|      3|         } else {
  121|      3|            return 0;
  122|      3|         }
  123|      3|      }

_ZNK5Botan10CPUFeature6as_u32Ev:
   56|    107|      uint32_t as_u32() const { return static_cast<uint32_t>(m_bit); }
_ZN5Botan10CPUFeatureC2ENS0_3BitE:
   54|    113|      CPUFeature(Bit b) : m_bit(b) {}  // NOLINT(*-explicit-conversions,*-explicit-constructor)

_ZN5Botan2CT4MaskImE5is_ltEmm:
  450|  6.12k|      static constexpr Mask<T> is_lt(T x, T y) {
  451|  6.12k|         T u = x ^ ((x ^ y) | ((x - y) ^ x));
  452|  6.12k|         return Mask<T>::expand_top_bit(u);
  453|  6.12k|      }
_ZN5Botan2CT4MaskImE14expand_top_bitEm:
  415|  6.12k|      static constexpr Mask<T> expand_top_bit(T v) { return Mask<T>(ct_expand_top_bit<T>(v)); }
_ZN5Botan2CT4MaskImEC2Em:
  637|  12.5k|      constexpr explicit Mask(T m) : m_mask(m) {}
_ZN5Botan2CT8unpoisonITkNSt3__18integralEmEEvRKT_:
  112|  43.4k|constexpr void unpoison(const T& p) {
  113|  43.4k|   unpoison(&p, 1);
  114|  43.4k|}
_ZN5Botan2CT4MaskImE7is_zeroEm:
  437|  6.45k|      static constexpr Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(value_barrier<T>(x))); }
_ZNK5Botan2CT4MaskImE5valueEv:
  630|  12.5k|      constexpr T value() const { return value_barrier<T>(m_mask); }
_ZNK5Botan2CT4MaskImE6selectEmm:
  548|  12.5k|      constexpr T select(T x, T y) const { return choose(value(), x, y); }
_ZN5Botan2CT4MaskImE8is_equalEmm:
  442|  6.12k|      static constexpr Mask<T> is_equal(T x, T y) {
  443|  6.12k|         const T diff = value_barrier(x) ^ value_barrier(y);
  444|  6.12k|         return Mask<T>::is_zero(diff);
  445|  6.12k|      }
_ZN5Botan2CT8unpoisonImEEvPKT_m:
   67|  72.6k|constexpr inline void unpoison(const T* p, size_t n) {
   68|       |#if defined(BOTAN_HAS_VALGRIND)
   69|       |   if(!std::is_constant_evaluated()) {
   70|       |      VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
   71|       |   }
   72|       |#endif
   73|       |
   74|  72.6k|   BOTAN_UNUSED(p, n);
  ------------------
  |  |  151|  72.6k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   75|  72.6k|}

_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  9.13k|std::string fmt(std::string_view format, const T&... args) {
   54|  9.13k|   std::ostringstream oss;
   55|  9.13k|   oss.imbue(std::locale::classic());
   56|  9.13k|   fmt_detail::do_fmt(oss, format, args...);
   57|  9.13k|   return oss.str();
   58|  9.13k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  9.13k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  9.13k|   size_t i = 0;
   27|       |
   28|  78.4k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 78.4k, False: 0]
  ------------------
   29|  78.4k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 9.13k, False: 69.2k]
  |  Branch (29:30): [True: 9.13k, False: 0]
  |  Branch (29:59): [True: 9.13k, False: 0]
  ------------------
   30|  9.13k|         oss << val;
   31|  9.13k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  69.2k|      } else {
   33|  69.2k|         oss << format[i];
   34|  69.2k|      }
   35|       |
   36|  69.2k|      i += 1;
   37|  69.2k|   }
   38|  9.13k|}
_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  14.9k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  14.9k|   oss << format;
   22|  14.9k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKcEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  4.06k|std::string fmt(std::string_view format, const T&... args) {
   54|  4.06k|   std::ostringstream oss;
   55|  4.06k|   oss.imbue(std::locale::classic());
   56|  4.06k|   fmt_detail::do_fmt(oss, format, args...);
   57|  4.06k|   return oss.str();
   58|  4.06k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJPKcEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  4.06k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.06k|   size_t i = 0;
   27|       |
   28|  4.06k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.06k, False: 0]
  ------------------
   29|  4.06k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.06k, False: 0]
  |  Branch (29:30): [True: 4.06k, False: 0]
  |  Branch (29:59): [True: 4.06k, False: 0]
  ------------------
   30|  4.06k|         oss << val;
   31|  4.06k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  4.06k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  4.06k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  4.22k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.22k|   size_t i = 0;
   27|       |
   28|  60.3k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 60.3k, False: 0]
  ------------------
   29|  60.3k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.22k, False: 56.1k]
  |  Branch (29:30): [True: 4.22k, False: 0]
  |  Branch (29:59): [True: 4.22k, False: 0]
  ------------------
   30|  4.22k|         oss << val;
   31|  4.22k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  56.1k|      } else {
   33|  56.1k|         oss << format[i];
   34|  56.1k|      }
   35|       |
   36|  56.1k|      i += 1;
   37|  56.1k|   }
   38|  4.22k|}
_ZN5Botan3fmtIJPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEENS3_12basic_stringIcS6_NS3_9allocatorIcEEEES7_DpRKT_:
   53|      4|std::string fmt(std::string_view format, const T&... args) {
   54|      4|   std::ostringstream oss;
   55|      4|   oss.imbue(std::locale::classic());
   56|      4|   fmt_detail::do_fmt(oss, format, args...);
   57|      4|   return oss.str();
   58|      4|}
_ZN5Botan10fmt_detail6do_fmtIPKcJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEvRNS4_19basic_ostringstreamIcS7_NS4_9allocatorIcEEEES8_RKT_DpRKT0_:
   25|      4|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      4|   size_t i = 0;
   27|       |
   28|      4|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4, False: 0]
  ------------------
   29|      4|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4, False: 0]
  |  Branch (29:30): [True: 4, False: 0]
  |  Branch (29:59): [True: 4, False: 0]
  ------------------
   30|      4|         oss << val;
   31|      4|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|      4|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|      4|}
_ZN5Botan10fmt_detail6do_fmtImJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    409|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    409|   size_t i = 0;
   27|       |
   28|  16.7k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 16.7k, False: 0]
  ------------------
   29|  16.7k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 409, False: 16.2k]
  |  Branch (29:30): [True: 409, False: 0]
  |  Branch (29:59): [True: 409, False: 0]
  ------------------
   30|    409|         oss << val;
   31|    409|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  16.2k|      } else {
   33|  16.2k|         oss << format[i];
   34|  16.2k|      }
   35|       |
   36|  16.2k|      i += 1;
   37|  16.2k|   }
   38|    409|}
_ZN5Botan3fmtIJPKcEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|    117|std::string fmt(std::string_view format, const T&... args) {
   54|    117|   std::ostringstream oss;
   55|    117|   oss.imbue(std::locale::classic());
   56|    117|   fmt_detail::do_fmt(oss, format, args...);
   57|    117|   return oss.str();
   58|    117|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    591|std::string fmt(std::string_view format, const T&... args) {
   54|    591|   std::ostringstream oss;
   55|    591|   oss.imbue(std::locale::classic());
   56|    591|   fmt_detail::do_fmt(oss, format, args...);
   57|    591|   return oss.str();
   58|    591|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    591|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    591|   size_t i = 0;
   27|       |
   28|  10.3k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 10.3k, False: 0]
  ------------------
   29|  10.3k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 591, False: 9.71k]
  |  Branch (29:30): [True: 591, False: 0]
  |  Branch (29:59): [True: 591, False: 0]
  ------------------
   30|    591|         oss << val;
   31|    591|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  9.71k|      } else {
   33|  9.71k|         oss << format[i];
   34|  9.71k|      }
   35|       |
   36|  9.71k|      i += 1;
   37|  9.71k|   }
   38|    591|}
_ZN5Botan3fmtIJmmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|      3|std::string fmt(std::string_view format, const T&... args) {
   54|      3|   std::ostringstream oss;
   55|      3|   oss.imbue(std::locale::classic());
   56|      3|   fmt_detail::do_fmt(oss, format, args...);
   57|      3|   return oss.str();
   58|      3|}
_ZN5Botan10fmt_detail6do_fmtImJmEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|      3|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      3|   size_t i = 0;
   27|       |
   28|    135|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 135, False: 0]
  ------------------
   29|    135|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3, False: 132]
  |  Branch (29:30): [True: 3, False: 0]
  |  Branch (29:59): [True: 3, False: 0]
  ------------------
   30|      3|         oss << val;
   31|      3|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    132|      } else {
   33|    132|         oss << format[i];
   34|    132|      }
   35|       |
   36|    132|      i += 1;
   37|    132|   }
   38|      3|}
_ZN5Botan3fmtIJmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    406|std::string fmt(std::string_view format, const T&... args) {
   54|    406|   std::ostringstream oss;
   55|    406|   oss.imbue(std::locale::classic());
   56|    406|   fmt_detail::do_fmt(oss, format, args...);
   57|    406|   return oss.str();
   58|    406|}
_ZN5Botan3fmtIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|     20|std::string fmt(std::string_view format, const T&... args) {
   54|     20|   std::ostringstream oss;
   55|     20|   oss.imbue(std::locale::classic());
   56|     20|   fmt_detail::do_fmt(oss, format, args...);
   57|     20|   return oss.str();
   58|     20|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    563|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    563|   size_t i = 0;
   27|       |
   28|  3.09k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.09k, False: 0]
  ------------------
   29|  3.09k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 563, False: 2.53k]
  |  Branch (29:30): [True: 563, False: 0]
  |  Branch (29:59): [True: 563, False: 0]
  ------------------
   30|    563|         oss << val;
   31|    563|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  2.53k|      } else {
   33|  2.53k|         oss << format[i];
   34|  2.53k|      }
   35|       |
   36|  2.53k|      i += 1;
   37|  2.53k|   }
   38|    563|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|     89|std::string fmt(std::string_view format, const T&... args) {
   54|     89|   std::ostringstream oss;
   55|     89|   oss.imbue(std::locale::classic());
   56|     89|   fmt_detail::do_fmt(oss, format, args...);
   57|     89|   return oss.str();
   58|     89|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|     89|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     89|   size_t i = 0;
   27|       |
   28|     89|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 89, False: 0]
  ------------------
   29|     89|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 89, False: 0]
  |  Branch (29:30): [True: 89, False: 0]
  |  Branch (29:59): [True: 89, False: 0]
  ------------------
   30|     89|         oss << val;
   31|     89|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     89|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|     89|}
_ZN5Botan3fmtIJjjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    454|std::string fmt(std::string_view format, const T&... args) {
   54|    454|   std::ostringstream oss;
   55|    454|   oss.imbue(std::locale::classic());
   56|    454|   fmt_detail::do_fmt(oss, format, args...);
   57|    454|   return oss.str();
   58|    454|}
_ZN5Botan10fmt_detail6do_fmtIjJjEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    454|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    454|   size_t i = 0;
   27|       |
   28|  12.1k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 12.1k, False: 0]
  ------------------
   29|  12.1k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 454, False: 11.7k]
  |  Branch (29:30): [True: 454, False: 0]
  |  Branch (29:59): [True: 454, False: 0]
  ------------------
   30|    454|         oss << val;
   31|    454|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  11.7k|      } else {
   33|  11.7k|         oss << format[i];
   34|  11.7k|      }
   35|       |
   36|  11.7k|      i += 1;
   37|  11.7k|   }
   38|    454|}
_ZN5Botan3fmtIJtttEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|      9|std::string fmt(std::string_view format, const T&... args) {
   54|      9|   std::ostringstream oss;
   55|      9|   oss.imbue(std::locale::classic());
   56|      9|   fmt_detail::do_fmt(oss, format, args...);
   57|      9|   return oss.str();
   58|      9|}
_ZN5Botan10fmt_detail6do_fmtItJttEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|      9|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      9|   size_t i = 0;
   27|       |
   28|    144|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 144, False: 0]
  ------------------
   29|    144|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 9, False: 135]
  |  Branch (29:30): [True: 9, False: 0]
  |  Branch (29:59): [True: 9, False: 0]
  ------------------
   30|      9|         oss << val;
   31|      9|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    135|      } else {
   33|    135|         oss << format[i];
   34|    135|      }
   35|       |
   36|    135|      i += 1;
   37|    135|   }
   38|      9|}
_ZN5Botan10fmt_detail6do_fmtItJtEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|      9|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      9|   size_t i = 0;
   27|       |
   28|    171|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 171, False: 0]
  ------------------
   29|    171|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 9, False: 162]
  |  Branch (29:30): [True: 9, False: 0]
  |  Branch (29:59): [True: 9, False: 0]
  ------------------
   30|      9|         oss << val;
   31|      9|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    162|      } else {
   33|    162|         oss << format[i];
   34|    162|      }
   35|       |
   36|    162|      i += 1;
   37|    162|   }
   38|      9|}
_ZN5Botan10fmt_detail6do_fmtItJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|      9|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      9|   size_t i = 0;
   27|       |
   28|     45|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 45, False: 0]
  ------------------
   29|     45|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 9, False: 36]
  |  Branch (29:30): [True: 9, False: 0]
  |  Branch (29:59): [True: 9, False: 0]
  ------------------
   30|      9|         oss << val;
   31|      9|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     36|      } else {
   33|     36|         oss << format[i];
   34|     36|      }
   35|       |
   36|     36|      i += 1;
   37|     36|   }
   38|      9|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|     43|std::string fmt(std::string_view format, const T&... args) {
   54|     43|   std::ostringstream oss;
   55|     43|   oss.imbue(std::locale::classic());
   56|     43|   fmt_detail::do_fmt(oss, format, args...);
   57|     43|   return oss.str();
   58|     43|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|     43|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     43|   size_t i = 0;
   27|       |
   28|     43|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 43, False: 0]
  ------------------
   29|     43|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 43, False: 0]
  |  Branch (29:30): [True: 43, False: 0]
  |  Branch (29:59): [True: 43, False: 0]
  ------------------
   30|     43|         oss << val;
   31|     43|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     43|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|     43|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|     43|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     43|   size_t i = 0;
   27|       |
   28|    215|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 215, False: 0]
  ------------------
   29|    215|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 43, False: 172]
  |  Branch (29:30): [True: 43, False: 0]
  |  Branch (29:59): [True: 43, False: 0]
  ------------------
   30|     43|         oss << val;
   31|     43|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    172|      } else {
   33|    172|         oss << format[i];
   34|    172|      }
   35|       |
   36|    172|      i += 1;
   37|    172|   }
   38|     43|}

_ZN5Botan11checked_mulITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   46|  36.0k|constexpr inline std::optional<T> checked_mul(T a, T b) {
   47|       |   // Multiplication by 1U is a hack to work around C's insane
   48|       |   // integer promotion rules.
   49|       |   // https://stackoverflow.com/questions/24795651
   50|  36.0k|   const T r = (1U * a) * b;
   51|       |   // If a == 0 then the multiply certainly did not overflow
   52|       |   // Otherwise r / a == b unless overflow occurred
   53|  36.0k|   if(a != 0 && r / a != b) {
  ------------------
  |  Branch (53:7): [True: 36.0k, False: 0]
  |  Branch (53:17): [True: 0, False: 36.0k]
  ------------------
   54|      0|      return {};
   55|      0|   }
   56|  36.0k|   return r;
   57|  36.0k|}
_ZN5Botan15checked_cast_toItmQaasr3stdE8integralINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEsr3stdE8integralINS2_Iu14__remove_cvrefIT0_EE4typeEEEES3_S7_:
  104|     27|constexpr RT checked_cast_to(AT i) {
  105|     27|   return checked_cast_to_or_throw<RT, Internal_Error>(i, "Error during integer conversion");
  106|     27|}
_ZN5Botan24checked_cast_to_or_throwItNS_14Internal_ErrorEmQaasr3stdE8integralINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEsr3stdE8integralINS3_Iu14__remove_cvrefIT1_EE4typeEEEES4_S8_NSt3__117basic_string_viewIcNSC_11char_traitsIcEEEE:
   91|     27|constexpr RT checked_cast_to_or_throw(AT i, std::string_view error_msg_on_fail) {
   92|     27|   const auto unwrapped_input = unwrap_strong_type(i);
   93|       |
   94|     27|   const auto unwrapped_result = static_cast<strong_type_wrapped_type<RT>>(unwrapped_input);
   95|     27|   if(unwrapped_input != static_cast<strong_type_wrapped_type<AT>>(unwrapped_result)) [[unlikely]] {
  ------------------
  |  Branch (95:7): [True: 0, False: 27]
  ------------------
   96|      0|      throw ExceptionType(error_msg_on_fail);
   97|      0|   }
   98|       |
   99|     27|   return wrap_strong_type<RT>(unwrapped_result);
  100|     27|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEjEENS1_8optionalIT_EES3_S3_:
   19|  3.42k|constexpr inline std::optional<T> checked_add(T a, T b) {
   20|  3.42k|   const T r = a + b;
   21|  3.42k|   if(r < a || r < b) {
  ------------------
  |  Branch (21:7): [True: 0, False: 3.42k]
  |  Branch (21:16): [True: 0, False: 3.42k]
  ------------------
   22|      0|      return {};
   23|      0|   }
   24|  3.42k|   return r;
   25|  3.42k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|  5.25k|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|  5.25k|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 5.25k, False: 0]
  ------------------
   39|  5.25k|      return checked_add(r.value(), rest...);
   40|  5.25k|   } else {
   41|      0|      return {};
   42|      0|   }
   43|  5.25k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   19|  16.4k|constexpr inline std::optional<T> checked_add(T a, T b) {
   20|  16.4k|   const T r = a + b;
   21|  16.4k|   if(r < a || r < b) {
  ------------------
  |  Branch (21:7): [True: 0, False: 16.4k]
  |  Branch (21:16): [True: 0, False: 16.4k]
  ------------------
   22|      0|      return {};
   23|      0|   }
   24|  16.4k|   return r;
   25|  16.4k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|  5.25k|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|  5.25k|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 5.25k, False: 0]
  ------------------
   39|  5.25k|      return checked_add(r.value(), rest...);
   40|  5.25k|   } else {
   41|      0|      return {};
   42|      0|   }
   43|  5.25k|}
_ZN5Botan13swar_in_rangeITkNSt3__117unsigned_integralEmEET_S2_S2_S2_:
  144|  50.4k|constexpr T swar_in_range(T v, T lower, T upper) {
  145|       |   // The constant 0x808080... as a T
  146|  50.4k|   constexpr T hi1 = (static_cast<T>(-1) / 255) << 7;
  147|       |   // The constant 0x7F7F7F... as a T
  148|  50.4k|   constexpr T lo7 = ~hi1;
  149|       |
  150|  50.4k|   const T sub = ((v | hi1) - (lower & lo7)) ^ ((v ^ (~lower)) & hi1);
  151|  50.4k|   const T a_lo = sub & lo7;
  152|  50.4k|   const T a_hi = sub & hi1;
  153|  50.4k|   return (lo7 - a_lo + upper) & hi1 & ~a_hi;
  154|  50.4k|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmmmmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|    176|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|    176|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 176, False: 0]
  ------------------
   39|    176|      return checked_add(r.value(), rest...);
   40|    176|   } else {
   41|      0|      return {};
   42|      0|   }
   43|    176|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmmmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|    176|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|    176|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 176, False: 0]
  ------------------
   39|    176|      return checked_add(r.value(), rest...);
   40|    176|   } else {
   41|      0|      return {};
   42|      0|   }
   43|    176|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|    176|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|    176|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 176, False: 0]
  ------------------
   39|    176|      return checked_add(r.value(), rest...);
   40|    176|   } else {
   41|      0|      return {};
   42|      0|   }
   43|    176|}
_ZN5Botan11checked_addITkNSt3__117unsigned_integralEmTpTkNS1_17unsigned_integralEJmmmEQ10all_same_vIT_DpT0_EEENS1_8optionalIS2_EES2_S2_S4_:
   37|    176|constexpr inline std::optional<T> checked_add(T a, T b, Ts... rest) {
   38|    176|   if(auto r = checked_add(a, b)) {
  ------------------
  |  Branch (38:12): [True: 176, False: 0]
  ------------------
   39|    176|      return checked_add(r.value(), rest...);
   40|    176|   } else {
   41|      0|      return {};
   42|      0|   }
   43|    176|}

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

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

_ZN5Botan10bigint_cmpITkNS_8WordTypeEmEEiPKT_mS3_m:
  462|  6.45k|inline constexpr int32_t bigint_cmp(const W x[], size_t x_size, const W y[], size_t y_size) {
  463|  6.45k|   static_assert(sizeof(W) >= sizeof(uint32_t), "Size assumption");
  464|       |
  465|  6.45k|   const W LT = static_cast<W>(-1);
  466|  6.45k|   const W EQ = 0;
  467|  6.45k|   const W GT = 1;
  468|       |
  469|  6.45k|   const size_t common_elems = std::min(x_size, y_size);
  470|       |
  471|  6.45k|   W result = EQ;  // until found otherwise
  472|       |
  473|  12.5k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (473:22): [True: 6.12k, False: 6.45k]
  ------------------
  474|  6.12k|      const auto is_eq = CT::Mask<W>::is_equal(x[i], y[i]);
  475|  6.12k|      const auto is_lt = CT::Mask<W>::is_lt(x[i], y[i]);
  476|       |
  477|  6.12k|      result = is_eq.select(result, is_lt.select(LT, GT));
  478|  6.12k|   }
  479|       |
  480|  6.45k|   if(x_size < y_size) {
  ------------------
  |  Branch (480:7): [True: 330, False: 6.12k]
  ------------------
  481|    330|      W mask = 0;
  482|    660|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (482:30): [True: 330, False: 330]
  ------------------
  483|    330|         mask |= y[i];
  484|    330|      }
  485|       |
  486|       |      // If any bits were set in high part of y, then x < y
  487|    330|      result = CT::Mask<W>::is_zero(mask).select(result, LT);
  488|  6.12k|   } else if(y_size < x_size) {
  ------------------
  |  Branch (488:14): [True: 0, False: 6.12k]
  ------------------
  489|      0|      W mask = 0;
  490|      0|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (490:30): [True: 0, False: 0]
  ------------------
  491|      0|         mask |= x[i];
  492|      0|      }
  493|       |
  494|       |      // If any bits were set in high part of x, then x > y
  495|      0|      result = CT::Mask<W>::is_zero(mask).select(result, GT);
  496|      0|   }
  497|       |
  498|  6.45k|   CT::unpoison(result);
  499|  6.45k|   BOTAN_DEBUG_ASSERT(result == LT || result == GT || result == EQ);
  ------------------
  |  |  137|  6.45k|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|  6.45k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 6.45k]
  |  |  ------------------
  ------------------
  500|  6.45k|   return static_cast<int32_t>(result);
  501|  6.45k|}

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

_ZN5Botan17is_sub_element_ofERKNS_3OIDESt16initializer_listIjE:
   22|  21.5k|inline std::optional<uint32_t> is_sub_element_of(const OID& oid, std::initializer_list<uint32_t> prefix) {
   23|  21.5k|   const auto& c = oid.get_components();
   24|       |
   25|  21.5k|   if(c.size() != prefix.size() + 1) {
  ------------------
  |  Branch (25:7): [True: 10.0k, False: 11.5k]
  ------------------
   26|  10.0k|      return {};
   27|  10.0k|   }
   28|       |
   29|  11.5k|   if(!std::equal(c.begin(), c.end() - 1, prefix.begin(), prefix.end())) {
  ------------------
  |  Branch (29:7): [True: 1.36k, False: 10.1k]
  ------------------
   30|  1.36k|      return {};
   31|  1.36k|   }
   32|       |
   33|  10.1k|   return c[c.size() - 1];
   34|  11.5k|}

_ZN5Botan11ASN1_ObjectD2Ev:
  168|   216k|      virtual ~ASN1_Object() = default;
_ZNK5Botan14ASN1_BitString5bytesEv:
  206|  5.92k|      std::span<const uint8_t> bytes() const { return std::span{m_bytes}; }
_ZNK5Botan14ASN1_BitString11unused_bitsEv:
  211|  2.96k|      size_t unused_bits() const { return m_unused_bits; }
_ZNK5Botan10BER_Object6is_setEv:
  267|   395k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  272|   166k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  277|   168k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  282|   187k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  287|  33.4k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  292|  17.0k|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  298|   429k|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  303|  1.13M|      size_t length() const { return m_value.size(); }
_ZNK5Botan10BER_Object4dataEv:
  308|  63.2k|      std::span<const uint8_t> data() const { return std::span{m_value}; }
_ZN5Botan10BER_Object12mutable_bitsEm:
  344|   141k|      uint8_t* mutable_bits(size_t length) {
  345|   141k|         m_value.resize(length);
  346|   141k|         return m_value.data();
  347|   141k|      }
_ZNK5Botan3OID5emptyEv:
  468|    960|      bool empty() const { return m_id.empty(); }
_ZNK5Botan3OID9has_valueEv:
  474|    960|      bool has_value() const { return !empty(); }
_ZNK5Botan3OIDeqERKS0_:
  510|  12.4k|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan3OID14get_componentsEv:
  530|  82.1k|      const std::vector<uint32_t>& get_components() const {
  531|  82.1k|         return m_id;
  532|  82.1k|      }
_ZNK5Botan11ASN1_String5valueEv:
  590|  3.91k|      const std::string& value() const { return m_utf8_str; }
_ZN5BotanltERKNS_11ASN1_StringES2_:
  612|    243|      friend bool operator<(const ASN1_String& a, const ASN1_String& b) { return a.value() < b.value(); }
_ZNK5Botan19AlgorithmIdentifier3oidEv:
  688|  5.35k|      const OID& oid() const { return m_oid; }
_ZNK5Botan19AlgorithmIdentifier10parametersEv:
  693|  5.24k|      const std::vector<uint8_t>& parameters() const { return m_parameters; }
_ZNK5Botan19AlgorithmIdentifier20parameters_are_emptyEv:
  715|  5.87k|      bool parameters_are_empty() const { return m_parameters.empty(); }
_ZNK5Botan19AlgorithmIdentifier28parameters_are_null_or_emptyEv:
  720|  5.87k|      bool parameters_are_null_or_empty() const { return parameters_are_empty() || parameters_are_null(); }
  ------------------
  |  Branch (720:58): [True: 2.89k, False: 2.97k]
  |  Branch (720:84): [True: 2.62k, False: 355]
  ------------------
_ZN5BotanorENS_10ASN1_ClassES0_:
   91|  74.1k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   92|  74.1k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   93|  74.1k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   98|   166k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   99|   166k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
  100|   166k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
  105|  25.1k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
  106|  25.1k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
  107|  25.1k|}
_ZN5BotanneERKNS_3OIDES2_:
  561|  1.22k|inline bool operator!=(const OID& a, const OID& b) {
  562|  1.22k|   return !(a == b);
  563|  1.22k|}
_ZNKSt3__14hashIN5Botan3OIDEEclERKS2_:
  761|      4|      size_t operator()(const Botan::OID& oid) const noexcept { return static_cast<size_t>(oid.hash_code()); }
_ZN5Botan11ASN1_ObjectC2Ev:
  146|   127k|      ASN1_Object() = default;
_ZN5Botan19AlgorithmIdentifierC2Ev:
  655|  6.62k|      AlgorithmIdentifier() = default;
_ZN5Botan3OIDC2Ev:
  423|  26.5k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectC2EOS0_:
  161|  53.7k|      ASN1_Object(ASN1_Object&&) = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  259|  58.7k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  151|  35.8k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan11ASN1_ObjectaSEOS0_:
  166|  20.5k|      ASN1_Object& operator=(ASN1_Object&&) = default;
_ZN5Botan14ASN1_BitStringC2Ev:
  179|  3.06k|      ASN1_BitString() = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  249|  77.0k|      BER_Object(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectC2Ev:
  239|   241k|      BER_Object() = default;
_ZN5Botan10BER_ObjectC2ERKS0_:
  244|    345|      BER_Object(const BER_Object& other) = default;

_ZN5Botan9ASN1_TimeC2Ev:
   42|  14.6k|      ASN1_Time() = default;

_ZN5Botan13ignore_paramsIJPKmmEEEvDpRKT_:
  149|  72.6k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}
_ZN5Botan13ignore_paramsIJjEEEvDpRKT_:
  149|  17.2k|constexpr void ignore_params([[maybe_unused]] const T&... args) {}

_ZN5Botan11BER_Decoder6Limits3DEREv:
   44|  13.2k|            static Limits DER() { return Limits(false, 0, false, DefaultMaxObjectSize, false); }
_ZN5Botan11BER_Decoder6LimitsC2EbmbNSt3__18optionalImEEb:
  135|  13.2k|                  m_allow_ber(allow_ber),
  136|  13.2k|                  m_max_nested_indef(max_nested_indef),
  137|  13.2k|                  m_allow_standalone_eoc(allow_standalone_eoc),
  138|  13.2k|                  m_max_object_size(max_object_size),
  139|  13.2k|                  m_reject_default_value_encoding(reject_default_value_encoding) {}
_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  548|  2.94k|      BER_Decoder& decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value = T()) {
  549|  2.94k|         std::optional<T> optval;
  550|  2.94k|         this->decode_optional(optval, type_tag, class_tag);
  551|  2.94k|         out = optval ? *optval : default_value;
  ------------------
  |  Branch (551:16): [True: 2.62k, False: 321]
  ------------------
  552|  2.94k|         return (*this);
  553|  2.94k|      }
_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RNSt3__18optionalIT_EENS_9ASN1_TypeENS_10ASN1_ClassE:
  840|  2.94k|BER_Decoder& BER_Decoder::decode_optional(std::optional<T>& optval, ASN1_Type type_tag, ASN1_Class class_tag) {
  841|  2.94k|   BER_Object obj = get_next_object();
  842|       |
  843|  2.94k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (843:7): [True: 2.75k, False: 193]
  ------------------
  844|  2.75k|      T out{};
  845|  2.75k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (845:10): [True: 0, False: 2.75k]
  ------------------
  846|      0|         BER_Decoder(obj, m_limits).decode(out).verify_end();
  847|  2.75k|      } else {
  848|  2.75k|         this->push_back(std::move(obj));
  849|       |         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
  850|       |            // Object types check the tag in decode_from; a re-tagging
  851|       |            // implicit override of an object is not supported here
  852|       |            this->decode(out);
  853|  2.75k|         } else {
  854|  2.75k|            this->decode(out, type_tag, class_tag);
  855|  2.75k|         }
  856|  2.75k|      }
  857|  2.75k|      optval = std::move(out);
  858|  2.75k|   } else {
  859|    193|      this->push_back(std::move(obj));
  860|    193|      optval = std::nullopt;
  861|    193|   }
  862|       |
  863|  2.94k|   return (*this);
  864|  2.94k|}
_ZNK5Botan11BER_Decoder6limitsEv:
  199|  64.5k|      Limits limits() const { return m_limits; }
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectENS0_6LimitsE:
  169|  4.09k|            BER_Decoder(obj.data(), limits) {}
_ZNK5Botan11BER_Decoder6Limits18allow_ber_encodingEv:
   58|   361k|            bool allow_ber_encoding() const { return m_allow_ber; }
_ZNK5Botan11BER_Decoder6Limits20require_der_encodingEv:
   63|   217k|            bool require_der_encoding() const { return !allow_ber_encoding(); }
_ZNK5Botan11BER_Decoder6Limits15max_object_sizeEv:
   82|   142k|            std::optional<size_t> max_object_size() const { return m_max_object_size; }
_ZN5Botan11BER_Decoder14start_sequenceEv:
  277|  55.3k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9start_setEv:
  283|  3.99k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder22start_context_specificEj:
  292|     41|      BER_Decoder start_context_specific(uint32_t tag) {
  293|     41|         return start_cons(ASN1_Type(tag), ASN1_Class::ContextSpecific);
  294|     41|      }
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  369|  8.83k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__16vectorIhNS2_9allocatorIhEEEEQsr8conceptsE20ordinary_byte_vectorINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEEERS0_RS9_NS_9ASN1_TypeE:
  388|  13.9k|      BER_Decoder& decode(T& out, ASN1_Type real_type) {
  389|  13.9k|         return decode(unwrap_strong_type(out), real_type, real_type, ASN1_Class::Universal);
  390|  13.9k|      }
_ZN5Botan11BER_Decoder6decodeINSt3__16vectorIhNS2_9allocatorIhEEEEQsr8conceptsE20ordinary_byte_vectorINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEEERS0_RS9_NS_9ASN1_TypeESF_NS_10ASN1_ClassE:
  405|  13.9k|                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  406|  13.9k|         return decode_into_byte_vector(unwrap_strong_type(v), real_type, type_tag, class_tag);
  407|  13.9k|      }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__16vectorIhNS2_9allocatorIhEEEEQsr8conceptsE20ordinary_byte_vectorINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEEERS0_RS9_:
  341|  12.1k|      BER_Decoder& raw_bytes(T& out_wrapped) {
  342|  12.1k|         auto& out = unwrap_strong_type(out_wrapped);
  343|  12.1k|         out.clear();
  344|  12.1k|         uint8_t buf[64];
  345|  48.9k|         while(const size_t got = this->read_bytes(std::span{buf})) {
  ------------------
  |  Branch (345:29): [True: 36.7k, False: 12.1k]
  ------------------
  346|  36.7k|            out.insert(out.end(), buf, buf + got);
  347|  36.7k|         }
  348|  12.1k|         return (*this);
  349|  12.1k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  548|  13.9k|      BER_Decoder& decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value = T()) {
  549|  13.9k|         std::optional<T> optval;
  550|  13.9k|         this->decode_optional(optval, type_tag, class_tag);
  551|  13.9k|         out = optval ? *optval : default_value;
  ------------------
  |  Branch (551:16): [True: 3, False: 13.9k]
  ------------------
  552|  13.9k|         return (*this);
  553|  13.9k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RNSt3__18optionalIT_EENS_9ASN1_TypeENS_10ASN1_ClassE:
  840|  13.9k|BER_Decoder& BER_Decoder::decode_optional(std::optional<T>& optval, ASN1_Type type_tag, ASN1_Class class_tag) {
  841|  13.9k|   BER_Object obj = get_next_object();
  842|       |
  843|  13.9k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (843:7): [True: 8, False: 13.9k]
  ------------------
  844|      8|      T out{};
  845|      8|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (845:10): [True: 0, False: 8]
  ------------------
  846|      0|         BER_Decoder(obj, m_limits).decode(out).verify_end();
  847|      8|      } else {
  848|      8|         this->push_back(std::move(obj));
  849|       |         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
  850|       |            // Object types check the tag in decode_from; a re-tagging
  851|       |            // implicit override of an object is not supported here
  852|       |            this->decode(out);
  853|      8|         } else {
  854|      8|            this->decode(out, type_tag, class_tag);
  855|      8|         }
  856|      8|      }
  857|      8|      optval = std::move(out);
  858|  13.9k|   } else {
  859|  13.9k|      this->push_back(std::move(obj));
  860|  13.9k|      optval = std::nullopt;
  861|  13.9k|   }
  862|       |
  863|  13.9k|   return (*this);
  864|  13.9k|}
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_0EERS0_jNS_10ASN1_ClassEOT_:
  621|    103|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|    103|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 16, False: 87]
  ------------------
  623|     16|            std::forward<F>(fn)(*this);
  624|     16|         }
  625|    103|         return (*this);
  626|    103|      }
_ZN5Botan11BER_Decoder15decode_implicitINS_15AlternativeNameEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassES6_S7_:
  658|     39|         T& out, ASN1_Type type_tag, ASN1_Class class_tag, ASN1_Type real_type, ASN1_Class real_class) {
  659|     39|         BER_Object obj = get_next_object();
  660|     39|         obj.assert_is_a(type_tag, class_tag);
  661|     39|         return decode_implicit(std::move(obj), out, real_type, real_class);
  662|     39|      }
_ZN5Botan11BER_Decoder15decode_implicitINS_15AlternativeNameEEERS0_NS_10BER_ObjectERT_NS_9ASN1_TypeENS_10ASN1_ClassE:
  635|     39|      BER_Decoder& decode_implicit(BER_Object obj, T& out, ASN1_Type real_type, ASN1_Class real_class) {
  636|     39|         obj.set_tagging(real_type, real_class);
  637|     39|         push_back(std::move(obj));
  638|     39|         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
  639|       |            // The object was re-tagged above; decode_from checks the real tag itself
  640|     39|            return decode(out);
  641|       |         } else {
  642|       |            return decode(out, real_type, real_class);
  643|       |         }
  644|     39|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_1EERS0_jNS_10ASN1_ClassEOT_:
  621|     79|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|     79|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 6, False: 73]
  ------------------
  623|      6|            std::forward<F>(fn)(*this);
  624|      6|         }
  625|     79|         return (*this);
  626|     79|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_2EERS0_jNS_10ASN1_ClassEOT_:
  621|     71|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|     71|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 14, False: 57]
  ------------------
  623|     14|            std::forward<F>(fn)(*this);
  624|     14|         }
  625|     71|         return (*this);
  626|     71|      }
_ZN5Botan11BER_Decoder15decode_implicitINS_18X509_Serial_NumberEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassES6_S7_:
  658|     14|         T& out, ASN1_Type type_tag, ASN1_Class class_tag, ASN1_Type real_type, ASN1_Class real_class) {
  659|     14|         BER_Object obj = get_next_object();
  660|     14|         obj.assert_is_a(type_tag, class_tag);
  661|     14|         return decode_implicit(std::move(obj), out, real_type, real_class);
  662|     14|      }
_ZN5Botan11BER_Decoder15decode_implicitINS_18X509_Serial_NumberEEERS0_NS_10BER_ObjectERT_NS_9ASN1_TypeENS_10ASN1_ClassE:
  635|     14|      BER_Decoder& decode_implicit(BER_Object obj, T& out, ASN1_Type real_type, ASN1_Class real_class) {
  636|     14|         obj.set_tagging(real_type, real_class);
  637|     14|         push_back(std::move(obj));
  638|     14|         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
  639|       |            // The object was re-tagged above; decode_from checks the real tag itself
  640|     14|            return decode(out);
  641|       |         } else {
  642|       |            return decode(out, real_type, real_class);
  643|       |         }
  644|     14|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_1EERS0_jNS_10ASN1_ClassEOT_:
  621|    199|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|    199|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 41, False: 158]
  ------------------
  623|     41|            std::forward<F>(fn)(*this);
  624|     41|         }
  625|    199|         return (*this);
  626|    199|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_2EERS0_jNS_10ASN1_ClassEOT_:
  621|    154|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|    154|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 21, False: 133]
  ------------------
  623|     21|            std::forward<F>(fn)(*this);
  624|     21|         }
  625|    154|         return (*this);
  626|    154|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_3EERS0_jNS_10ASN1_ClassEOT_:
  621|    143|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|    143|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 14, False: 129]
  ------------------
  623|     14|            std::forward<F>(fn)(*this);
  624|     14|         }
  625|    143|         return (*this);
  626|    143|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_4EERS0_jNS_10ASN1_ClassEOT_:
  621|    132|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|    132|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 46, False: 86]
  ------------------
  623|     46|            std::forward<F>(fn)(*this);
  624|     46|         }
  625|    132|         return (*this);
  626|    132|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_5EERS0_jNS_10ASN1_ClassEOT_:
  621|     94|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|     94|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 6, False: 88]
  ------------------
  623|      6|            std::forward<F>(fn)(*this);
  624|      6|         }
  625|     94|         return (*this);
  626|     94|      }
x509_ext.cpp:_ZN5Botan11BER_Decoder21decode_optional_fieldIZNS_14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS4_9allocatorIhEEEEE3$_6EERS0_jNS_10ASN1_ClassEOT_:
  621|     79|      BER_Decoder& decode_optional_field(uint32_t tag_no, ASN1_Class class_tag, F&& fn) {
  622|     79|         if(peek_next_object().is_a(tag_no, class_tag)) {
  ------------------
  |  Branch (622:13): [True: 4, False: 75]
  ------------------
  623|      4|            std::forward<F>(fn)(*this);
  624|      4|         }
  625|     79|         return (*this);
  626|     79|      }
_ZN5Botan11BER_Decoder30decode_octet_aligned_bitstringINSt3__16vectorIhNS2_9allocatorIhEEEEQsr8conceptsE20ordinary_byte_vectorINS_6detail19wrapped_type_helperIu14__remove_cvrefIT_EE4typeEEEERS0_RS9_NS_9ASN1_TypeENS_10ASN1_ClassE:
  458|  3.02k|                                                  ASN1_Class class_tag = ASN1_Class::Universal) {
  459|  3.02k|         auto& out = unwrap_strong_type(out_wrapped);
  460|  3.02k|         ASN1_BitString bits;
  461|  3.02k|         decode_bitstring(bits, type_tag, class_tag);
  462|       |
  463|  3.02k|         if(bits.unused_bits() != 0) {
  ------------------
  |  Branch (463:13): [True: 5, False: 3.01k]
  ------------------
  464|      5|            throw Decoding_Error("Expected octet-aligned BIT STRING");
  465|      5|         }
  466|       |
  467|  3.01k|         out.assign(bits.bytes().begin(), bits.bytes().end());
  468|  3.01k|         return (*this);
  469|  3.02k|      }
_ZN5Botan11BER_Decoder15decode_implicitINS_3OIDEEERS0_NS_10BER_ObjectERT_NS_9ASN1_TypeENS_10ASN1_ClassE:
  635|    345|      BER_Decoder& decode_implicit(BER_Object obj, T& out, ASN1_Type real_type, ASN1_Class real_class) {
  636|    345|         obj.set_tagging(real_type, real_class);
  637|    345|         push_back(std::move(obj));
  638|    345|         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
  639|       |            // The object was re-tagged above; decode_from checks the real tag itself
  640|    345|            return decode(out);
  641|       |         } else {
  642|       |            return decode(out, real_type, real_class);
  643|       |         }
  644|    345|      }

_ZN5Botan6BigIntC2ERKS0_:
   88|     13|      BigInt(const BigInt& other) = default;
_ZN5Botan6BigIntD2Ev:
  185|  29.2k|      ~BigInt() { _const_time_unpoison(); }
_ZNK5Botan6BigInt6signumEv:
  493|  21.6k|      int signum() const {
  494|  21.6k|         if(sig_words() == 0) {
  ------------------
  |  Branch (494:13): [True: 403, False: 21.2k]
  ------------------
  495|    403|            return 0;
  496|    403|         }
  497|  21.2k|         return (sign() == Negative) ? -1 : 1;
  ------------------
  |  Branch (497:17): [True: 2.06k, False: 19.1k]
  ------------------
  498|  21.6k|      }
_ZNK5Botan6BigInt9sig_wordsEv:
  687|  77.2k|      size_t sig_words() const { return m_data.sig_words(); }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
 1163|  77.2k|            size_t sig_words() const {
 1164|  77.2k|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (1164:19): [True: 14.1k, False: 63.1k]
  ------------------
 1165|  14.1k|                  m_sig_words = calc_sig_words();
 1166|  14.1k|               }
 1167|  77.2k|               return m_sig_words;
 1168|  77.2k|            }
_ZNK5Botan6BigInt4signEv:
  641|  21.2k|      Sign sign() const { return (m_signedness); }
_ZN5Botan6BigInt4zeroEv:
   50|     52|      static BigInt zero() { return BigInt(); }
_ZN5Botan6BigIntaSEOS0_:
  190|  13.2k|      BigInt& operator=(BigInt&& other) noexcept {
  191|  13.2k|         if(this != &other) {
  ------------------
  |  Branch (191:13): [True: 13.2k, False: 0]
  ------------------
  192|  13.2k|            this->swap(other);
  193|  13.2k|         }
  194|       |
  195|  13.2k|         return (*this);
  196|  13.2k|      }
_ZN5Botan6BigInt4swapERS0_:
  207|  13.2k|      void swap(BigInt& other) noexcept {
  208|  13.2k|         m_data.swap(other.m_data);
  209|  13.2k|         std::swap(m_signedness, other.m_signedness);
  210|  13.2k|      }
_ZN5Botan6BigInt5clearEv:
  441|  14.1k|      void clear() {
  442|  14.1k|         m_data.set_to_zero();
  443|  14.1k|         m_signedness = Positive;
  444|  14.1k|      }
_ZNK5Botan6BigInt7is_zeroEv:
  510|  2.03k|      bool is_zero() const { return sig_words() == 0; }
_ZNK5Botan6BigInt7word_atEm:
  601|  53.3k|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  663|  2.03k|      void set_sign(Sign sign) {
  664|  2.03k|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (664:13): [True: 2.03k, False: 0]
  |  Branch (664:33): [True: 0, False: 2.03k]
  ------------------
  665|      0|            sign = Positive;
  666|      0|         }
  667|       |
  668|  2.03k|         m_signedness = sign;
  669|  2.03k|      }
_ZNK5Botan6BigInt5_dataEv:
 1033|  6.45k|      const word* _data() const { return m_data.const_data(); }
_ZN5Botan6BigInt18_assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
 1044|  14.1k|      void _assign_from_bytes(std::span<const uint8_t> bytes) { assign_from_bytes(bytes); }
_ZNK5Botan6BigInt4Data10const_dataEv:
 1088|  35.7k|            const word* const_data() const { return m_reg.data(); }
_ZNK5Botan6BigInt4Data11get_word_atEm:
 1099|  53.3k|            word get_word_at(size_t n) const {
 1100|  53.3k|               if(n < m_reg.size()) {
  ------------------
  |  Branch (1100:19): [True: 53.3k, False: 3]
  ------------------
 1101|  53.3k|                  return m_reg[n];
 1102|  53.3k|               }
 1103|      3|               return 0;
 1104|  53.3k|            }
_ZNK5Botan6BigInt4Data4sizeEv:
 1136|  29.2k|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERS1_:
 1151|  13.2k|            void swap(Data& other) noexcept {
 1152|  13.2k|               m_reg.swap(other.m_reg);
 1153|  13.2k|               std::swap(m_sig_words, other.m_sig_words);
 1154|  13.2k|            }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
 1156|  14.1k|            void swap(secure_vector<word>& reg) noexcept {
 1157|  14.1k|               m_reg.swap(reg);
 1158|  14.1k|               invalidate_sig_words();
 1159|  14.1k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
 1161|  14.1k|            void invalidate_sig_words() const noexcept { m_sig_words = sig_words_npos; }
_ZN5BotaneqERKNS_6BigIntEm:
 1373|  8.76k|inline bool operator==(const BigInt& a, word b) {
 1374|  8.76k|   return (a.cmp_word(b) == 0);
 1375|  8.76k|}
_ZNK5Botan6BigInt9serializeINSt3__16vectorIhNS2_9allocatorIhEEEEEET_m:
  790|  9.34k|      T serialize(size_t len) const {
  791|       |         // TODO this supports std::vector and secure_vector
  792|       |         // it would be nice if this also could work with std::array as in
  793|       |         //   bn.serialize_to<std::array<uint8_t, 32>>(32);
  794|  9.34k|         T out(len);
  795|  9.34k|         this->serialize_to(out);
  796|  9.34k|         return out;
  797|  9.34k|      }
_ZN5Botan6BigIntC2Ev:
   45|  29.2k|      BigInt() = default;
_ZNK5Botan6BigInt9serializeINSt3__16vectorIhNS2_9allocatorIhEEEEEET_v:
  803|    904|      T serialize() const {
  804|    904|         return serialize<T>(this->bytes());
  805|    904|      }

_ZN5Botan17DataSource_MemoryC2ENSt3__14spanIKhLm18446744073709551615EEE:
  181|  20.6k|      explicit DataSource_Memory(std::span<const uint8_t> in) : m_offset(0) {
  182|       |         // Guard against forming a range from a null pointer (eg an empty span)
  183|  20.6k|         if(!in.empty()) {
  ------------------
  |  Branch (183:13): [True: 19.2k, False: 1.38k]
  ------------------
  184|  19.2k|            m_source.assign(in.begin(), in.end());
  185|  19.2k|         }
  186|  20.6k|      }
_ZN5Botan10DataSourceC2Ev:
  107|  83.1k|      DataSource() = default;
_ZN5Botan10DataSourceD2Ev:
  109|  78.2k|      virtual ~DataSource() = default;
_ZN5Botan17DataSource_MemoryC2ENSt3__16vectorIhNS_16secure_allocatorIhEEEE:
  175|     85|      explicit DataSource_Memory(secure_vector<uint8_t> in) : m_source(std::move(in)), m_offset(0) {}

_ZN5Botan11DER_Encoder12DER_SequenceD2Ev:
  504|    729|            ~DER_Sequence() = default;
_ZN5Botan11DER_Encoder14start_sequenceEv:
   86|    243|      DER_Encoder& start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassENSt3__14spanIKhLm18446744073709551615EEE:
  410|  4.45k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, std::span<const uint8_t> rep) {
  411|  4.45k|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  412|  4.45k|      }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  421|  3.42k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const std::vector<uint8_t>& rep) {
  422|  3.42k|         return add_object(type_tag, class_tag, std::span{rep});
  423|  3.42k|      }
_ZN5Botan11DER_Encoder12DER_SequenceC2EOS1_:
  487|    486|                  m_type_tag(seq.m_type_tag),
  488|    486|                  m_class_tag(seq.m_class_tag),
  489|    486|                  m_sort_contents(seq.m_sort_contents),
  490|    486|                  m_contents(std::move(seq.m_contents)),
  491|    486|                  m_set_contents(std::move(seq.m_set_contents)) {}

_ZN5Botan7DNSNameC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  101|  2.06k|      explicit DNSName(std::string canonical) : m_name(std::move(canonical)) {}
_ZNK5Botan7DNSNamessERKS0_:
   84|  6.65k|      auto operator<=>(const DNSName&) const = default;

_ZN5Botan12EmailAddressC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7DNSNameE:
   69|    488|            m_local_part(std::move(local_part)), m_domain(std::move(domain)) {}
_ZNK5Botan12EmailAddressssERKS0_:
   59|  2.53k|      auto operator<=>(const EmailAddress&) const = default;

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

_ZN5Botan11IPv4AddressC2Ej:
   29|    860|      explicit IPv4Address(uint32_t ip) : m_ip(ip) {}
_ZNK5Botan11IPv4AddressssERKS0_:
   73|  5.02k|      auto operator<=>(const IPv4Address&) const = default;

_ZN5Botan11IPv6AddressC2ENSt3__15arrayIhLm16EEE:
   37|     26|      explicit IPv6Address(std::array<uint8_t, 16> ip) : m_ip(ip) {}
_ZNK5Botan11IPv6AddressssERKS0_:
   73|    406|      auto operator<=>(const IPv6Address&) const = default;

_ZN5Botan11clear_bytesEPvm:
  101|  14.3k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  102|  14.3k|   if(bytes > 0) {
  ------------------
  |  Branch (102:7): [True: 150, False: 14.1k]
  ------------------
  103|    150|      std::memset(ptr, 0, bytes);
  104|    150|   }
  105|  14.3k|}
_ZN5Botan8copy_memIhQsr3stdE12is_trivial_vIu7__decayIT_EEEEvPS1_PKS1_m:
  144|   654k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  145|   654k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |  110|   654k|   do {                                                                                          \
  |  |  111|   654k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                              \
  |  |  112|  1.27M|      if((expr1) && !(expr2)) {                                                                  \
  |  |  ------------------
  |  |  |  Branch (112:10): [True: 638k, False: 16.4k]
  |  |  |  Branch (112:23): [True: 638k, False: 0]
  |  |  |  Branch (112:23): [True: 638k, False: 0]
  |  |  ------------------
  |  |  113|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                     \
  |  |  114|      0|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |  115|      0|      }                                                                                          \
  |  |  116|   654k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (116:12): [Folded, False: 654k]
  |  |  ------------------
  ------------------
  146|       |
  147|   654k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (147:7): [True: 652k, False: 1.75k]
  |  Branch (147:24): [True: 649k, False: 3.53k]
  |  Branch (147:42): [True: 638k, False: 11.1k]
  ------------------
  148|   638k|      std::memmove(out, in, sizeof(T) * n);
  149|   638k|   }
  150|   654k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__15arrayIhLm8EEETkNS1_16contiguous_rangeENS3_ImLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  10.2k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  10.2k|   ranges::assert_equal_byte_lengths(out, in);
  178|  10.2k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  10.2k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERKNSt3__14spanIhLm8EEETkNS1_16contiguous_rangeENS3_IKmLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISG_EESH_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS9_IXsr21__is_primary_templateINSA_Iu14__remove_cvrefIDTclL_ZNSC_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSI_ISQ_EESR_E4type10value_typeEEEEvOSN_RKSD_:
  176|  4.52k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  4.52k|   ranges::assert_equal_byte_lengths(out, in);
  178|  4.52k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  4.52k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERKNSt3__14spanIhLm8EEEmQaaaasr3stdE23is_trivially_copyable_vIT0_Entsr3std6rangesE5rangeIS7_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEEEvOSC_RKS7_:
  199|  4.52k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromT& in) {
  200|  4.52k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|  4.52k|}
_ZN5Botan19secure_scrub_memoryITkNS_6ranges23contiguous_output_rangeERNSt3__16vectorIhNS2_9allocatorIhEEEEEEvOT_:
   59|   318k|void secure_scrub_memory(ranges::contiguous_output_range auto&& data) {
   60|   318k|   secure_scrub_memory(std::ranges::data(data), ranges::size_bytes(data));
   61|   318k|}
_ZN5Botan9clear_memIhEEvPT_m:
  118|    181|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|    181|   clear_bytes(ptr, sizeof(T) * n);
  120|    181|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanIjLm1EEETkNS1_16contiguous_rangeENS3_IKhLm4EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|    934|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|    934|   ranges::assert_equal_byte_lengths(out, in);
  178|    934|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|    934|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm4EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|    934|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|    934|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|    934|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm4EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|    934|inline constexpr ToT typecast_copy(const FromR& src) {
  211|    934|   ToT dst;  // NOLINT(*-member-init)
  212|    934|   typecast_copy(dst, src);
  213|    934|   return dst;
  214|    934|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  6.06k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  6.06k|   ToT dst;  // NOLINT(*-member-init)
  212|  6.06k|   typecast_copy(dst, src);
  213|  6.06k|   return dst;
  214|  6.06k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  6.06k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  6.06k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  6.06k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IKhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  6.06k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  6.06k|   ranges::assert_equal_byte_lengths(out, in);
  178|  6.06k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  6.06k|}
_ZN5Botan9clear_memImEEvPT_m:
  118|  14.1k|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|  14.1k|   clear_bytes(ptr, sizeof(T) * n);
  120|  14.1k|}
_ZN5Botan8copy_memITkNS_6ranges23contiguous_output_rangeENSt3__14spanIhLm18446744073709551615EEETkNS1_16contiguous_rangeENS3_IKhLm18446744073709551615EEEQaasr3stdE9is_same_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeENS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIST_EEEvOSB_RKSL_:
  160|  12.6k|inline constexpr void copy_mem(OutR&& out /* NOLINT(*-std-forward) */, const InR& in) {
  161|  12.6k|   ranges::assert_equal_byte_lengths(out, in);
  162|  12.6k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (162:7): [Folded, False: 12.6k]
  ------------------
  163|      0|      std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
  164|  12.6k|   } else if(ranges::size_bytes(out) > 0) {
  ------------------
  |  Branch (164:14): [True: 12.6k, False: 0]
  ------------------
  165|  12.6k|      std::memmove(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  166|  12.6k|   }
  167|  12.6k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS5_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEEES5_RKSA_:
  210|  12.6k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  12.6k|   ToT dst;  // NOLINT(*-member-init)
  212|  12.6k|   typecast_copy(dst, src);
  213|  12.6k|   return dst;
  214|  12.6k|}
_ZN5Botan13typecast_copyImTkNS_6ranges16contiguous_rangeENSt3__14spanIhLm8EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISC_EESD_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISJ_EEEvRSJ_RKS9_:
  188|  12.6k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  12.6k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  12.6k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanImLm1EEETkNS1_16contiguous_rangeENS3_IhLm8EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS6_IXsr21__is_primary_templateINS7_Iu14__remove_cvrefIDTclL_ZNS9_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSF_ISN_EESO_E4type10value_typeEEEEvOSK_RKSA_:
  176|  12.6k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  12.6k|   ranges::assert_equal_byte_lengths(out, in);
  178|  12.6k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  12.6k|}
_ZN5Botan13typecast_copyItTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm2EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEES6_RKSB_:
  210|  1.07k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  1.07k|   ToT dst;  // NOLINT(*-member-init)
  212|  1.07k|   typecast_copy(dst, src);
  213|  1.07k|   return dst;
  214|  1.07k|}
_ZN5Botan13typecast_copyItTkNS_6ranges16contiguous_rangeENSt3__14spanIKhLm2EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISD_EESE_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISK_EEEvRSK_RKSA_:
  188|  1.07k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  1.07k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.07k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanItLm1EEETkNS1_16contiguous_rangeENS3_IKhLm2EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS7_IXsr21__is_primary_templateINS8_Iu14__remove_cvrefIDTclL_ZNSA_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSG_ISO_EESP_E4type10value_typeEEEEvOSL_RKSB_:
  176|  1.07k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  1.07k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.07k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.07k|}
_ZN5Botan9clear_memIjEEvPT_m:
  118|      6|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|      6|   clear_bytes(ptr, sizeof(T) * n);
  120|      6|}

_ZN5Botan15Key_ConstraintsC2ENS0_4BitsE:
  163|      1|      Key_Constraints(Key_Constraints::Bits bits) : m_value(bits) {}
_ZN5Botan11ReasonFlagsC2Et:
  248|     27|      explicit ReasonFlags(uint16_t bits) : m_value(bits) {
  249|     27|         if((m_value & static_cast<uint16_t>(~DefinedReasonBits)) != 0) {
  ------------------
  |  Branch (249:13): [True: 11, False: 16]
  ------------------
  250|     11|            throw Decoding_Error("ReasonFlags contains undefined reason bits");
  251|     11|         }
  252|     16|         if(m_value == 0) {
  ------------------
  |  Branch (252:13): [True: 3, False: 13]
  ------------------
  253|      3|            throw Decoding_Error("ReasonFlags must have at least one defined reason");
  254|      3|         }
  255|     16|      }

_ZN5Botan7X509_DNC2Ev:
  159|  3.36k|      X509_DN() = default;
_ZN5Botan10ExtensionsC2Ev:
 1027|  11.7k|      Extensions() = default;
_ZNK5Botan10Extensions30has_unknown_critical_extensionEv:
  934|  8.60k|      bool has_unknown_critical_extension() const { return m_has_unknown_critical_extension; }
_ZNK5Botan10Extensions5countEv:
 1025|    471|      size_t count() const { return m_extension_oids.size(); }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension10CRL_NumberEEEPKT_RKNS_3OIDE:
  882|     47|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  883|     47|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (883:42): [True: 19, False: 28]
  ------------------
  884|       |            // Unknown_Extension oid_name is empty
  885|     19|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (885:16): [True: 6, False: 13]
  ------------------
  886|      6|               return nullptr;
  887|     13|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (887:32): [True: 13, False: 0]
  ------------------
  888|     13|               return extn_as_T;
  889|     13|            } else {
  890|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  891|      0|            }
  892|     19|         }
  893|       |
  894|     28|         return nullptr;
  895|     47|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Authority_Key_IDEEEPKT_RKNS_3OIDE:
  882|     47|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  883|     47|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (883:42): [True: 7, False: 40]
  ------------------
  884|       |            // Unknown_Extension oid_name is empty
  885|      7|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (885:16): [True: 3, False: 4]
  ------------------
  886|      3|               return nullptr;
  887|      4|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (887:32): [True: 4, False: 0]
  ------------------
  888|      4|               return extn_as_T;
  889|      4|            } else {
  890|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  891|      0|            }
  892|      7|         }
  893|       |
  894|     40|         return nullptr;
  895|     47|      }
_ZNK5Botan15AlternativeName15directory_namesEv:
  441|     29|      const std::set<X509_DN>& directory_names() const { return m_dn_names; }
_ZN5Botan10ExtensionsD2Ev:
 1035|  11.7k|      ~Extensions() override = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension30CRL_Issuing_Distribution_PointEEEPKT_RKNS_3OIDE:
  882|     47|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  883|     47|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (883:42): [True: 8, False: 39]
  ------------------
  884|       |            // Unknown_Extension oid_name is empty
  885|      8|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (885:16): [True: 8, False: 0]
  ------------------
  886|      8|               return nullptr;
  887|      8|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (887:32): [True: 0, False: 0]
  ------------------
  888|      0|               return extn_as_T;
  889|      0|            } else {
  890|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  891|      0|            }
  892|      8|         }
  893|       |
  894|     39|         return nullptr;
  895|     47|      }
_ZN5Botan18X509_Serial_NumberC2Ev:
   70|  8.81k|      X509_Serial_Number() : m_contents{0x00} {}
_ZNK5Botan7X509_DN5emptyEv:
  202|      7|      bool empty() const { return m_rdn.empty(); }
_ZNK5Botan7X509_DN16_canonical_bytesEv:
  274|    782|      const std::vector<uint8_t>& _canonical_bytes() const { return m_canonical_dn_bits; }
_ZNK5Botan15AlternativeName14OtherNameValue3oidEv:
  309|  4.24k|            const OID& oid() const { return m_oid; }
_ZNK5Botan15AlternativeName14OtherNameValueltERKS1_:
  313|  1.22k|            bool operator<(const OtherNameValue& other) const {
  314|  1.22k|               if(oid() != other.oid()) {
  ------------------
  |  Branch (314:19): [True: 895, False: 331]
  ------------------
  315|    895|                  return oid() < other.oid();
  316|    895|               }
  317|    331|               return m_value < other.m_value;
  318|  1.22k|            }
_ZN5Botan15AlternativeName14OtherNameValueC2ERKNS_3OIDENSt3__16vectorIhNS5_9allocatorIhEEEE:
  323|    778|            OtherNameValue(const OID& oid, std::vector<uint8_t> value) : m_oid(oid), m_value(std::move(value)) {}
_ZN5Botan15AlternativeName16add_ipv4_addressEj:
  372|    734|      BOTAN_DEPRECATED("Use variant taking IPv4Address") void add_ipv4_address(uint32_t ipv4) {
  373|    734|         this->add_ipv4_address(IPv4Address(ipv4));
  374|    734|      }
_ZN5Botan10Extensions15Extensions_InfoC2EbNSt3__16vectorIhNS2_9allocatorIhEEEENS2_10unique_ptrINS_21Certificate_ExtensionENS2_14default_deleteIS8_EEEE:
 1049|  13.8k|                  m_obj(std::move(ext)), m_bits(std::move(encoding)), m_critical(critical) {}
_ZN5Botan15NameConstraintsC2Ev:
  753|      1|      NameConstraints() = default;
_ZN5Botan21Certificate_ExtensionD2Ev:
  856|  18.7k|      virtual ~Certificate_Extension() = default;
_ZN5Botan15AlternativeNameC2Ev:
  336|  2.34k|      AlternativeName() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension14CRL_ReasonCodeEEEPKT_RKNS_3OIDE:
  882|  6.44k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  883|  6.44k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (883:42): [True: 3.54k, False: 2.90k]
  ------------------
  884|       |            // Unknown_Extension oid_name is empty
  885|  3.54k|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (885:16): [True: 2.39k, False: 1.14k]
  ------------------
  886|  2.39k|               return nullptr;
  887|  2.39k|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (887:32): [True: 1.14k, False: 0]
  ------------------
  888|  1.14k|               return extn_as_T;
  889|  1.14k|            } else {
  890|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  891|      0|            }
  892|  3.54k|         }
  893|       |
  894|  2.90k|         return nullptr;
  895|  6.44k|      }

_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJNS3_IKhLm18446744073709551615EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  12.6k|{
  101|  12.6k|   const std::span s0{r0};
  102|       |
  103|       |   if constexpr(statically_spanable_range<R0>) {
  104|       |      constexpr size_t expected_size = s0.size_bytes();
  105|       |      (assert_exact_byte_length<expected_size>(rs), ...);
  106|  12.6k|   } else {
  107|  12.6k|      const size_t expected_size = s0.size_bytes();
  108|  12.6k|      const bool correct_size =
  109|  12.6k|         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|  12.6k|      if(!correct_size) {
  ------------------
  |  Branch (111:10): [True: 0, False: 12.6k]
  ------------------
  112|      0|         memory_region_size_violation();
  113|      0|      }
  114|  12.6k|   }
  115|  12.6k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__15arrayIhLm8EEETpTkNS0_14spanable_rangeEJNS3_ImLm1EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  20.5k|{
  101|  20.5k|   const std::span s0{r0};
  102|       |
  103|  20.5k|   if constexpr(statically_spanable_range<R0>) {
  104|  20.5k|      constexpr size_t expected_size = s0.size_bytes();
  105|  20.5k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  20.5k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayImLm1EEEEEvRKT0_:
   77|  20.5k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  20.5k|   const std::span s{r};
   79|  20.5k|   if constexpr(statically_spanable_range<R>) {
   80|  20.5k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  20.5k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEmRKT_:
   59|  10.2k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  10.2k|   return std::span{r}.size_bytes();
   61|  10.2k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEvRKT0_:
   77|  17.1k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  17.1k|   const std::span s{r};
   79|  17.1k|   if constexpr(statically_spanable_range<R>) {
   80|  17.1k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  17.1k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKmLm1EEEEEvRKT0_:
   77|  4.52k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  4.52k|   const std::span s{r};
   79|  4.52k|   if constexpr(statically_spanable_range<R>) {
   80|  4.52k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  4.52k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm8EEETpTkNS0_14spanable_rangeEJNS3_IKmLm1EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  4.52k|{
  101|  4.52k|   const std::span s0{r0};
  102|       |
  103|  4.52k|   if constexpr(statically_spanable_range<R0>) {
  104|  4.52k|      constexpr size_t expected_size = s0.size_bytes();
  105|  4.52k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  4.52k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEmRKT_:
   59|  4.52k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  4.52k|   return std::span{r}.size_bytes();
   61|  4.52k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__16vectorIhNS2_9allocatorIhEEEEEEmRKT_:
   59|   318k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|   318k|   return std::span{r}.size_bytes();
   61|   318k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEEEEmRKT_:
   59|  25.2k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  25.2k|   return std::span{r}.size_bytes();
   61|  25.2k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeENSt3__14spanIKhLm4EEEEEvRKT0_:
   77|  1.86k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  1.86k|   const std::span s{r};
   79|  1.86k|   if constexpr(statically_spanable_range<R>) {
   80|  1.86k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  1.86k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIjLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm4EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|    934|{
  101|    934|   const std::span s0{r0};
  102|       |
  103|    934|   if constexpr(statically_spanable_range<R0>) {
  104|    934|      constexpr size_t expected_size = s0.size_bytes();
  105|    934|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|    934|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIjLm1EEEEEmRKT_:
   59|    934|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|    934|   return std::span{r}.size_bytes();
   61|    934|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKhLm8EEEEEvRKT0_:
   77|  12.1k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  12.1k|   const std::span s{r};
   79|  12.1k|   if constexpr(statically_spanable_range<R>) {
   80|  12.1k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  12.1k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  6.06k|{
  101|  6.06k|   const std::span s0{r0};
  102|       |
  103|  6.06k|   if constexpr(statically_spanable_range<R0>) {
  104|  6.06k|      constexpr size_t expected_size = s0.size_bytes();
  105|  6.06k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  6.06k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanImLm1EEEEEmRKT_:
   59|  18.7k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  18.7k|   return std::span{r}.size_bytes();
   61|  18.7k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEvRKT0_:
   77|  12.6k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  12.6k|   const std::span s{r};
   79|  12.6k|   if constexpr(statically_spanable_range<R>) {
   80|  12.6k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  12.6k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  12.6k|{
  101|  12.6k|   const std::span s0{r0};
  102|       |
  103|  12.6k|   if constexpr(statically_spanable_range<R0>) {
  104|  12.6k|      constexpr size_t expected_size = s0.size_bytes();
  105|  12.6k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  12.6k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm2ETkNS0_14spanable_rangeENSt3__14spanIKhLm2EEEEEvRKT0_:
   77|  2.14k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  2.14k|   const std::span s{r};
   79|  2.14k|   if constexpr(statically_spanable_range<R>) {
   80|  2.14k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   81|       |   } else {
   82|       |      if(s.size_bytes() != expected) {
   83|       |         memory_region_size_violation();
   84|       |      }
   85|       |   }
   86|  2.14k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanItLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm2EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  1.07k|{
  101|  1.07k|   const std::span s0{r0};
  102|       |
  103|  1.07k|   if constexpr(statically_spanable_range<R0>) {
  104|  1.07k|      constexpr size_t expected_size = s0.size_bytes();
  105|  1.07k|      (assert_exact_byte_length<expected_size>(rs), ...);
  106|       |   } else {
  107|       |      const size_t expected_size = s0.size_bytes();
  108|       |      const bool correct_size =
  109|       |         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|       |      if(!correct_size) {
  112|       |         memory_region_size_violation();
  113|       |      }
  114|       |   }
  115|  1.07k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanItLm1EEEEEmRKT_:
   59|  1.07k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  1.07k|   return std::span{r}.size_bytes();
   61|  1.07k|}

_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
  102|  21.9k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIhE8allocateEm:
   95|  21.9k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorImE10deallocateEPmm:
  102|  14.1k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE8allocateEm:
   95|  14.1k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPKS5_T1_EE:
  204|    486|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<const T*, L>& in) {
  205|    486|   if(in.second > 0) {
  ------------------
  |  Branch (205:7): [True: 447, False: 39]
  ------------------
  206|    447|      out.insert(out.end(), in.first, in.first + in.second);
  207|    447|   }
  208|    486|   return out;
  209|    486|}

_ZN5Botan18unwrap_strong_typeIRNSt3__16vectorIhNS1_9allocatorIhEEEEEEDcOT_:
  119|  43.0k|[[nodiscard]] constexpr decltype(auto) unwrap_strong_type(T&& t) {
  120|  43.0k|   if constexpr(!concepts::strong_type<std::remove_cvref_t<T>>) {
  121|       |      // If the parameter type isn't a strong type, return it as is.
  122|  43.0k|      return std::forward<T>(t);
  123|       |   } else {
  124|       |      // Unwrap the strong type and return the underlying value.
  125|       |      return std::forward<T>(t).get();
  126|       |   }
  127|  43.0k|}
_ZN5Botan18unwrap_strong_typeIRmEEDcOT_:
  119|  4.55k|[[nodiscard]] constexpr decltype(auto) unwrap_strong_type(T&& t) {
  120|  4.55k|   if constexpr(!concepts::strong_type<std::remove_cvref_t<T>>) {
  121|       |      // If the parameter type isn't a strong type, return it as is.
  122|  4.55k|      return std::forward<T>(t);
  123|       |   } else {
  124|       |      // Unwrap the strong type and return the underlying value.
  125|       |      return std::forward<T>(t).get();
  126|       |   }
  127|  4.55k|}
_ZN5Botan16wrap_strong_typeItRKtQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS3_Esr3stdE18constructible_fromINS3_12wrapped_typeES4_EEEDcOS4_:
  144|     27|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  145|     27|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  146|       |      // Noop, if the parameter type already is the desired return type.
  147|     27|      return std::forward<ParamT>(t);
  148|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  149|       |      // Implicit conversion from the parameter type to the return type.
  150|       |      return T{std::forward<ParamT>(t)};
  151|       |   } else {
  152|       |      // Explicitly calling the wrapped type's constructor to support
  153|       |      // implicit conversions on types that mark their constructors as explicit.
  154|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  155|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  156|       |   }
  157|     27|}
_ZN5Botan16wrap_strong_typeIjRjQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  144|    934|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  145|    934|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  146|       |      // Noop, if the parameter type already is the desired return type.
  147|    934|      return std::forward<ParamT>(t);
  148|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  149|       |      // Implicit conversion from the parameter type to the return type.
  150|       |      return T{std::forward<ParamT>(t)};
  151|       |   } else {
  152|       |      // Explicitly calling the wrapped type's constructor to support
  153|       |      // implicit conversions on types that mark their constructors as explicit.
  154|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  155|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  156|       |   }
  157|    934|}
_ZN5Botan16wrap_strong_typeImRmQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  144|  18.7k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  145|  18.7k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  146|       |      // Noop, if the parameter type already is the desired return type.
  147|  18.7k|      return std::forward<ParamT>(t);
  148|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  149|       |      // Implicit conversion from the parameter type to the return type.
  150|       |      return T{std::forward<ParamT>(t)};
  151|       |   } else {
  152|       |      // Explicitly calling the wrapped type's constructor to support
  153|       |      // implicit conversions on types that mark their constructors as explicit.
  154|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  155|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  156|       |   }
  157|  18.7k|}
_ZN5Botan16wrap_strong_typeItRtQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  144|  1.07k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  145|  1.07k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  146|       |      // Noop, if the parameter type already is the desired return type.
  147|  1.07k|      return std::forward<ParamT>(t);
  148|       |   } else if constexpr(std::constructible_from<T, ParamT>) {
  149|       |      // Implicit conversion from the parameter type to the return type.
  150|       |      return T{std::forward<ParamT>(t)};
  151|       |   } else {
  152|       |      // Explicitly calling the wrapped type's constructor to support
  153|       |      // implicit conversions on types that mark their constructors as explicit.
  154|       |      static_assert(concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>);
  155|       |      return T{typename T::wrapped_type{std::forward<ParamT>(t)}};
  156|       |   }
  157|  1.07k|}

_ZN5Botan3URI9AuthorityC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_8optionalIS8_EENS2_7variantIJNS_7DNSNameENS_11IPv4AddressENS_11IPv6AddressEEEENS9_ItEE:
  105|    829|                  m_raw(std::move(raw)), m_userinfo(std::move(userinfo)), m_host(std::move(host)), m_port(port) {}
_ZN5Botan3URIC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_NS1_8optionalINS0_9AuthorityEEES7_NS8_IS7_EESB_:
  202|  1.63k|            m_raw(std::move(raw)),
  203|  1.63k|            m_scheme(std::move(scheme)),
  204|  1.63k|            m_authority(std::move(authority)),
  205|  1.63k|            m_path(std::move(path)),
  206|  1.63k|            m_query(std::move(query)),
  207|  1.63k|            m_fragment(std::move(fragment)) {}

_ZN5Botan9CRL_EntryC2Ev:
   73|  8.80k|      CRL_Entry() = default;

_ZN5Botan14Cert_Extension10CRL_Number10static_oidEv:
  516|     47|      static OID static_oid() { return OID({2, 5, 29, 20}); }
_ZN5Botan14Cert_Extension16Authority_Key_ID10static_oidEv:
  185|     47|      static OID static_oid() { return OID({2, 5, 29, 35}); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID10get_key_idEv:
  178|      4|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point10static_oidEv:
  749|     47|      static OID static_oid() { return OID({2, 5, 29, 28}); }
_ZNK5Botan14Cert_Extension17Basic_Constraints8oid_nameEv:
   67|      1|      std::string oid_name() const override { return "X509v3.BasicConstraints"; }
_ZN5Botan14Cert_Extension9Key_UsageC2Ev:
   89|      1|      explicit Key_Usage() : m_constraints(Key_Constraints::None) {}
_ZNK5Botan14Cert_Extension9Key_Usage8oid_nameEv:
   98|      1|      std::string oid_name() const override { return "X509v3.KeyUsage"; }
_ZNK5Botan14Cert_Extension14Subject_Key_ID8oid_nameEv:
  143|      2|      std::string oid_name() const override { return "X509v3.SubjectKeyIdentifier"; }
_ZNK5Botan14Cert_Extension16Authority_Key_ID8oid_nameEv:
  190|      5|      std::string oid_name() const override { return "X509v3.AuthorityKeyIdentifier"; }
_ZN5Botan14Cert_Extension24Subject_Alternative_NameC2ERKNS_15AlternativeNameE:
  218|      1|      explicit Subject_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name8oid_nameEv:
  221|      1|      std::string oid_name() const override { return "X509v3.SubjectAlternativeName"; }
_ZN5Botan14Cert_Extension23Issuer_Alternative_NameC2ERKNS_15AlternativeNameE:
  248|  2.06k|      explicit Issuer_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name8oid_nameEv:
  251|      1|      std::string oid_name() const override { return "X509v3.IssuerAlternativeName"; }
_ZNK5Botan14Cert_Extension18Extended_Key_Usage8oid_nameEv:
  283|      1|      std::string oid_name() const override { return "X509v3.ExtendedKeyUsage"; }
_ZNK5Botan14Cert_Extension16Name_Constraints8oid_nameEv:
  321|      1|      std::string oid_name() const override { return "X509v3.NameConstraints"; }
_ZNK5Botan14Cert_Extension20Certificate_Policies8oid_nameEv:
  359|      3|      std::string oid_name() const override { return "X509v3.CertificatePolicies"; }
_ZN5Botan14Cert_Extension28Authority_Information_Access17AccessDescriptionC2ENS_3OIDENS_9ASN1_TypeENS_10ASN1_ClassENSt3__16vectorIhNS6_9allocatorIhEEEE:
  391|    182|                  m_method(std::move(method)),
  392|    182|                  m_location_tag(location_tag),
  393|    182|                  m_location_class(location_class),
  394|    182|                  m_location_value(std::move(location_value)) {}
_ZN5Botan14Cert_Extension10CRL_NumberC2Ev:
  506|     52|      CRL_Number() : m_has_value(false), m_crl_number(BigInt::zero()) {}
_ZNK5Botan14Cert_Extension10CRL_Number8oid_nameEv:
  521|     14|      std::string oid_name() const override { return "X509v3.CRLNumber"; }
_ZN5Botan14Cert_Extension14CRL_ReasonCodeC2ENS_8CRL_CodeE:
  543|  3.54k|      explicit CRL_ReasonCode(CRL_Code r = CRL_Code::Unspecified) : m_reason(r) {}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode10get_reasonEv:
  545|  1.14k|      CRL_Code get_reason() const { return m_reason; }
_ZN5Botan14Cert_Extension14CRL_ReasonCode10static_oidEv:
  547|  6.44k|      static OID static_oid() { return OID({2, 5, 29, 21}); }
_ZNK5Botan14Cert_Extension14CRL_ReasonCode8oid_nameEv:
  552|  1.14k|      std::string oid_name() const override { return "X509v3.ReasonCode"; }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points8oid_nameEv:
  672|      2|      std::string oid_name() const override { return "X509v3.CRLDistributionPoints"; }
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point8oid_nameEv:
  754|      1|      std::string oid_name() const override { return "X509v3.CRLIssuingDistributionPoint"; }
_ZN5Botan14Cert_Extension12OCSP_NoCheck10static_oidEv:
  796|  7.61k|      static OID static_oid() { return OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 5}); }
_ZNK5Botan14Cert_Extension21NoRevocationAvailable8oid_nameEv:
  850|      1|      std::string oid_name() const override { return "X509v3.NoRevocationAvailable"; }
_ZNK5Botan14Cert_Extension10TNAuthList8oid_nameEv:
 1003|      1|      std::string oid_name() const override { return "PKIX.TNAuthList"; }
_ZNK5Botan14Cert_Extension15IPAddressBlocks8oid_nameEv:
 1295|      1|      std::string oid_name() const override { return "PKIX.IpAddrBlocks"; }
_ZNK5Botan14Cert_Extension8ASBlocks8oid_nameEv:
 1447|      1|      std::string oid_name() const override { return "PKIX.AutonomousSysIds"; }
_ZN5Botan14Cert_Extension17Unknown_ExtensionC2ERKNS_3OIDEbb:
 1466|  12.5k|            m_oid(oid), m_critical(critical), m_failed_to_decode(failed_to_decode) {}
_ZNK5Botan14Cert_Extension17Unknown_Extension8oid_nameEv:
 1508|  2.41k|      std::string oid_name() const override { return ""; }
_ZN5Botan14Cert_Extension14Subject_Key_IDC2Ev:
  115|      2|      Subject_Key_ID() = default;
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_PointC2Ev:
  698|    237|      CRL_Issuing_Distribution_Point() = default;
_ZN5Botan14Cert_Extension16Name_ConstraintsC2Ev:
  304|      1|      Name_Constraints() = default;
_ZN5Botan14Cert_Extension23CRL_Distribution_PointsC2Ev:
  657|      2|      CRL_Distribution_Points() = default;
_ZN5Botan14Cert_Extension20Certificate_PoliciesC2Ev:
  342|      3|      Certificate_Policies() = default;
_ZN5Botan14Cert_Extension16Authority_Key_IDC2Ev:
  162|    248|      Authority_Key_ID() = default;
_ZN5Botan14Cert_Extension18Extended_Key_UsageC2Ev:
  272|      1|      Extended_Key_Usage() = default;
_ZN5Botan14Cert_Extension21NoRevocationAvailableC2Ev:
  835|      1|      NoRevocationAvailable() = default;
_ZN5Botan14Cert_Extension28Authority_Information_AccessC2Ev:
  427|     92|      Authority_Information_Access() = default;
_ZN5Botan14Cert_Extension15IPAddressBlocksC2Ev:
 1206|      1|      IPAddressBlocks() = default;
_ZN5Botan14Cert_Extension8ASBlocksC2Ev:
 1392|      1|      ASBlocks() = default;
_ZN5Botan14Cert_Extension8ASBlocks13ASIdentifiersC2Ev:
 1386|      1|            ASIdentifiers() = default;
_ZN5Botan14Cert_Extension10TNAuthListC2Ev:
  958|      1|      TNAuthList() = default;
_ZN5Botan14Cert_Extension21DistributionPointNameC2Ev:
  577|     41|      DistributionPointName() = default;

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

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

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

_ZNK5Botan19AlgorithmIdentifier19parameters_are_nullEv:
   50|  2.97k|bool AlgorithmIdentifier::parameters_are_null() const {
   51|  2.97k|   return (m_parameters.size() == 2 && (m_parameters[0] == 0x05) && (m_parameters[1] == 0x00));
  ------------------
  |  Branch (51:12): [True: 2.67k, False: 302]
  |  Branch (51:40): [True: 2.63k, False: 45]
  |  Branch (51:69): [True: 2.62k, False: 8]
  ------------------
   52|  2.97k|}
_ZN5BotaneqERKNS_19AlgorithmIdentifierES2_:
   54|  2.67k|bool operator==(const AlgorithmIdentifier& x, const AlgorithmIdentifier& y) {
   55|  2.67k|   return (x.oid() == y.oid() && x.parameters() == y.parameters());
  ------------------
  |  Branch (55:12): [True: 2.62k, False: 51]
  |  Branch (55:34): [True: 2.58k, False: 38]
  ------------------
   56|  2.67k|}
_ZN5BotanneERKNS_19AlgorithmIdentifierES2_:
   58|  2.67k|bool operator!=(const AlgorithmIdentifier& x, const AlgorithmIdentifier& y) {
   59|  2.67k|   return !(x == y);
   60|  2.67k|}
_ZN5Botan19AlgorithmIdentifier11decode_fromERNS_11BER_DecoderE:
   72|  6.12k|void AlgorithmIdentifier::decode_from(BER_Decoder& codec) {
   73|  6.12k|   codec.start_sequence().decode(m_oid).raw_bytes(m_parameters).end_cons();
   74|       |
   75|       |   /*
   76|       |   * The parameters field is OPTIONAL ANY but in practice it is one of
   77|       |   * - empty
   78|       |   * - NULL
   79|       |   * - SEQUENCE
   80|       |   * - OBJECT IDENTIFIER (namedCurve)
   81|       |   * - OCTET STRING (CBC IV in PBES2)
   82|       |   *
   83|       |   * So require it be exactly one of these values. In particular this ensures that
   84|       |   * there is not any additional trailing data (eg after the SEQUENCE encoding)
   85|       |   * that might be otherwise skipped over by a reader.
   86|       |   */
   87|       |
   88|  6.12k|   const bool acceptable_parameters = [&]() {
   89|  6.12k|      if(this->parameters_are_null_or_empty()) {
   90|  6.12k|         return true;
   91|  6.12k|      }
   92|  6.12k|      if(ASN1::is_der_sequence_header(m_parameters)) {
   93|  6.12k|         return true;
   94|  6.12k|      }
   95|  6.12k|      if(ASN1::is_single_der_object(m_parameters, ASN1_Type::ObjectId, ASN1_Class::Universal)) {
   96|  6.12k|         return true;
   97|  6.12k|      }
   98|  6.12k|      if(ASN1::is_single_der_object(m_parameters, ASN1_Type::OctetString, ASN1_Class::Universal)) {
   99|  6.12k|         return true;
  100|  6.12k|      }
  101|  6.12k|      return false;
  102|  6.12k|   }();
  103|       |
  104|  6.12k|   if(!acceptable_parameters) {
  ------------------
  |  Branch (104:7): [True: 176, False: 5.95k]
  ------------------
  105|    176|      throw Decoding_Error("AlgorithmIdentifier parameters were not NULL, a SEQUENCE, an OID, or an OCTET STRING");
  106|    176|   }
  107|  6.12k|}
alg_id.cpp:_ZZN5Botan19AlgorithmIdentifier11decode_fromERNS_11BER_DecoderEENK3$_0clEv:
   88|  5.87k|   const bool acceptable_parameters = [&]() {
   89|  5.87k|      if(this->parameters_are_null_or_empty()) {
  ------------------
  |  Branch (89:10): [True: 5.51k, False: 355]
  ------------------
   90|  5.51k|         return true;
   91|  5.51k|      }
   92|    355|      if(ASN1::is_der_sequence_header(m_parameters)) {
  ------------------
  |  Branch (92:10): [True: 29, False: 326]
  ------------------
   93|     29|         return true;
   94|     29|      }
   95|    326|      if(ASN1::is_single_der_object(m_parameters, ASN1_Type::ObjectId, ASN1_Class::Universal)) {
  ------------------
  |  Branch (95:10): [True: 46, False: 280]
  ------------------
   96|     46|         return true;
   97|     46|      }
   98|    280|      if(ASN1::is_single_der_object(m_parameters, ASN1_Type::OctetString, ASN1_Class::Universal)) {
  ------------------
  |  Branch (98:10): [True: 104, False: 176]
  ------------------
   99|    104|         return true;
  100|    104|      }
  101|    176|      return false;
  102|    280|   }();

_ZNK5Botan11ASN1_Object10BER_encodeEv:
   21|  3.42k|std::vector<uint8_t> ASN1_Object::BER_encode() const {
   22|  3.42k|   std::vector<uint8_t> output;
   23|  3.42k|   DER_Encoder der(output);
   24|  3.42k|   this->encode_into(der);
   25|  3.42k|   return output;
   26|  3.42k|}
_ZN5Botan14ASN1_BitStringC2ENSt3__16vectorIhNS1_9allocatorIhEEEEm:
   29|  3.00k|      m_bytes(std::move(bytes)), m_unused_bits(unused_bits) {
   30|  3.00k|   if(m_unused_bits >= 8) {
  ------------------
  |  Branch (30:7): [True: 0, False: 3.00k]
  ------------------
   31|      0|      throw Invalid_Argument("ASN1_BitString: Invalid unused bit count");
   32|      0|   }
   33|       |
   34|  3.00k|   if(m_bytes.empty() && m_unused_bits != 0) {
  ------------------
  |  Branch (34:7): [True: 32, False: 2.97k]
  |  Branch (34:26): [True: 0, False: 32]
  ------------------
   35|      0|      throw Invalid_Argument("ASN1_BitString: Empty BIT STRING cannot have unused bits");
   36|      0|   }
   37|       |
   38|  3.00k|   if(m_unused_bits > 0 && (m_bytes.back() & ((1U << m_unused_bits) - 1)) != 0) {
  ------------------
  |  Branch (38:7): [True: 20, False: 2.98k]
  |  Branch (38:28): [True: 0, False: 20]
  ------------------
   39|      0|      throw Invalid_Argument("ASN1_BitString: Unused bits must be zero");
   40|      0|   }
   41|  3.00k|}
_ZNK5Botan14ASN1_BitString10bit_lengthEv:
   46|    464|size_t ASN1_BitString::bit_length() const {
   47|    464|   return 8 * m_bytes.size() - m_unused_bits;
   48|    464|}
_ZNK5Botan14ASN1_BitString6bit_atEm:
   50|    184|bool ASN1_BitString::bit_at(size_t bit) const {
   51|    184|   if(bit >= bit_length()) {
  ------------------
  |  Branch (51:7): [True: 0, False: 184]
  ------------------
   52|      0|      throw Invalid_Argument("ASN1_BitString: Bit index out of range");
   53|      0|   }
   54|       |
   55|    184|   return (m_bytes[bit / 8] & (0x80 >> (bit % 8))) != 0;
   56|    184|}
_ZN5Botan10BER_ObjectD2Ev:
   58|   318k|BER_Object::~BER_Object() {
   59|   318k|   secure_scrub_memory(m_value);
   60|   318k|}
_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   65|  90.2k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   66|  90.2k|   if(!this->is_a(expected_type_tag, expected_class_tag)) {
  ------------------
  |  Branch (66:7): [True: 2.25k, False: 87.9k]
  ------------------
   67|  2.25k|      std::stringstream msg;
   68|       |
   69|  2.25k|      msg << "Tag mismatch when decoding " << descr << " got ";
   70|       |
   71|  2.25k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (71:10): [True: 72, False: 2.18k]
  |  Branch (71:49): [True: 72, False: 0]
  ------------------
   72|     72|         msg << "EOF";
   73|  2.18k|      } else {
   74|  2.18k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (74:13): [True: 1.15k, False: 1.03k]
  |  Branch (74:53): [True: 440, False: 593]
  ------------------
   75|  1.59k|            msg << asn1_tag_to_string(m_type_tag);
   76|  1.59k|         } else {
   77|    593|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   78|    593|         }
   79|       |
   80|  2.18k|         msg << "/" << asn1_class_to_string(m_class_tag);
   81|  2.18k|      }
   82|       |
   83|  2.25k|      msg << " expected ";
   84|       |
   85|  2.25k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (85:10): [True: 1.38k, False: 872]
  |  Branch (85:57): [True: 872, False: 0]
  ------------------
   86|  2.25k|         msg << asn1_tag_to_string(expected_type_tag);
   87|  2.25k|      } else {
   88|      0|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   89|      0|      }
   90|       |
   91|  2.25k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   92|       |
   93|  2.25k|      throw BER_Decoding_Error(msg.str());
   94|  2.25k|   }
   95|  90.2k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   97|   152k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   98|   152k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (98:12): [True: 102k, False: 50.8k]
  |  Branch (98:47): [True: 101k, False: 281]
  ------------------
   99|   152k|}
_ZNK5Botan10BER_Object4is_aEiNS_10ASN1_ClassE:
  101|  40.8k|bool BER_Object::is_a(int expected_type_tag, ASN1_Class expected_class_tag) const {
  102|  40.8k|   return is_a(ASN1_Type(expected_type_tag), expected_class_tag);
  103|  40.8k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
  105|   144k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
  106|   144k|   m_type_tag = type_tag;
  107|   144k|   m_class_tag = class_tag;
  108|   144k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
  110|  4.44k|std::string asn1_class_to_string(ASN1_Class type) {
  111|  4.44k|   switch(type) {
  112|  2.54k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (112:7): [True: 2.54k, False: 1.90k]
  ------------------
  113|  2.54k|         return "UNIVERSAL";
  114|  1.31k|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (114:7): [True: 1.31k, False: 3.13k]
  ------------------
  115|  1.31k|         return "CONSTRUCTED";
  116|    241|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (116:7): [True: 241, False: 4.20k]
  ------------------
  117|    241|         return "CONTEXT_SPECIFIC";
  118|    108|      case ASN1_Class::Application:
  ------------------
  |  Branch (118:7): [True: 108, False: 4.33k]
  ------------------
  119|    108|         return "APPLICATION";
  120|     38|      case ASN1_Class::Private:
  ------------------
  |  Branch (120:7): [True: 38, False: 4.40k]
  ------------------
  121|     38|         return "PRIVATE";
  122|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (122:7): [True: 0, False: 4.44k]
  ------------------
  123|      0|         return "NO_OBJECT";
  124|    206|      default:
  ------------------
  |  Branch (124:7): [True: 206, False: 4.24k]
  ------------------
  125|    206|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
  126|  4.44k|   }
  127|  4.44k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
  129|  4.09k|std::string asn1_tag_to_string(ASN1_Type type) {
  130|  4.09k|   switch(type) {
  131|    869|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (131:7): [True: 869, False: 3.22k]
  ------------------
  132|    869|         return "SEQUENCE";
  133|       |
  134|     47|      case ASN1_Type::Set:
  ------------------
  |  Branch (134:7): [True: 47, False: 4.04k]
  ------------------
  135|     47|         return "SET";
  136|       |
  137|     91|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (137:7): [True: 91, False: 4.00k]
  ------------------
  138|     91|         return "PRINTABLE STRING";
  139|       |
  140|     62|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (140:7): [True: 62, False: 4.03k]
  ------------------
  141|     62|         return "NUMERIC STRING";
  142|       |
  143|     30|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (143:7): [True: 30, False: 4.06k]
  ------------------
  144|     30|         return "IA5 STRING";
  145|       |
  146|     16|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (146:7): [True: 16, False: 4.07k]
  ------------------
  147|     16|         return "T61 STRING";
  148|       |
  149|    114|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (149:7): [True: 114, False: 3.97k]
  ------------------
  150|    114|         return "UTF8 STRING";
  151|       |
  152|     45|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (152:7): [True: 45, False: 4.04k]
  ------------------
  153|     45|         return "VISIBLE STRING";
  154|       |
  155|     12|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (155:7): [True: 12, False: 4.08k]
  ------------------
  156|     12|         return "BMP STRING";
  157|       |
  158|     12|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (158:7): [True: 12, False: 4.08k]
  ------------------
  159|     12|         return "UNIVERSAL STRING";
  160|       |
  161|     32|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (161:7): [True: 32, False: 4.06k]
  ------------------
  162|     32|         return "UTC TIME";
  163|       |
  164|     17|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (164:7): [True: 17, False: 4.07k]
  ------------------
  165|     17|         return "GENERALIZED TIME";
  166|       |
  167|     51|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (167:7): [True: 51, False: 4.04k]
  ------------------
  168|     51|         return "OCTET STRING";
  169|       |
  170|     62|      case ASN1_Type::BitString:
  ------------------
  |  Branch (170:7): [True: 62, False: 4.03k]
  ------------------
  171|     62|         return "BIT STRING";
  172|       |
  173|  1.37k|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (173:7): [True: 1.37k, False: 2.71k]
  ------------------
  174|  1.37k|         return "ENUMERATED";
  175|       |
  176|     99|      case ASN1_Type::Integer:
  ------------------
  |  Branch (176:7): [True: 99, False: 3.99k]
  ------------------
  177|     99|         return "INTEGER";
  178|       |
  179|     37|      case ASN1_Type::Null:
  ------------------
  |  Branch (179:7): [True: 37, False: 4.05k]
  ------------------
  180|     37|         return "NULL";
  181|       |
  182|     63|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (182:7): [True: 63, False: 4.03k]
  ------------------
  183|     63|         return "OBJECT";
  184|       |
  185|    204|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (185:7): [True: 204, False: 3.88k]
  ------------------
  186|    204|         return "BOOLEAN";
  187|       |
  188|      0|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (188:7): [True: 0, False: 4.09k]
  ------------------
  189|      0|         return "NO_OBJECT";
  190|       |
  191|    851|      default:
  ------------------
  |  Branch (191:7): [True: 851, False: 3.24k]
  ------------------
  192|    851|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  193|  4.09k|   }
  194|  4.09k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  199|  5.24k|BER_Decoding_Error::BER_Decoding_Error(std::string_view err) : Decoding_Error(fmt("BER: {}", err)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  201|     89|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  224|  19.5k|std::string to_string(const BER_Object& obj) {
  225|  19.5k|   return bytes_to_string(obj.data());
  226|  19.5k|}
_ZN5Botan4ASN19maybe_BERERNS_10DataSourceE:
  231|  4.20k|bool maybe_BER(DataSource& source) {
  232|  4.20k|   uint8_t first_u8 = 0;
  233|  4.20k|   if(source.peek_byte(first_u8) == 0) {
  ------------------
  |  Branch (233:7): [True: 0, False: 4.20k]
  ------------------
  234|      0|      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
  ------------------
  |  |   97|      0|   do {                                                                                                \
  |  |   98|      0|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                                    \
  |  |   99|      0|      if((expr1) != (expr2)) {                                                                         \
  |  |  ------------------
  |  |  |  Branch (99:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  100|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                           \
  |  |  101|      0|         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \
  |  |  102|      0|      }                                                                                                \
  |  |  103|      0|   } while(0)
  |  |  ------------------
  |  |  |  Branch (103:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  235|      0|      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
  236|      0|   }
  237|       |
  238|  4.20k|   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
  239|  4.20k|   return first_u8 == cons_seq;
  240|  4.20k|}

_ZN5Botan3OID11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   80|    960|OID OID::from_string(std::string_view str) {
   81|    960|   if(str.empty()) {
  ------------------
  |  Branch (81:7): [True: 0, False: 960]
  ------------------
   82|      0|      throw Invalid_Argument("OID::from_string argument must be non-empty");
   83|      0|   }
   84|       |
   85|    960|   OID o = OID_Map::global_registry().str2oid(str);
   86|    960|   if(o.has_value()) {
  ------------------
  |  Branch (86:7): [True: 960, False: 0]
  ------------------
   87|    960|      return o;
   88|    960|   }
   89|       |
   90|       |   // Try to parse as a dotted decimal
   91|      0|   try {
   92|      0|      return OID(str);
   93|      0|   } catch(...) {}
   94|       |
   95|      0|   throw Lookup_Error(fmt("No OID associated with name '{}'", str));
   96|      0|}
_ZN5Botan3OIDC2ESt16initializer_listIjE:
   98|  15.1k|OID::OID(std::initializer_list<uint32_t> init) : m_id(init) {
   99|  15.1k|   oid_valid_check(m_id);
  100|  15.1k|}
_ZNK5Botan3OID9hash_codeEv:
  162|      4|uint64_t OID::hash_code() const {
  163|       |   // If this is changed also update gen_oids.py to match
  164|      4|   uint64_t hash = 0x621F302327D9A49A;
  165|     32|   for(const auto id : m_id) {
  ------------------
  |  Branch (165:22): [True: 32, False: 4]
  ------------------
  166|     32|      hash *= 193;
  167|     32|      hash += id;
  168|     32|   }
  169|      4|   return hash;
  170|      4|}
_ZN5BotanltERKNS_3OIDES2_:
  175|  30.2k|bool operator<(const OID& a, const OID& b) {
  176|  30.2k|   const std::vector<uint32_t>& oid1 = a.get_components();
  177|  30.2k|   const std::vector<uint32_t>& oid2 = b.get_components();
  178|       |
  179|  30.2k|   return std::lexicographical_compare(oid1.begin(), oid1.end(), oid2.begin(), oid2.end());
  180|  30.2k|}
_ZNK5Botan3OID11encode_intoERNS_11DER_EncoderE:
  185|  3.42k|void OID::encode_into(DER_Encoder& der) const {
  186|  3.42k|   if(m_id.size() < 2) {
  ------------------
  |  Branch (186:7): [True: 0, False: 3.42k]
  ------------------
  187|      0|      throw Invalid_Argument("OID::encode_into: OID is invalid");
  188|      0|   }
  189|       |
  190|  3.42k|   const auto append = [](std::vector<uint8_t>& encoding, uint32_t z) {
  191|  3.42k|      if(z <= 0x7F) {
  192|  3.42k|         encoding.push_back(static_cast<uint8_t>(z));
  193|  3.42k|      } else {
  194|  3.42k|         const size_t z7 = (high_bit(z) + 7 - 1) / 7;
  195|       |
  196|  3.42k|         for(size_t j = 0; j != z7; ++j) {
  197|  3.42k|            uint8_t zp = static_cast<uint8_t>(z >> (7 * (z7 - j - 1)) & 0x7F);
  198|       |
  199|  3.42k|            if(j != z7 - 1) {
  200|  3.42k|               zp |= 0x80;
  201|  3.42k|            }
  202|       |
  203|  3.42k|            encoding.push_back(zp);
  204|  3.42k|         }
  205|  3.42k|      }
  206|  3.42k|   };
  207|       |
  208|  3.42k|   std::vector<uint8_t> encoding;
  209|       |
  210|       |   // We know 40 * root can't overflow because root is between 0 and 2
  211|  3.42k|   auto first = checked_add(40 * m_id[0], m_id[1]);
  212|  3.42k|   BOTAN_ASSERT_NOMSG(first.has_value());
  ------------------
  |  |   84|  3.42k|   do {                                                                     \
  |  |   85|  3.42k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  3.42k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 3.42k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  3.42k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 3.42k]
  |  |  ------------------
  ------------------
  213|       |
  214|  3.42k|   append(encoding, *first);
  215|       |
  216|  8.79k|   for(size_t i = 2; i != m_id.size(); ++i) {
  ------------------
  |  Branch (216:22): [True: 5.36k, False: 3.42k]
  ------------------
  217|  5.36k|      append(encoding, m_id[i]);
  218|  5.36k|   }
  219|  3.42k|   der.add_object(ASN1_Type::ObjectId, ASN1_Class::Universal, encoding);
  220|  3.42k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  225|  25.1k|void OID::decode_from(BER_Decoder& decoder) {
  226|  25.1k|   const BER_Object obj = decoder.get_next_object();
  227|  25.1k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (227:7): [True: 89, False: 25.0k]
  ------------------
  228|     89|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  229|     89|   }
  230|       |
  231|  25.0k|   if(obj.length() == 0) {
  ------------------
  |  Branch (231:7): [True: 6, False: 25.0k]
  ------------------
  232|      6|      throw BER_Decoding_Error("OID encoding is too short");
  233|      6|   }
  234|       |
  235|  25.0k|   const auto consume = [](BufferSlicer& data) -> uint32_t {
  236|  25.0k|      BOTAN_ASSERT_NOMSG(!data.empty());
  237|  25.0k|      uint32_t b = data.take_byte();
  238|       |
  239|  25.0k|      if(b > 0x7F) {
  240|  25.0k|         b &= 0x7F;
  241|       |
  242|       |         // Even BER requires that the OID have minimal length, ie that
  243|       |         // the first byte of a multibyte encoding cannot be zero
  244|       |         // See X.690 section 8.19.2
  245|  25.0k|         if(b == 0) {
  246|  25.0k|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  247|  25.0k|         }
  248|       |
  249|  25.0k|         while(true) {
  250|  25.0k|            if(data.empty()) {
  251|  25.0k|               throw Decoding_Error("Truncated OID value");
  252|  25.0k|            }
  253|       |
  254|  25.0k|            const uint8_t next = data.take_byte();
  255|  25.0k|            const bool more = (next & 0x80) == 0x80;
  256|  25.0k|            const uint8_t value = next & 0x7F;
  257|       |
  258|  25.0k|            if((b >> (32 - 7)) != 0) {
  259|  25.0k|               throw Decoding_Error("OID component overflow");
  260|  25.0k|            }
  261|       |
  262|  25.0k|            b = (b << 7) | value;
  263|       |
  264|  25.0k|            if(!more) {
  265|  25.0k|               break;
  266|  25.0k|            }
  267|  25.0k|         }
  268|  25.0k|      }
  269|       |
  270|  25.0k|      return b;
  271|  25.0k|   };
  272|       |
  273|  25.0k|   BufferSlicer data(obj.data());
  274|  25.0k|   std::vector<uint32_t> parts;
  275|       |
  276|       |   // Each byte of the DER encoding can result in at most one additional arc,
  277|       |   // except the first byte which always encodes two. Don't reserve for more than
  278|       |   // 16 arcs though; the longest OID in our current table has just 13 arcs.
  279|  25.0k|   parts.reserve(std::min<size_t>(16, obj.length() + 1));
  280|       |
  281|   118k|   while(!data.empty()) {
  ------------------
  |  Branch (281:10): [True: 93.6k, False: 25.0k]
  ------------------
  282|  93.6k|      const uint32_t comp = consume(data);
  283|       |
  284|  93.6k|      if(parts.empty()) {
  ------------------
  |  Branch (284:10): [True: 25.0k, False: 68.5k]
  ------------------
  285|       |         // divide into root and second arc
  286|       |
  287|  25.0k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  288|  25.0k|            if(b0 < 40) {
  289|  25.0k|               return 0;
  290|  25.0k|            } else if(b0 < 80) {
  291|  25.0k|               return 1;
  292|  25.0k|            } else {
  293|  25.0k|               return 2;
  294|  25.0k|            }
  295|  25.0k|         }(comp);
  296|       |
  297|  25.0k|         parts.push_back(root_arc);
  298|  25.0k|         BOTAN_ASSERT_NOMSG(comp >= 40 * root_arc);
  ------------------
  |  |   84|  25.0k|   do {                                                                     \
  |  |   85|  25.0k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  25.0k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 25.0k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  25.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 25.0k]
  |  |  ------------------
  ------------------
  299|  25.0k|         parts.push_back(comp - 40 * root_arc);
  300|  68.5k|      } else {
  301|  68.5k|         parts.push_back(comp);
  302|  68.5k|      }
  303|  93.6k|   }
  304|       |
  305|  25.0k|   m_id = std::move(parts);
  306|  25.0k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_115oid_valid_checkENSt3__14spanIKjLm18446744073709551615EEE:
   26|  15.1k|void oid_valid_check(std::span<const uint32_t> oid) {
   27|  15.1k|   BOTAN_ARG_CHECK(oid.size() >= 2, "OID too short to be valid");
  ------------------
  |  |   35|  15.1k|   do {                                                          \
  |  |   36|  15.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  15.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 15.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  15.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 15.1k]
  |  |  ------------------
  ------------------
   28|  15.1k|   BOTAN_ARG_CHECK(oid[0] <= 2, "OID root out of range");
  ------------------
  |  |   35|  15.1k|   do {                                                          \
  |  |   36|  15.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  15.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 15.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  15.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 15.1k]
  |  |  ------------------
  ------------------
   29|  15.1k|   BOTAN_ARG_CHECK(oid[1] <= 39 || oid[0] == 2, "OID second arc too large");
  ------------------
  |  |   35|  15.1k|   do {                                                          \
  |  |   36|  15.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  15.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 15.1k, False: 0]
  |  |  |  Branch (37:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  15.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 15.1k]
  |  |  ------------------
  ------------------
   30|       |   // This last is a limitation of using 32 bit integers when decoding
   31|       |   // not a limitation of ASN.1 object identifiers in general
   32|  15.1k|   BOTAN_ARG_CHECK(oid[1] <= 0xFFFFFFAF, "OID second arc too large");
  ------------------
  |  |   35|  15.1k|   do {                                                          \
  |  |   36|  15.1k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  15.1k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 15.1k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  15.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 15.1k]
  |  |  ------------------
  ------------------
   33|  15.1k|}
asn1_oid.cpp:_ZZNK5Botan3OID11encode_intoERNS_11DER_EncoderEENK3$_0clERNSt3__16vectorIhNS4_9allocatorIhEEEEj:
  190|  8.79k|   const auto append = [](std::vector<uint8_t>& encoding, uint32_t z) {
  191|  8.79k|      if(z <= 0x7F) {
  ------------------
  |  Branch (191:10): [True: 6.89k, False: 1.89k]
  ------------------
  192|  6.89k|         encoding.push_back(static_cast<uint8_t>(z));
  193|  6.89k|      } else {
  194|  1.89k|         const size_t z7 = (high_bit(z) + 7 - 1) / 7;
  195|       |
  196|  6.87k|         for(size_t j = 0; j != z7; ++j) {
  ------------------
  |  Branch (196:28): [True: 4.97k, False: 1.89k]
  ------------------
  197|  4.97k|            uint8_t zp = static_cast<uint8_t>(z >> (7 * (z7 - j - 1)) & 0x7F);
  198|       |
  199|  4.97k|            if(j != z7 - 1) {
  ------------------
  |  Branch (199:16): [True: 3.07k, False: 1.89k]
  ------------------
  200|  3.07k|               zp |= 0x80;
  201|  3.07k|            }
  202|       |
  203|  4.97k|            encoding.push_back(zp);
  204|  4.97k|         }
  205|  1.89k|      }
  206|  8.79k|   };
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_0clERNS_12BufferSlicerE:
  235|  93.6k|   const auto consume = [](BufferSlicer& data) -> uint32_t {
  236|  93.6k|      BOTAN_ASSERT_NOMSG(!data.empty());
  ------------------
  |  |   84|  93.6k|   do {                                                                     \
  |  |   85|  93.6k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  93.6k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 93.6k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  93.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 93.6k]
  |  |  ------------------
  ------------------
  237|  93.6k|      uint32_t b = data.take_byte();
  238|       |
  239|  93.6k|      if(b > 0x7F) {
  ------------------
  |  Branch (239:10): [True: 16.7k, False: 76.8k]
  ------------------
  240|  16.7k|         b &= 0x7F;
  241|       |
  242|       |         // Even BER requires that the OID have minimal length, ie that
  243|       |         // the first byte of a multibyte encoding cannot be zero
  244|       |         // See X.690 section 8.19.2
  245|  16.7k|         if(b == 0) {
  ------------------
  |  Branch (245:13): [True: 4, False: 16.7k]
  ------------------
  246|      4|            throw Decoding_Error("Leading zero byte in multibyte OID encoding");
  247|      4|         }
  248|       |
  249|  24.7k|         while(true) {
  ------------------
  |  Branch (249:16): [True: 24.7k, Folded]
  ------------------
  250|  24.7k|            if(data.empty()) {
  ------------------
  |  Branch (250:16): [True: 32, False: 24.6k]
  ------------------
  251|     32|               throw Decoding_Error("Truncated OID value");
  252|     32|            }
  253|       |
  254|  24.6k|            const uint8_t next = data.take_byte();
  255|  24.6k|            const bool more = (next & 0x80) == 0x80;
  256|  24.6k|            const uint8_t value = next & 0x7F;
  257|       |
  258|  24.6k|            if((b >> (32 - 7)) != 0) {
  ------------------
  |  Branch (258:16): [True: 20, False: 24.6k]
  ------------------
  259|     20|               throw Decoding_Error("OID component overflow");
  260|     20|            }
  261|       |
  262|  24.6k|            b = (b << 7) | value;
  263|       |
  264|  24.6k|            if(!more) {
  ------------------
  |  Branch (264:16): [True: 16.7k, False: 7.95k]
  ------------------
  265|  16.7k|               break;
  266|  16.7k|            }
  267|  24.6k|         }
  268|  16.7k|      }
  269|       |
  270|  93.5k|      return b;
  271|  93.6k|   };
asn1_oid.cpp:_ZZN5Botan3OID11decode_fromERNS_11BER_DecoderEENK3$_1clEj:
  287|  25.0k|         const uint32_t root_arc = [](uint32_t b0) -> uint32_t {
  288|  25.0k|            if(b0 < 40) {
  ------------------
  |  Branch (288:16): [True: 1.52k, False: 23.4k]
  ------------------
  289|  1.52k|               return 0;
  290|  23.4k|            } else if(b0 < 80) {
  ------------------
  |  Branch (290:23): [True: 6.80k, False: 16.6k]
  ------------------
  291|  6.80k|               return 1;
  292|  16.6k|            } else {
  293|  16.6k|               return 2;
  294|  16.6k|            }
  295|  25.0k|         }(comp);

_ZN5Botan11ASN1_String14is_string_typeENS_9ASN1_TypeE:
  131|    778|bool ASN1_String::is_string_type(ASN1_Type tag) {
  132|    778|   return is_asn1_string_type(tag);
  133|    778|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  135|  4.22k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
  136|  4.22k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (136:7): [True: 28, False: 4.19k]
  ------------------
  137|     28|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
  138|     28|   }
  139|       |
  140|  4.19k|   if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (140:7): [True: 206, False: 3.98k]
  ------------------
  141|    206|      throw Invalid_Argument(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  142|    206|   }
  143|  4.19k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  145|  3.76k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
  162|  3.75k|void ASN1_String::decode_from(BER_Decoder& source) {
  163|  3.75k|   const BER_Object obj = source.get_next_object();
  164|       |
  165|  3.75k|   if(obj.get_class() != ASN1_Class::Universal || !is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (165:7): [True: 6, False: 3.75k]
  |  Branch (165:51): [True: 66, False: 3.68k]
  ------------------
  166|     72|      auto typ = static_cast<uint32_t>(obj.type());
  167|     72|      auto cls = static_cast<uint32_t>(obj.get_class());
  168|     72|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}/{}", typ, cls));
  169|     72|   }
  170|       |
  171|  3.68k|   m_tag = obj.type();
  172|  3.68k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
  173|       |
  174|  3.68k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (174:7): [True: 250, False: 3.43k]
  ------------------
  175|    250|      m_utf8_str = ucs2_to_utf8(m_data);
  176|  3.43k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (176:14): [True: 95, False: 3.34k]
  ------------------
  177|     95|      m_utf8_str = ucs4_to_utf8(m_data);
  178|  3.34k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (178:14): [True: 299, False: 3.04k]
  ------------------
  179|       |      /*
  180|       |      TeletexString is nominally ITU T.61 not ISO-8859-1 but it seems
  181|       |      the majority of implementations actually used that charset here.
  182|       |      */
  183|    299|      m_utf8_str = latin1_to_utf8(m_data);
  184|  3.04k|   } else {
  185|       |      // All other supported string types are UTF-8 or some subset thereof
  186|  3.04k|      m_utf8_str = ASN1::to_string(obj);
  187|       |
  188|  3.04k|      if(!is_valid_asn1_string_content(m_utf8_str, m_tag)) {
  ------------------
  |  Branch (188:10): [True: 34, False: 3.00k]
  ------------------
  189|     34|         throw Decoding_Error(fmt("ASN1_String: Invalid {} encoding", asn1_tag_to_string(m_tag)));
  190|     34|      }
  191|  3.04k|   }
  192|  3.68k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   99|  4.53k|bool is_asn1_string_type(ASN1_Type tag) {
  100|  4.53k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (100:12): [True: 3.50k, False: 1.02k]
  |  Branch (100:47): [True: 317, False: 712]
  |  Branch (100:82): [True: 290, False: 422]
  ------------------
  101|    422|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (101:12): [True: 113, False: 309]
  ------------------
  102|  4.53k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   94|  15.9k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   95|  15.9k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (95:12): [True: 87, False: 15.9k]
  |  Branch (95:47): [True: 8.24k, False: 7.66k]
  |  Branch (95:84): [True: 67, False: 7.59k]
  ------------------
   96|  7.59k|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (96:12): [True: 1.93k, False: 5.65k]
  |  Branch (96:43): [True: 4.60k, False: 1.05k]
  ------------------
   97|  15.9k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_128is_valid_asn1_string_contentERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_9ASN1_TypeE:
  104|  7.23k|bool is_valid_asn1_string_content(const std::string& str, ASN1_Type tag) {
  105|  7.23k|   BOTAN_ASSERT_NOMSG(is_utf8_subset_string_type(tag));
  ------------------
  |  |   84|  7.23k|   do {                                                                     \
  |  |   85|  7.23k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  7.23k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 7.23k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  7.23k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 7.23k]
  |  |  ------------------
  ------------------
  106|       |
  107|  7.23k|   switch(tag) {
  108|  2.16k|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (108:7): [True: 2.16k, False: 5.07k]
  ------------------
  109|  2.16k|         return is_valid_utf8(str);
  110|     28|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (110:7): [True: 28, False: 7.20k]
  ------------------
  111|  4.10k|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (111:7): [True: 4.08k, False: 3.15k]
  ------------------
  112|  5.05k|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (112:7): [True: 942, False: 6.29k]
  ------------------
  113|  5.07k|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (113:7): [True: 23, False: 7.21k]
  ------------------
  114|  5.07k|         return g_char_validator.valid_encoding(str, tag);
  115|      0|      default:
  ------------------
  |  Branch (115:7): [True: 0, False: 7.23k]
  ------------------
  116|      0|         return false;
  117|  7.23k|   }
  118|  7.23k|}
asn1_str.cpp:_ZNK5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator14valid_encodingENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_9ASN1_TypeE:
   25|  8.83k|      constexpr bool valid_encoding(std::string_view str, ASN1_Type tag) const {
   26|  8.83k|         const uint8_t mask = mask_for(tag);
   27|  8.83k|         for(const char c : str) {
  ------------------
  |  Branch (27:27): [True: 8.73k, False: 8.69k]
  ------------------
   28|  8.73k|            const uint8_t codepoint = static_cast<uint8_t>(c);
   29|  8.73k|            const bool is_valid = (m_table[codepoint] & mask) != 0;
   30|       |
   31|  8.73k|            if(!is_valid) {
  ------------------
  |  Branch (31:16): [True: 148, False: 8.58k]
  ------------------
   32|    148|               return false;
   33|    148|            }
   34|  8.73k|         }
   35|       |
   36|  8.69k|         return true;
   37|  8.83k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_131ASN1_String_Codepoint_Validator8mask_forENS_9ASN1_TypeE:
   45|  8.83k|      static constexpr uint8_t mask_for(ASN1_Type tag) {
   46|  8.83k|         switch(tag) {
   47|     28|            case ASN1_Type::NumericString:
  ------------------
  |  Branch (47:13): [True: 28, False: 8.81k]
  ------------------
   48|     28|               return Numeric_String;
   49|  7.84k|            case ASN1_Type::PrintableString:
  ------------------
  |  Branch (49:13): [True: 7.84k, False: 993]
  ------------------
   50|  7.84k|               return Printable_String;
   51|    942|            case ASN1_Type::Ia5String:
  ------------------
  |  Branch (51:13): [True: 942, False: 7.89k]
  ------------------
   52|    942|               return IA5_String;
   53|     23|            case ASN1_Type::VisibleString:
  ------------------
  |  Branch (53:13): [True: 23, False: 8.81k]
  ------------------
   54|     23|               return Visible_String;
   55|      0|            default:
  ------------------
  |  Branch (55:13): [True: 0, False: 8.83k]
  ------------------
   56|      0|               return 0;
   57|  8.83k|         }
   58|  8.83k|      }
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  120|  3.76k|ASN1_Type choose_encoding(std::string_view str) {
  121|  3.76k|   if(g_char_validator.valid_encoding(str, ASN1_Type::PrintableString)) {
  ------------------
  |  Branch (121:7): [True: 3.76k, False: 0]
  ------------------
  122|  3.76k|      return ASN1_Type::PrintableString;
  123|  3.76k|   } else {
  124|      0|      return ASN1_Type::Utf8String;
  125|      0|   }
  126|  3.76k|}

_ZN5Botan9ASN1_TimeC2EthhhhhNS_9ASN1_TypeE:
   43|  11.8k|      m_year(year), m_month(month), m_day(day), m_hour(hour), m_minute(minute), m_second(second), m_tag(tag) {
   44|  11.8k|   if(tag != ASN1_Type::UtcTime && tag != ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (44:7): [True: 628, False: 11.1k]
  |  Branch (44:36): [True: 0, False: 628]
  ------------------
   45|      0|      throw Invalid_Argument("ASN1_Time tag must be UtcTime or GeneralizedTime");
   46|      0|   }
   47|       |
   48|       |   /*
   49|       |   * RFC 5280 Section 4.1.2.5:
   50|       |   *    To indicate that a certificate has no well-defined expiration date,
   51|       |   *    the notAfter SHOULD be assigned the GeneralizedTime value of
   52|       |   *    99991231235959Z.
   53|       |   */
   54|  11.8k|   const uint16_t min_year = 1950;
   55|  11.8k|   const uint16_t max_year = (tag == ASN1_Type::UtcTime) ? 2049 : 9999;
  ------------------
  |  Branch (55:30): [True: 11.1k, False: 628]
  ------------------
   56|       |
   57|  11.8k|   if(m_year < min_year || m_year > max_year) {
  ------------------
  |  Branch (57:7): [True: 9, False: 11.8k]
  |  Branch (57:28): [True: 0, False: 11.8k]
  ------------------
   58|      9|      throw Invalid_Argument(fmt("ASN1_Time year {} is out of range ({} to {})", m_year, min_year, max_year));
   59|      9|   }
   60|       |
   61|  11.8k|   if(m_month < 1 || m_month > 12) {
  ------------------
  |  Branch (61:7): [True: 3, False: 11.7k]
  |  Branch (61:22): [True: 10, False: 11.7k]
  ------------------
   62|     13|      throw Invalid_Argument(fmt("ASN1_Time month {} is out of range", static_cast<uint32_t>(m_month)));
   63|     13|   }
   64|       |
   65|  11.7k|   constexpr uint8_t days_in_month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
   66|       |
   67|  11.7k|   const bool is_leap_year = (m_year % 4 == 0) && (m_year % 100 != 0 || m_year % 400 == 0);
  ------------------
  |  Branch (67:30): [True: 4.34k, False: 7.44k]
  |  Branch (67:52): [True: 4.20k, False: 136]
  |  Branch (67:73): [True: 124, False: 12]
  ------------------
   68|  11.7k|   const uint8_t max_day = (m_month == 2 && is_leap_year) ? 29 : days_in_month[m_month - 1];
  ------------------
  |  Branch (68:29): [True: 638, False: 11.1k]
  |  Branch (68:45): [True: 475, False: 163]
  ------------------
   69|       |
   70|  11.7k|   if(m_day < 1 || m_day > max_day) {
  ------------------
  |  Branch (70:7): [True: 1, False: 11.7k]
  |  Branch (70:20): [True: 18, False: 11.7k]
  ------------------
   71|     19|      throw Invalid_Argument(fmt("ASN1_Time day {} is out of range for month {}",
   72|     19|                                 static_cast<uint32_t>(m_day),
   73|     19|                                 static_cast<uint32_t>(m_month)));
   74|     19|   }
   75|       |
   76|  11.7k|   if(m_hour > 23) {
  ------------------
  |  Branch (76:7): [True: 1, False: 11.7k]
  ------------------
   77|      1|      throw Invalid_Argument(fmt("ASN1_Time hour {} is out of range", static_cast<uint32_t>(m_hour)));
   78|      1|   }
   79|       |
   80|  11.7k|   if(m_minute > 59) {
  ------------------
  |  Branch (80:7): [True: 5, False: 11.7k]
  ------------------
   81|      5|      throw Invalid_Argument(fmt("ASN1_Time minute {} is out of range", static_cast<uint32_t>(m_minute)));
   82|      5|   }
   83|       |
   84|       |   /*
   85|       |   * RFC 5280 is silent on the issue of leap seconds in certificate fields, but both
   86|       |   * OpenSSL and Go reject which suggests they are rarely if ever used in practice.
   87|       |   */
   88|  11.7k|   if(m_second > 59) {
  ------------------
  |  Branch (88:7): [True: 1, False: 11.7k]
  ------------------
   89|      1|      throw Invalid_Argument(fmt("ASN1_Time second {} is out of range", static_cast<uint32_t>(m_second)));
   90|      1|   }
   91|  11.7k|}
_ZN5Botan9ASN1_Time11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  109|  11.8k|ASN1_Time ASN1_Time::from_string(std::string_view t_spec, ASN1_Type tag) {
  110|  11.8k|   BOTAN_ARG_CHECK(tag == ASN1_Type::UtcTime || tag == ASN1_Type::GeneralizedTime, "Invalid tag for ASN1_Time");
  ------------------
  |  |   35|  11.8k|   do {                                                          \
  |  |   36|  11.8k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  12.5k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:12): [True: 11.2k, False: 641]
  |  |  |  Branch (37:12): [True: 641, False: 0]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  11.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 11.8k]
  |  |  ------------------
  ------------------
  111|       |
  112|  11.8k|   if(tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (112:7): [True: 641, False: 11.2k]
  ------------------
  113|    641|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   35|    641|   do {                                                          \
  |  |   36|    641|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|    641|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 8, False: 633]
  |  |  ------------------
  |  |   38|      8|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      8|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      8|      }                                                          \
  |  |   41|    641|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 641]
  |  |  ------------------
  ------------------
  114|  11.2k|   } else {
  115|  11.2k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   35|  11.2k|   do {                                                          \
  |  |   36|  11.2k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  11.2k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 12, False: 11.2k]
  |  |  ------------------
  |  |   38|     12|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|     12|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|     12|      }                                                          \
  |  |   41|  11.2k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 11.2k]
  |  |  ------------------
  ------------------
  116|  11.2k|   }
  117|       |
  118|  11.8k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   35|  11.8k|   do {                                                          \
  |  |   36|  11.8k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  11.8k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 23, False: 11.8k]
  |  |  ------------------
  |  |   38|     23|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|     23|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|     23|      }                                                          \
  |  |   41|  11.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 11.8k]
  |  |  ------------------
  ------------------
  119|       |
  120|  11.8k|   const size_t field_len = 2;
  121|  11.8k|   const size_t year_len = (tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (121:28): [True: 11.2k, False: 673]
  ------------------
  122|       |
  123|  11.8k|   const size_t year_start = 0;
  124|  11.8k|   const size_t month_start = year_start + year_len;
  125|  11.8k|   const size_t day_start = month_start + field_len;
  126|  11.8k|   const size_t hour_start = day_start + field_len;
  127|  11.8k|   const size_t min_start = hour_start + field_len;
  128|  11.8k|   const size_t sec_start = min_start + field_len;
  129|       |
  130|  11.8k|   uint32_t year = to_u32bit(t_spec.substr(year_start, year_len));
  131|  11.8k|   const uint32_t month = to_u32bit(t_spec.substr(month_start, field_len));
  132|  11.8k|   const uint32_t day = to_u32bit(t_spec.substr(day_start, field_len));
  133|  11.8k|   const uint32_t hour = to_u32bit(t_spec.substr(hour_start, field_len));
  134|  11.8k|   const uint32_t minute = to_u32bit(t_spec.substr(min_start, field_len));
  135|  11.8k|   const uint32_t second = to_u32bit(t_spec.substr(sec_start, field_len));
  136|       |
  137|  11.8k|   if(tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (137:7): [True: 11.1k, False: 697]
  ------------------
  138|       |      // Interpret the two digit year by the 1950/2050 split (RFC 5280 Section 4.1.2.5.1)
  139|  11.1k|      year += (year >= 50) ? 1900 : 2000;
  ------------------
  |  Branch (139:15): [True: 375, False: 10.8k]
  ------------------
  140|  11.1k|   }
  141|       |
  142|  11.8k|   return ASN1_Time(static_cast<uint16_t>(year),
  143|  11.8k|                    static_cast<uint8_t>(month),
  144|  11.8k|                    static_cast<uint8_t>(day),
  145|  11.8k|                    static_cast<uint8_t>(hour),
  146|  11.8k|                    static_cast<uint8_t>(minute),
  147|  11.8k|                    static_cast<uint8_t>(second),
  148|  11.8k|                    tag);
  149|  11.8k|}
_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
  168|  12.1k|void ASN1_Time::decode_from(BER_Decoder& source) {
  169|  12.1k|   const BER_Object ber_time = source.get_next_object();
  170|       |
  171|  12.1k|   if(ber_time.get_class() != ASN1_Class::Universal ||
  ------------------
  |  Branch (171:7): [True: 189, False: 11.9k]
  ------------------
  172|  11.9k|      (ber_time.type() != ASN1_Type::UtcTime && ber_time.type() != ASN1_Type::GeneralizedTime)) {
  ------------------
  |  Branch (172:8): [True: 703, False: 11.2k]
  |  Branch (172:49): [True: 62, False: 641]
  ------------------
  173|    183|      throw Decoding_Error(fmt("ASN1_Time: Unexpected tag {}/{}",
  174|    183|                               static_cast<uint32_t>(ber_time.type()),
  175|    183|                               static_cast<uint32_t>(ber_time.get_class())));
  176|    183|   }
  177|       |
  178|  11.9k|   try {
  179|       |      // Assigning only after a successful parse means that a decoding error
  180|       |      // cannot leave this object in a partially written state
  181|  11.9k|      *this = ASN1_Time::from_string(ASN1::to_string(ber_time), ber_time.type());
  182|  11.9k|   } catch(Invalid_Argument& e) {
  183|    117|      throw Decoding_Error(fmt("Invalid ASN1_Time encoding: {}", e.what()));
  184|    117|   }
  185|  11.9k|}

_ZN5Botan11BER_DecoderD2Ev:
  456|  77.8k|BER_Decoder::~BER_Decoder() = default;
_ZNK5Botan11BER_Decoder10more_itemsEv:
  461|  60.7k|bool BER_Decoder::more_items() const {
  462|  60.7k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (462:7): [True: 15.1k, False: 45.6k]
  |  Branch (462:34): [True: 15.1k, False: 0]
  ------------------
  463|  15.1k|      return false;
  464|  15.1k|   }
  465|  45.6k|   return true;
  466|  60.7k|}
_ZN5Botan11BER_Decoder10verify_endEv:
  471|  10.4k|BER_Decoder& BER_Decoder::verify_end() {
  472|  10.4k|   return verify_end("BER_Decoder::verify_end called, but data remains");
  473|  10.4k|}
_ZN5Botan11BER_Decoder10verify_endENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  478|  10.4k|BER_Decoder& BER_Decoder::verify_end(std::string_view err) {
  479|  10.4k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (479:7): [True: 60, False: 10.4k]
  |  Branch (479:35): [True: 0, False: 10.4k]
  ------------------
  480|     60|      throw Decoding_Error(err);
  481|     60|   }
  482|  10.4k|   return (*this);
  483|  10.4k|}
_ZN5Botan11BER_Decoder10read_bytesENSt3__14spanIhLm18446744073709551615EEE:
  505|  48.9k|size_t BER_Decoder::read_bytes(std::span<uint8_t> out) {
  506|  48.9k|   BOTAN_ASSERT_NOMSG(m_source != nullptr);
  ------------------
  |  |   84|  48.9k|   do {                                                                     \
  |  |   85|  48.9k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  48.9k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 48.9k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  48.9k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 48.9k]
  |  |  ------------------
  ------------------
  507|  48.9k|   return m_source->read(out.data(), out.size());
  508|  48.9k|}
_ZN5Botan11BER_Decoder16peek_next_objectEv:
  510|  3.13k|const BER_Object& BER_Decoder::peek_next_object() {
  511|  3.13k|   if(!m_pushed.is_set()) {
  ------------------
  |  Branch (511:7): [True: 2.50k, False: 630]
  ------------------
  512|  2.50k|      m_pushed = get_next_object();
  513|  2.50k|   }
  514|       |
  515|  3.13k|   return m_pushed;
  516|  3.13k|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  521|   163k|BER_Object BER_Decoder::get_next_object() {
  522|   163k|   BER_Object next;
  523|       |
  524|   163k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (524:7): [True: 19.4k, False: 144k]
  ------------------
  525|  19.4k|      std::swap(next, m_pushed);
  526|  19.4k|      return next;
  527|  19.4k|   }
  528|       |
  529|   144k|   for(;;) {
  530|   144k|      ASN1_Type type_tag = ASN1_Type::NoObject;
  531|   144k|      ASN1_Class class_tag = ASN1_Class::NoObject;
  532|   144k|      decode_tag(m_source, type_tag, class_tag);
  533|   144k|      next.set_tagging(type_tag, class_tag);
  534|   144k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (534:10): [True: 280, False: 143k]
  ------------------
  535|    280|         return next;
  536|    280|      }
  537|       |
  538|   143k|      const size_t allow_indef = m_limits.allow_ber_encoding() ? m_limits.max_nested_indefinite_length() : 0;
  ------------------
  |  Branch (538:34): [True: 0, False: 143k]
  ------------------
  539|   143k|      const bool der_mode = m_limits.require_der_encoding();
  540|   143k|      const auto dl = decode_length(m_source, allow_indef, der_mode, is_constructed(class_tag));
  541|       |
  542|       |      // Per X.690 8.1.5 the only valid EOC encoding is the two-octet
  543|       |      // sequence 0x00 0x00. Reject any other length encoding on a tag of
  544|       |      // (Eoc, Universal) before we consume the "content" bytes.
  545|   143k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal &&
  ------------------
  |  Branch (545:10): [True: 3.76k, False: 140k]
  |  Branch (545:40): [True: 209, False: 3.55k]
  ------------------
  546|    209|         (dl.content_length() != 0 || dl.indefinite_length())) {
  ------------------
  |  Branch (546:11): [True: 108, False: 101]
  |  Branch (546:39): [True: 0, False: 101]
  ------------------
  547|    108|         throw BER_Decoding_Error("EOC marker with non-zero length");
  548|    108|      }
  549|       |
  550|   143k|      if(const auto max_size = m_limits.max_object_size(); max_size && dl.content_length() > *max_size) {
  ------------------
  |  Branch (550:60): [True: 142k, False: 871]
  |  Branch (550:72): [True: 46, False: 142k]
  ------------------
  551|     46|         throw BER_Decoding_Error("Encoded object exceeds maximum size");
  552|     46|      }
  553|       |
  554|   143k|      if(!m_source->check_available(dl.total_length())) {
  ------------------
  |  Branch (554:10): [True: 1.14k, False: 142k]
  ------------------
  555|  1.14k|         throw BER_Decoding_Error("Value truncated");
  556|  1.14k|      }
  557|       |
  558|   142k|      uint8_t* out = next.mutable_bits(dl.content_length());
  559|   142k|      if(m_source->read(out, dl.content_length()) != dl.content_length()) {
  ------------------
  |  Branch (559:10): [True: 0, False: 142k]
  ------------------
  560|      0|         throw BER_Decoding_Error("Value truncated");
  561|      0|      }
  562|       |
  563|   142k|      if(dl.indefinite_length()) {
  ------------------
  |  Branch (563:10): [True: 0, False: 142k]
  ------------------
  564|       |         // After reading the data consume the 2-byte EOC
  565|      0|         uint8_t eoc[2] = {0xFF, 0xFF};
  566|      0|         if(m_source->read(eoc, 2) != 2 || eoc[0] != 0x00 || eoc[1] != 0x00) {
  ------------------
  |  Branch (566:13): [True: 0, False: 0]
  |  Branch (566:44): [True: 0, False: 0]
  |  Branch (566:62): [True: 0, False: 0]
  ------------------
  567|      0|            throw BER_Decoding_Error("Missing or malformed EOC marker");
  568|      0|         }
  569|      0|      }
  570|       |
  571|   142k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (571:10): [True: 101, False: 142k]
  ------------------
  572|    101|         if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (572:13): [True: 101, False: 0]
  ------------------
  573|    101|            throw BER_Decoding_Error("Detected EOC marker in DER structure");
  574|    101|         }
  575|       |         // An EOC marker is only valid as an indefinite-length terminator, which
  576|       |         // is consumed above when reading the indefinite-length object. A
  577|       |         // standalone EOC is rejected unless the caller opted to tolerate it.
  578|      0|         if(m_limits.allow_standalone_eoc()) {
  ------------------
  |  Branch (578:13): [True: 0, False: 0]
  ------------------
  579|      0|            continue;
  580|      0|         }
  581|      0|         throw BER_Decoding_Error("Encountered EOC marker outside of indefinite-length encoding");
  582|      0|      }
  583|       |
  584|   142k|      break;
  585|   142k|   }
  586|       |
  587|   142k|   return next;
  588|   144k|}
_ZN5Botan11BER_Decoder9push_backEONS_10BER_ObjectE:
  612|  17.2k|void BER_Decoder::push_back(BER_Object&& obj) {
  613|  17.2k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (613:7): [True: 0, False: 17.2k]
  ------------------
  614|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  615|      0|   }
  616|  17.2k|   m_pushed = std::move(obj);
  617|  17.2k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  619|  59.4k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  620|  59.4k|   BER_Object obj = get_next_object();
  621|  59.4k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  622|       |
  623|       |   // In DER mode the elements of a universal SET must appear in sorted order
  624|  59.4k|   if(m_limits.require_der_encoding() && type_tag == ASN1_Type::Set && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (624:7): [True: 57.6k, False: 1.73k]
  |  Branch (624:42): [True: 3.97k, False: 53.7k]
  |  Branch (624:72): [True: 3.97k, False: 0]
  ------------------
  625|  3.97k|      verify_set_is_sorted(std::span<const uint8_t>{obj.bits(), obj.length()});
  626|  3.97k|   }
  627|       |
  628|  59.4k|   BER_Decoder child(std::move(obj), this);
  629|  59.4k|   return child;
  630|  59.4k|}
_ZN5Botan11BER_Decoder8end_consEv:
  635|  41.5k|BER_Decoder& BER_Decoder::end_cons() {
  636|  41.5k|   if(m_parent == nullptr) {
  ------------------
  |  Branch (636:7): [True: 0, False: 41.5k]
  ------------------
  637|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  638|      0|   }
  639|  41.5k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (639:7): [True: 110, False: 41.4k]
  |  Branch (639:35): [True: 78, False: 41.3k]
  ------------------
  640|    188|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  641|    188|   }
  642|  41.3k|   return (*m_parent);
  643|  41.5k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  646|  57.4k|      m_limits(parent != nullptr ? parent->limits() : BER_Decoder::Limits::BER()), m_parent(parent) {
  ------------------
  |  Branch (646:16): [True: 57.4k, False: 0]
  ------------------
  647|  57.4k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  648|  57.4k|   m_source = m_data_src.get();
  649|  57.4k|}
_ZN5Botan11BER_DecoderC2ERNS_10DataSourceENS0_6LimitsE:
  659|  3.85k|BER_Decoder::BER_Decoder(DataSource& src, Limits limits) : m_limits(limits), m_source(&src) {}
_ZN5Botan11BER_DecoderC2ENSt3__14spanIKhLm18446744073709551615EEENS0_6LimitsE:
  664|  16.4k|BER_Decoder::BER_Decoder(std::span<const uint8_t> buf, Limits limits) : m_limits(limits) {
  665|  16.4k|   m_data_src = std::make_unique<DataSource_Memory>(buf);
  666|  16.4k|   m_source = m_data_src.get();
  667|  16.4k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  676|  70.1k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type type_tag, ASN1_Class class_tag) {
  677|       |   // TODO support this case properly
  678|  70.1k|   if(type_tag != ASN1_Type::NoObject || class_tag != ASN1_Class::NoObject) {
  ------------------
  |  Branch (678:7): [True: 0, False: 70.1k]
  |  Branch (678:42): [True: 0, False: 70.1k]
  ------------------
  679|      0|      throw Not_Implemented("BER_Decoder::decode(ASN1_Object) does not support implicit tagged decoding");
  680|      0|   }
  681|  70.1k|   obj.decode_from(*this);
  682|  70.1k|   return (*this);
  683|  70.1k|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  707|     53|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  708|     53|   const BER_Object obj = get_next_object();
  709|     53|   obj.assert_is_a(type_tag, class_tag);
  710|       |
  711|     53|   if(obj.length() != 1) {
  ------------------
  |  Branch (711:7): [True: 12, False: 41]
  ------------------
  712|     12|      throw BER_Decoding_Error("BER boolean value had invalid size");
  713|     12|   }
  714|       |
  715|     41|   const uint8_t val = obj.bits()[0];
  716|       |
  717|       |   // DER requires boolean values to be exactly 0x00 or 0xFF
  718|     41|   if(m_limits.require_der_encoding() && val != 0x00 && val != 0xFF) {
  ------------------
  |  Branch (718:7): [True: 41, False: 0]
  |  Branch (718:42): [True: 23, False: 18]
  |  Branch (718:57): [True: 11, False: 12]
  ------------------
  719|     11|      throw BER_Decoding_Error("Detected non-canonical boolean encoding in DER structure");
  720|     11|   }
  721|       |
  722|     30|   out = (val != 0) ? true : false;
  ------------------
  |  Branch (722:10): [True: 12, False: 18]
  ------------------
  723|       |
  724|     30|   return (*this);
  725|     41|}
_ZN5Botan11BER_Decoder6decodeERmNS_9ASN1_TypeENS_10ASN1_ClassE:
  730|  6.29k|BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  731|  6.29k|   BigInt integer;
  732|  6.29k|   decode(integer, type_tag, class_tag);
  733|       |
  734|  6.29k|   if(integer.signum() < 0) {
  ------------------
  |  Branch (734:7): [True: 185, False: 6.10k]
  ------------------
  735|    185|      throw BER_Decoding_Error("Decoded small integer value was negative");
  736|    185|   }
  737|       |
  738|  6.10k|   if(integer.bits() > 32) {
  ------------------
  |  Branch (738:7): [True: 54, False: 6.05k]
  ------------------
  739|     54|      throw BER_Decoding_Error("Decoded integer value larger than expected");
  740|     54|   }
  741|       |
  742|  6.05k|   out = 0;
  743|  22.7k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (743:22): [True: 16.6k, False: 6.05k]
  ------------------
  744|  16.6k|      out = (out << 8) | integer.byte_at(3 - i);
  745|  16.6k|   }
  746|       |
  747|  6.05k|   return (*this);
  748|  6.10k|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  780|  15.1k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  781|  15.1k|   const BER_Object obj = get_next_object();
  782|  15.1k|   obj.assert_is_a(type_tag, class_tag);
  783|       |
  784|       |   // An INTEGER must have at least one content octet (X.690 section 8.3.1)
  785|  15.1k|   if(obj.length() == 0) {
  ------------------
  |  Branch (785:7): [True: 21, False: 15.1k]
  ------------------
  786|     21|      throw BER_Decoding_Error("INTEGER encoding has no content octets");
  787|     21|   }
  788|       |
  789|       |   // DER requires minimal INTEGER encoding (X.690 section 8.3.2)
  790|  15.1k|   if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (790:7): [True: 13.2k, False: 1.87k]
  ------------------
  791|  13.2k|      if(obj.length() > 1) {
  ------------------
  |  Branch (791:10): [True: 6.89k, False: 6.34k]
  ------------------
  792|  6.89k|         if(obj.bits()[0] == 0x00 && (obj.bits()[1] & 0x80) == 0) {
  ------------------
  |  Branch (792:13): [True: 353, False: 6.54k]
  |  Branch (792:38): [True: 5, False: 348]
  ------------------
  793|      5|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  794|      5|         }
  795|  6.88k|         if(obj.bits()[0] == 0xFF && (obj.bits()[1] & 0x80) != 0) {
  ------------------
  |  Branch (795:13): [True: 152, False: 6.73k]
  |  Branch (795:38): [True: 17, False: 135]
  ------------------
  796|     17|            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
  797|     17|         }
  798|  6.88k|      }
  799|  13.2k|   }
  800|       |
  801|  15.0k|   out = ASN1::integer_from_contents(obj.data());
  802|       |
  803|  15.0k|   return (*this);
  804|  15.1k|}
_ZN5Botan4ASN121integer_from_contentsENSt3__14spanIKhLm18446744073709551615EEE:
  806|  14.1k|BigInt ASN1::integer_from_contents(std::span<const uint8_t> contents) {
  807|  14.1k|   if(contents.empty()) {
  ------------------
  |  Branch (807:7): [True: 0, False: 14.1k]
  ------------------
  808|      0|      throw BER_Decoding_Error("INTEGER encoding has no content octets");
  809|      0|   }
  810|       |
  811|  14.1k|   BigInt out;
  812|       |
  813|  14.1k|   const bool negative = (contents[0] & 0x80) == 0x80;
  814|       |
  815|  14.1k|   if(negative) {
  ------------------
  |  Branch (815:7): [True: 2.03k, False: 12.0k]
  ------------------
  816|  2.03k|      secure_vector<uint8_t> vec(contents.begin(), contents.end());
  817|  2.77k|      for(size_t i = vec.size(); i > 0; --i) {
  ------------------
  |  Branch (817:34): [True: 2.77k, False: 0]
  ------------------
  818|  2.77k|         const bool gt0 = (vec[i - 1] > 0);
  819|  2.77k|         vec[i - 1] -= 1;
  820|  2.77k|         if(gt0) {
  ------------------
  |  Branch (820:13): [True: 2.03k, False: 743]
  ------------------
  821|  2.03k|            break;
  822|  2.03k|         }
  823|  2.77k|      }
  824|  16.0k|      for(auto& byte : vec) {
  ------------------
  |  Branch (824:22): [True: 16.0k, False: 2.03k]
  ------------------
  825|  16.0k|         byte = ~byte;
  826|  16.0k|      }
  827|  2.03k|      out._assign_from_bytes(vec);
  828|  2.03k|      out.set_sign(BigInt::Negative);
  829|  12.0k|   } else {
  830|  12.0k|      out._assign_from_bytes(contents);
  831|  12.0k|   }
  832|       |
  833|  14.1k|   return out;
  834|  14.1k|}
_ZN5Botan11BER_Decoder23decode_into_byte_vectorERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
 1038|  13.9k|                                                  ASN1_Class class_tag) {
 1039|  13.9k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (1039:7): [True: 0, False: 13.9k]
  |  Branch (1039:46): [True: 0, False: 0]
  ------------------
 1040|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
 1041|      0|   }
 1042|       |
 1043|  13.9k|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag, m_limits);
 1044|  13.9k|   return (*this);
 1045|  13.9k|}
_ZN5Botan11BER_Decoder16decode_bitstringERNS_14ASN1_BitStringENS_9ASN1_TypeENS_10ASN1_ClassE:
 1047|  3.06k|BER_Decoder& BER_Decoder::decode_bitstring(ASN1_BitString& out, ASN1_Type type_tag, ASN1_Class class_tag) {
 1048|  3.06k|   const BER_Object obj = get_next_object();
 1049|       |
 1050|  3.06k|   std::vector<uint8_t> bits;
 1051|  3.06k|   uint8_t unused_bits = 0;
 1052|       |
 1053|  3.06k|   if(is_constructed(obj.class_tag())) {
  ------------------
  |  Branch (1053:7): [True: 5, False: 3.06k]
  ------------------
 1054|      5|      obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
 1055|      5|      if(m_limits.require_der_encoding()) {
  ------------------
  |  Branch (1055:10): [True: 1, False: 4]
  ------------------
 1056|      1|         throw BER_Decoding_Error("Detected constructed string encoding in DER structure");
 1057|      1|      }
 1058|      4|      bits.reserve(obj.length());  // upper possible bound on the output size
 1059|      4|      unused_bits = asn1_concat_constructed_bit_string(bits, obj, m_limits, 0);
 1060|  3.06k|   } else {
 1061|  3.06k|      unused_bits = asn1_bitstring_unused_bits(obj, type_tag, class_tag, m_limits.require_der_encoding());
 1062|  3.06k|      bits.assign(obj.bits() + 1, obj.bits() + obj.length());
 1063|  3.06k|   }
 1064|       |
 1065|  3.06k|   if(unused_bits > 0 && !bits.empty()) {
  ------------------
  |  Branch (1065:7): [True: 20, False: 3.04k]
  |  Branch (1065:26): [True: 20, False: 0]
  ------------------
 1066|     20|      bits.back() &= static_cast<uint8_t>(0xFF << unused_bits);
 1067|     20|   }
 1068|       |
 1069|  3.06k|   out = ASN1_BitString(std::move(bits), unused_bits);
 1070|  3.06k|   return (*this);
 1071|  3.06k|}
_ZN5Botan11BER_Decoder22decode_named_bitstringERmmNS_9ASN1_TypeENS_10ASN1_ClassE:
 1076|     46|                                                 ASN1_Class class_tag) {
 1077|     46|   if(width > 64) {
  ------------------
  |  Branch (1077:7): [True: 0, False: 46]
  ------------------
 1078|      0|      throw Invalid_Argument("BER_Decoder: Named BIT STRING width is too large");
 1079|      0|   }
 1080|       |
 1081|     46|   ASN1_BitString bits;
 1082|     46|   decode_bitstring(bits, type_tag, class_tag);
 1083|       |
 1084|     46|   if(bits.bit_length() > width) {
  ------------------
  |  Branch (1084:7): [True: 5, False: 41]
  ------------------
 1085|      5|      throw BER_Decoding_Error("Named BIT STRING exceeds declared width");
 1086|      5|   }
 1087|       |
 1088|     41|   if(m_limits.require_der_encoding() && bits.bit_length() > 0 && !bits.bit_at(bits.bit_length() - 1)) {
  ------------------
  |  Branch (1088:7): [True: 32, False: 9]
  |  Branch (1088:42): [True: 29, False: 3]
  |  Branch (1088:67): [True: 5, False: 24]
  ------------------
 1089|      5|      throw BER_Decoding_Error("Named BIT STRING is not minimally encoded");
 1090|      5|   }
 1091|       |
 1092|     36|   uint64_t decoded = 0;
 1093|    191|   for(size_t bit = 0; bit != bits.bit_length(); ++bit) {
  ------------------
  |  Branch (1093:24): [True: 155, False: 36]
  ------------------
 1094|    155|      if(bits.bit_at(bit)) {
  ------------------
  |  Branch (1094:10): [True: 113, False: 42]
  ------------------
 1095|    113|         decoded |= uint64_t(1) << (width - 1 - bit);
 1096|    113|      }
 1097|    155|   }
 1098|       |
 1099|     36|   out = decoded;
 1100|     36|   return (*this);
 1101|     41|}
_ZN5Botan4ASN120is_single_der_objectENSt3__14spanIKhLm18446744073709551615EEENS_9ASN1_TypeENS_10ASN1_ClassE:
 1105|    961|bool is_single_der_object(std::span<const uint8_t> bytes, ASN1_Type expected_type, ASN1_Class expected_class) {
 1106|    961|   if(bytes.empty()) {
  ------------------
  |  Branch (1106:7): [True: 0, False: 961]
  ------------------
 1107|      0|      return false;
 1108|      0|   }
 1109|       |
 1110|    961|   try {
 1111|    961|      DataSource_Span src(bytes);
 1112|       |
 1113|    961|      ASN1_Type type_tag = ASN1_Type::NoObject;
 1114|    961|      ASN1_Class class_tag = ASN1_Class::NoObject;
 1115|    961|      const size_t tag_bytes = decode_tag(&src, type_tag, class_tag);
 1116|       |
 1117|    961|      if(type_tag != expected_type || class_tag != expected_class) {
  ------------------
  |  Branch (1117:10): [True: 708, False: 253]
  |  Branch (1117:39): [True: 8, False: 245]
  ------------------
 1118|    659|         return false;
 1119|    659|      }
 1120|       |
 1121|    302|      const auto dl = decode_length(&src, /*allow_indef=*/0, /*der_mode=*/true, is_constructed(expected_class));
 1122|       |
 1123|    302|      const size_t header_bytes = tag_bytes + dl.field_length();
 1124|    302|      if(header_bytes > bytes.size()) {
  ------------------
  |  Branch (1124:10): [True: 0, False: 302]
  ------------------
 1125|      0|         return false;
 1126|      0|      }
 1127|    302|      return dl.content_length() == bytes.size() - header_bytes;
 1128|    302|   } catch(Decoding_Error&) {
 1129|     67|      return false;
 1130|     67|   }
 1131|    961|}
_ZN5Botan4ASN122is_der_sequence_headerENSt3__14spanIKhLm18446744073709551615EEE:
 1133|    355|bool is_der_sequence_header(std::span<const uint8_t> bytes) {
 1134|    355|   return is_single_der_object(bytes, ASN1_Type::Sequence, ASN1_Class::Universal | ASN1_Class::Constructed);
 1135|    355|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|   145k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|   145k|   auto b = ber->read_byte();
   31|       |
   32|   145k|   if(!b) {
  ------------------
  |  Branch (32:7): [True: 280, False: 144k]
  ------------------
   33|    280|      type_tag = ASN1_Type::NoObject;
   34|    280|      class_tag = ASN1_Class::NoObject;
   35|    280|      return 0;
   36|    280|   }
   37|       |
   38|   144k|   if((*b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (38:7): [True: 143k, False: 1.23k]
  ------------------
   39|   143k|      type_tag = ASN1_Type(*b & 0x1F);
   40|   143k|      class_tag = ASN1_Class(*b & 0xE0);
   41|       |      // The EOC marker is primitive; a constructed universal tag 0 has no
   42|       |      // valid meaning and would otherwise bypass the EOC handling, which
   43|       |      // matches on (Eoc, Universal) exactly
   44|   143k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (44:10): [True: 3.88k, False: 139k]
  |  Branch (44:40): [True: 25, False: 3.85k]
  ------------------
   45|     25|         throw BER_Decoding_Error("EOC tag with constructed encoding");
   46|     25|      }
   47|   143k|      return 1;
   48|   143k|   }
   49|       |
   50|  1.23k|   size_t tag_bytes = 1;
   51|  1.23k|   class_tag = ASN1_Class(*b & 0xE0);
   52|       |
   53|  1.23k|   uint32_t tag_buf = 0;
   54|  4.16k|   while(true) {
  ------------------
  |  Branch (54:10): [True: 4.16k, Folded]
  ------------------
   55|  4.16k|      b = ber->read_byte();
   56|  4.16k|      if(!b) {
  ------------------
  |  Branch (56:10): [True: 49, False: 4.12k]
  ------------------
   57|     49|         throw BER_Decoding_Error("Long-form tag truncated");
   58|     49|      }
   59|       |      // Reject if shifting in another 7 bits would overflow the uint32_t tag
   60|  4.12k|      if((tag_buf >> 25) != 0) {
  ------------------
  |  Branch (60:10): [True: 67, False: 4.05k]
  ------------------
   61|     67|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   62|     67|      }
   63|       |      // This is required even by BER (see X.690 section 8.1.2.4.2 sentence c).
   64|       |      // Bits 7-1 of the first subsequent octet must not be all zero; this rules
   65|       |      // out both 0x80 (continuation with no data) and 0x00 (a long-form encoding
   66|       |      // of tag value 0, which collides with the EOC marker).
   67|  4.05k|      if(tag_bytes == 1 && (*b & 0x7F) == 0) {
  ------------------
  |  Branch (67:10): [True: 1.20k, False: 2.84k]
  |  Branch (67:28): [True: 49, False: 1.15k]
  ------------------
   68|     49|         throw BER_Decoding_Error("Long form tag with leading zero");
   69|     49|      }
   70|  4.00k|      ++tag_bytes;
   71|  4.00k|      tag_buf = (tag_buf << 7) | (*b & 0x7F);
   72|  4.00k|      if((*b & 0x80) == 0) {
  ------------------
  |  Branch (72:10): [True: 1.07k, False: 2.93k]
  ------------------
   73|  1.07k|         break;
   74|  1.07k|      }
   75|  4.00k|   }
   76|       |   // Per X.690 8.1.2.2, tag values 0-30 shall be encoded in the short form.
   77|       |   // Long-form encoding is reserved for tag values >= 31 (X.690 8.1.2.3).
   78|       |   // This is unconditional and applies to BER as well as DER.
   79|  1.07k|   if(tag_buf <= 30) {
  ------------------
  |  Branch (79:7): [True: 46, False: 1.02k]
  ------------------
   80|     46|      throw BER_Decoding_Error("Long-form tag encoding used for small tag value");
   81|     46|   }
   82|       |
   83|  1.02k|   if(tag_buf == static_cast<uint32_t>(ASN1_Type::NoObject)) {
  ------------------
  |  Branch (83:7): [True: 7, False: 1.01k]
  ------------------
   84|      7|      throw BER_Decoding_Error("Tag value collides with internal sentinel");
   85|      7|   }
   86|       |
   87|       |   // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
   88|  1.01k|   type_tag = ASN1_Type(tag_buf);
   89|  1.01k|   return tag_bytes;
   90|  1.02k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceEmbb:
  135|   143k|BerDecodedLength decode_length(DataSource* ber, size_t allow_indef, bool der_mode, bool constructed) {
  136|   143k|   uint8_t b = 0;
  137|   143k|   if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (137:7): [True: 206, False: 143k]
  ------------------
  138|    206|      throw BER_Decoding_Error("Length field not found");
  139|    206|   }
  140|   143k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (140:7): [True: 132k, False: 11.4k]
  ------------------
  141|   132k|      return BerDecodedLength(b, 1);
  142|   132k|   }
  143|       |
  144|  11.4k|   const size_t num_length_bytes = (b & 0x7F);
  145|  11.4k|   if(num_length_bytes > 4) {
  ------------------
  |  Branch (145:7): [True: 363, False: 11.0k]
  ------------------
  146|    363|      throw BER_Decoding_Error("Length field is too large");
  147|    363|   }
  148|       |
  149|  11.0k|   const size_t field_size = 1 + num_length_bytes;
  150|       |
  151|  11.0k|   if(num_length_bytes == 0) {
  ------------------
  |  Branch (151:7): [True: 24, False: 11.0k]
  ------------------
  152|     24|      if(der_mode) {
  ------------------
  |  Branch (152:10): [True: 24, False: 0]
  ------------------
  153|     24|         throw BER_Decoding_Error("Detected indefinite-length encoding in DER structure");
  154|     24|      } else if(!constructed) {
  ------------------
  |  Branch (154:17): [True: 0, False: 0]
  ------------------
  155|       |         // Indefinite length is only valid for constructed types (X.690 8.1.3.2)
  156|      0|         throw BER_Decoding_Error("Indefinite-length encoding used with non-constructed type");
  157|      0|      } else if(allow_indef == 0) {
  ------------------
  |  Branch (157:17): [True: 0, False: 0]
  ------------------
  158|      0|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
  159|      0|      } else {
  160|       |         // find_eoc returns bytes up to and including the EOC marker.
  161|       |         // Return the content length; the caller consumes the EOC separately.
  162|      0|         const size_t eoc_len = find_eoc(ber, /*base_offset=*/0, allow_indef - 1);
  163|      0|         if(eoc_len < 2) {
  ------------------
  |  Branch (163:13): [True: 0, False: 0]
  ------------------
  164|      0|            throw BER_Decoding_Error("Invalid EOC encoding");
  165|      0|         }
  166|      0|         return BerDecodedLength::indefinite(eoc_len - 2, field_size);
  167|      0|      }
  168|     24|   }
  169|       |
  170|  11.0k|   size_t length = 0;
  171|       |
  172|  31.6k|   for(size_t i = 0; i != num_length_bytes; ++i) {
  ------------------
  |  Branch (172:22): [True: 20.6k, False: 11.0k]
  ------------------
  173|  20.6k|      if(ber->read_byte(b) == 0) {
  ------------------
  |  Branch (173:10): [True: 56, False: 20.5k]
  ------------------
  174|     56|         throw BER_Decoding_Error("Corrupted length field");
  175|     56|      }
  176|       |      // Can't overflow since we already checked that num_length_bytes <= 4
  177|  20.5k|      length = (length << 8) | b;
  178|  20.5k|   }
  179|       |
  180|       |   // DER requires shortest possible length encoding
  181|  11.0k|   if(der_mode) {
  ------------------
  |  Branch (181:7): [True: 11.0k, False: 0]
  ------------------
  182|  11.0k|      if(length < 128) {
  ------------------
  |  Branch (182:10): [True: 40, False: 10.9k]
  ------------------
  183|     40|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  184|     40|      }
  185|  10.9k|      if(num_length_bytes > 1 && length < (size_t(1) << ((num_length_bytes - 1) * 8))) {
  ------------------
  |  Branch (185:10): [True: 9.29k, False: 1.68k]
  |  Branch (185:34): [True: 6, False: 9.28k]
  ------------------
  186|      6|         throw BER_Decoding_Error("Detected non-canonical length encoding in DER structure");
  187|      6|      }
  188|  10.9k|   }
  189|       |
  190|  10.9k|   return BerDecodedLength(length, field_size);
  191|  11.0k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emm:
  108|   143k|            BerDecodedLength(content_length, field_length, false) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_116BerDecodedLengthC2Emmb:
  125|   143k|            m_content_length(content_length), m_field_length(field_length), m_indefinite(indefinite) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18peek_tagEPKNS_10DataSourceEmRNS_9ASN1_TypeERNS_10ASN1_ClassE:
  197|  5.14k|size_t peek_tag(const DataSource* src, size_t offset, ASN1_Type& type_tag, ASN1_Class& class_tag) {
  198|  5.14k|   uint8_t b = 0;
  199|  5.14k|   if(src->peek(&b, 1, offset) == 0) {
  ------------------
  |  Branch (199:7): [True: 0, False: 5.14k]
  ------------------
  200|      0|      type_tag = ASN1_Type::NoObject;
  201|      0|      class_tag = ASN1_Class::NoObject;
  202|      0|      return 0;
  203|      0|   }
  204|       |
  205|  5.14k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (205:7): [True: 4.93k, False: 214]
  ------------------
  206|  4.93k|      type_tag = ASN1_Type(b & 0x1F);
  207|  4.93k|      class_tag = ASN1_Class(b & 0xE0);
  208|       |      // The EOC marker is primitive; a constructed universal tag 0 has no
  209|       |      // valid meaning and would otherwise bypass the EOC handling, which
  210|       |      // matches on (Eoc, Universal) exactly
  211|  4.93k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (211:10): [True: 658, False: 4.27k]
  |  Branch (211:40): [True: 4, False: 654]
  ------------------
  212|      4|         throw BER_Decoding_Error("EOC tag with constructed encoding");
  213|      4|      }
  214|  4.92k|      return 1;
  215|  4.93k|   }
  216|       |
  217|    214|   class_tag = ASN1_Class(b & 0xE0);
  218|    214|   size_t tag_bytes = 1;
  219|    214|   uint32_t tag_buf = 0;
  220|       |
  221|    604|   while(true) {
  ------------------
  |  Branch (221:10): [True: 604, Folded]
  ------------------
  222|    604|      if(src->peek(&b, 1, offset + tag_bytes) == 0) {
  ------------------
  |  Branch (222:10): [True: 9, False: 595]
  ------------------
  223|      9|         throw BER_Decoding_Error("Long-form tag truncated");
  224|      9|      }
  225|       |      // Reject if shifting in another 7 bits would overflow the uint32_t tag
  226|    595|      if((tag_buf >> 25) != 0) {
  ------------------
  |  Branch (226:10): [True: 11, False: 584]
  ------------------
  227|     11|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
  228|     11|      }
  229|       |      // Required even by BER (X.690 section 8.1.2.4.2 sentence c).
  230|       |      // Bits 7-1 of the first subsequent octet must not be all zero; this rules
  231|       |      // out both 0x80 (continuation with no data) and 0x00 (a long-form encoding
  232|       |      // of tag value 0, which collides with the EOC marker).
  233|    584|      if(tag_bytes == 1 && (b & 0x7F) == 0) {
  ------------------
  |  Branch (233:10): [True: 212, False: 372]
  |  Branch (233:28): [True: 3, False: 209]
  ------------------
  234|      3|         throw BER_Decoding_Error("Long form tag with leading zero");
  235|      3|      }
  236|    581|      ++tag_bytes;
  237|    581|      tag_buf = (tag_buf << 7) | (b & 0x7F);
  238|    581|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (238:10): [True: 191, False: 390]
  ------------------
  239|    191|         break;
  240|    191|      }
  241|    581|   }
  242|       |
  243|       |   // Per X.690 8.1.2.2, tag values 0-30 shall be encoded in the short form.
  244|       |   // Long-form encoding is reserved for tag values >= 31 (X.690 8.1.2.3).
  245|       |   // This is unconditional and applies to BER as well as DER.
  246|    191|   if(tag_buf <= 30) {
  ------------------
  |  Branch (246:7): [True: 6, False: 185]
  ------------------
  247|      6|      throw BER_Decoding_Error("Long-form tag encoding used for small tag value");
  248|      6|   }
  249|       |
  250|    185|   if(tag_buf == static_cast<uint32_t>(ASN1_Type::NoObject)) {
  ------------------
  |  Branch (250:7): [True: 1, False: 184]
  ------------------
  251|      1|      throw BER_Decoding_Error("Tag value collides with internal sentinel");
  252|      1|   }
  253|       |
  254|       |   // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
  255|    184|   type_tag = ASN1_Type(tag_buf);
  256|    184|   return tag_bytes;
  257|    185|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_111peek_lengthEPNS_10DataSourceEmRmmbb:
  265|  5.11k|   DataSource* src, size_t offset, size_t& field_size, size_t allow_indef, bool constructed, bool der_mode) {
  266|  5.11k|   uint8_t b = 0;
  267|  5.11k|   if(src->peek(&b, 1, offset) == 0) {
  ------------------
  |  Branch (267:7): [True: 8, False: 5.10k]
  ------------------
  268|      8|      throw BER_Decoding_Error("Length field not found");
  269|      8|   }
  270|       |
  271|  5.10k|   field_size = 1;
  272|  5.10k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (272:7): [True: 4.99k, False: 106]
  ------------------
  273|  4.99k|      return b;
  274|  4.99k|   }
  275|       |
  276|    106|   const size_t num_length_bytes = (b & 0x7F);
  277|    106|   field_size += num_length_bytes;
  278|    106|   if(field_size > 5) {
  ------------------
  |  Branch (278:7): [True: 18, False: 88]
  ------------------
  279|     18|      throw BER_Decoding_Error("Length field is too large");
  280|     18|   }
  281|       |
  282|     88|   if(num_length_bytes == 0) {
  ------------------
  |  Branch (282:7): [True: 4, False: 84]
  ------------------
  283|       |      // Indefinite length is not allowed in DER
  284|      4|      if(der_mode) {
  ------------------
  |  Branch (284:10): [True: 4, False: 0]
  ------------------
  285|      4|         throw BER_Decoding_Error("Detected indefinite-length encoding in DER structure");
  286|      4|      }
  287|       |      // Indefinite length is only valid for constructed types (X.690 8.1.3.2)
  288|      0|      if(!constructed) {
  ------------------
  |  Branch (288:10): [True: 0, False: 0]
  ------------------
  289|      0|         throw BER_Decoding_Error("Indefinite-length encoding used with non-constructed type");
  290|      0|      }
  291|      0|      if(allow_indef == 0) {
  ------------------
  |  Branch (291:10): [True: 0, False: 0]
  ------------------
  292|      0|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
  293|      0|      }
  294|      0|      return find_eoc(src, offset + 1, allow_indef - 1);
  295|      0|   }
  296|       |
  297|     84|   size_t length = 0;
  298|    318|   for(size_t i = 0; i < num_length_bytes; ++i) {
  ------------------
  |  Branch (298:22): [True: 243, False: 75]
  ------------------
  299|    243|      if(src->peek(&b, 1, offset + 1 + i) == 0) {
  ------------------
  |  Branch (299:10): [True: 9, False: 234]
  ------------------
  300|      9|         throw BER_Decoding_Error("Corrupted length field");
  301|      9|      }
  302|    234|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (302:10): [True: 0, False: 234]
  ------------------
  303|      0|         throw BER_Decoding_Error("Field length overflow");
  304|      0|      }
  305|    234|      length = (length << 8) | b;
  306|    234|   }
  307|     75|   return length;
  308|     84|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_114is_constructedENS_10ASN1_ClassE:
   22|   169k|bool is_constructed(ASN1_Class class_tag) {
   23|   169k|   return (static_cast<uint32_t>(class_tag) & static_cast<uint32_t>(ASN1_Class::Constructed)) != 0;
   24|   169k|}
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength14content_lengthEv:
  114|   568k|      size_t content_length() const { return m_content_length; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength17indefinite_lengthEv:
  121|   141k|      bool indefinite_length() const { return m_indefinite; }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength12total_lengthEv:
  117|   142k|      size_t total_length() const { return m_indefinite ? m_content_length + 2 : m_content_length; }
  ------------------
  |  Branch (117:44): [True: 0, False: 142k]
  ------------------
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120verify_set_is_sortedENSt3__14spanIKhLm18446744073709551615EEE:
  426|  3.97k|void verify_set_is_sorted(std::span<const uint8_t> content) {
  427|  3.97k|   DataSource_Span src(content);
  428|  3.97k|   size_t offset = 0;
  429|  3.97k|   std::optional<std::span<const uint8_t>> prev;
  430|       |
  431|  8.98k|   while(offset < content.size()) {
  ------------------
  |  Branch (431:10): [True: 5.14k, False: 3.83k]
  ------------------
  432|  5.14k|      ASN1_Type type_tag = ASN1_Type::NoObject;
  433|  5.14k|      ASN1_Class class_tag = ASN1_Class::NoObject;
  434|  5.14k|      const size_t tag_size = peek_tag(&src, offset, type_tag, class_tag);
  435|       |
  436|  5.14k|      size_t length_size = 0;
  437|  5.14k|      const size_t item_size =
  438|  5.14k|         peek_length(&src, offset + tag_size, length_size, /*allow_indef=*/0, is_constructed(class_tag), true);
  439|       |
  440|  5.14k|      const auto end = checked_add(offset, tag_size, length_size, item_size);
  441|  5.14k|      if(!end || *end > content.size()) {
  ------------------
  |  Branch (441:10): [True: 73, False: 5.07k]
  |  Branch (441:18): [True: 77, False: 4.99k]
  ------------------
  442|     77|         throw BER_Decoding_Error("SET element exceeds available data");
  443|     77|      }
  444|       |
  445|  5.07k|      const auto elem = content.subspan(offset, *end - offset);
  446|  5.07k|      if(prev && std::lexicographical_compare(elem.begin(), elem.end(), prev->begin(), prev->end())) {
  ------------------
  |  Branch (446:10): [True: 1.05k, False: 4.01k]
  |  Branch (446:18): [True: 64, False: 995]
  ------------------
  447|     64|         throw BER_Decoding_Error("Detected unsorted SET in DER structure");
  448|     64|      }
  449|  5.00k|      prev = elem;
  450|  5.00k|      offset = *end;
  451|  5.00k|   }
  452|  3.97k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_126asn1_bitstring_unused_bitsERKNS_10BER_ObjectENS_9ASN1_TypeENS_10ASN1_ClassEb:
  990|  3.05k|uint8_t asn1_bitstring_unused_bits(const BER_Object& obj, ASN1_Type type_tag, ASN1_Class class_tag, bool require_der) {
  991|  3.05k|   obj.assert_is_a(type_tag, class_tag);
  992|  3.05k|   BOTAN_ASSERT_NOMSG(!is_constructed(obj));
  ------------------
  |  |   84|  3.05k|   do {                                                                     \
  |  |   85|  3.05k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  3.05k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 3.05k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  3.05k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 3.05k]
  |  |  ------------------
  ------------------
  993|       |
  994|  3.05k|   if(obj.length() == 0) {
  ------------------
  |  Branch (994:7): [True: 3, False: 3.04k]
  ------------------
  995|      3|      throw BER_Decoding_Error("Invalid BIT STRING");
  996|      3|   }
  997|       |
  998|  3.04k|   const uint8_t unused_bits = obj.bits()[0];
  999|       |
 1000|  3.04k|   if(unused_bits >= 8) {
  ------------------
  |  Branch (1000:7): [True: 7, False: 3.04k]
  ------------------
 1001|      7|      throw BER_Decoding_Error("Invalid number of unused bits in BIT STRING");
 1002|      7|   }
 1003|       |
 1004|  3.04k|   if(obj.length() == 1 && unused_bits != 0) {
  ------------------
  |  Branch (1004:7): [True: 37, False: 3.00k]
  |  Branch (1004:28): [True: 5, False: 32]
  ------------------
 1005|      5|      throw BER_Decoding_Error("Invalid BIT STRING");
 1006|      5|   }
 1007|       |
 1008|  3.03k|   if(require_der && unused_bits > 0) {
  ------------------
  |  Branch (1008:7): [True: 3.01k, False: 24]
  |  Branch (1008:22): [True: 29, False: 2.98k]
  ------------------
 1009|     29|      const uint8_t last_byte = obj.bits()[obj.length() - 1];
 1010|     29|      if((last_byte & ((1 << unused_bits) - 1)) != 0) {
  ------------------
  |  Branch (1010:10): [True: 9, False: 20]
  ------------------
 1011|      9|         throw BER_Decoding_Error("Detected non-zero padding bits in BIT STRING in DER structure");
 1012|      9|      }
 1013|     29|   }
 1014|       |
 1015|  3.02k|   return unused_bits;
 1016|  3.03k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_114is_constructedERKNS_10BER_ObjectE:
  838|  16.9k|bool is_constructed(const BER_Object& obj) {
  839|  16.9k|   return is_constructed(obj.class_tag());
  840|  16.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_115DataSource_SpanC2ENSt3__14spanIKhLm18446744073709551615EEE:
  414|  4.93k|      explicit DataSource_Span(std::span<const uint8_t> buf) : m_buf(buf) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_115DataSource_Span4readEPhm:
  392|  1.78k|      size_t read(uint8_t out[], size_t length) override {
  393|  1.78k|         const size_t got = std::min(m_buf.size() - m_offset, length);
  394|  1.78k|         copy_mem(out, m_buf.data() + m_offset, got);
  395|  1.78k|         m_offset += got;
  396|  1.78k|         return got;
  397|  1.78k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_115DataSource_Span4peekEPhmm:
  399|  11.1k|      size_t peek(uint8_t out[], size_t length, size_t peek_offset) const override {
  400|  11.1k|         if(peek_offset >= m_buf.size() - m_offset) {
  ------------------
  |  Branch (400:13): [True: 26, False: 11.0k]
  ------------------
  401|     26|            return 0;
  402|     26|         }
  403|  11.0k|         const size_t got = std::min(m_buf.size() - m_offset - peek_offset, length);
  404|  11.0k|         copy_mem(out, m_buf.data() + m_offset + peek_offset, got);
  405|  11.0k|         return got;
  406|  11.1k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_116BerDecodedLength12field_lengthEv:
  119|    235|      size_t field_length() const { return m_field_length; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  379|  57.4k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  349|   366k|      size_t read(uint8_t out[], size_t length) override {
  350|   366k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   84|   366k|   do {                                                                     \
  |  |   85|   366k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|   366k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 366k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|   366k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 366k]
  |  |  ------------------
  ------------------
  351|   366k|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  352|   366k|         copy_mem(out, m_obj.bits() + m_offset, got);
  353|   366k|         m_offset += got;
  354|   366k|         return got;
  355|   366k|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  370|   102k|      bool check_available(size_t n) override {
  371|   102k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   84|   102k|   do {                                                                     \
  |  |   85|   102k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|   102k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 102k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|   102k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 102k]
  |  |  ------------------
  ------------------
  372|   102k|         return (n <= (m_obj.length() - m_offset));
  373|   102k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  375|  93.4k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  377|  93.4k|      size_t get_bytes_read() const override { return m_offset; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassERKNS_11BER_Decoder6LimitsE:
  932|  13.9k|                               const BER_Decoder::Limits& limits) {
  933|       |   // DER requires BIT STRING and OCTET STRING to use primitive encoding;
  934|       |   // in BER the constructed (fragmented) form is decoded by concatenation
  935|  13.9k|   if(is_constructed(obj)) {
  ------------------
  |  Branch (935:7): [True: 3, False: 13.9k]
  ------------------
  936|      3|      obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  937|       |
  938|      3|      if(limits.require_der_encoding()) {
  ------------------
  |  Branch (938:10): [True: 1, False: 2]
  ------------------
  939|      1|         throw BER_Decoding_Error("Detected constructed string encoding in DER structure");
  940|      1|      }
  941|       |
  942|       |      // Concatenate into a temporary so a failed decode leaves buffer unmodified
  943|      2|      std::vector<uint8_t, Alloc> concat;
  944|      2|      concat.reserve(obj.length());  // upper possible bound on the output size
  945|      2|      if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (945:10): [True: 0, False: 2]
  ------------------
  946|      0|         asn1_concat_constructed_octet_string(concat, obj, limits, 0);
  947|      2|      } else {
  948|      2|         asn1_concat_constructed_bit_string(concat, obj, limits, 0);
  949|      2|      }
  950|      2|      buffer = std::move(concat);
  951|      2|      return;
  952|      3|   }
  953|       |
  954|  13.9k|   obj.assert_is_a(type_tag, class_tag);
  955|       |
  956|  13.9k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (956:7): [True: 13.9k, False: 16]
  ------------------
  957|  13.9k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  958|  13.9k|   } else {
  959|     16|      if(obj.length() == 0) {
  ------------------
  |  Branch (959:10): [True: 0, False: 16]
  ------------------
  960|      0|         throw BER_Decoding_Error("Invalid BIT STRING");
  961|      0|      }
  962|       |
  963|     16|      const uint8_t unused_bits = obj.bits()[0];
  964|       |
  965|     16|      if(unused_bits >= 8) {
  ------------------
  |  Branch (965:10): [True: 0, False: 16]
  ------------------
  966|      0|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  967|      0|      }
  968|       |
  969|       |      // Empty BIT STRING with unused bits > 0 ...
  970|     16|      if(unused_bits > 0 && obj.length() < 2) {
  ------------------
  |  Branch (970:10): [True: 0, False: 16]
  |  Branch (970:29): [True: 0, False: 0]
  ------------------
  971|      0|         throw BER_Decoding_Error("Invalid BIT STRING");
  972|      0|      }
  973|       |
  974|       |      // DER requires unused bits in BIT STRING to be zero (X.690 section 11.2.2)
  975|     16|      if(limits.require_der_encoding() && unused_bits > 0) {
  ------------------
  |  Branch (975:10): [True: 0, False: 16]
  |  Branch (975:43): [True: 0, False: 0]
  ------------------
  976|      0|         const uint8_t last_byte = obj.bits()[obj.length() - 1];
  977|      0|         if((last_byte & ((1 << unused_bits) - 1)) != 0) {
  ------------------
  |  Branch (977:13): [True: 0, False: 0]
  ------------------
  978|      0|            throw BER_Decoding_Error("Detected non-zero padding bits in BIT STRING in DER structure");
  979|      0|         }
  980|      0|      }
  981|       |
  982|     16|      buffer.resize(obj.length() - 1);
  983|       |
  984|     16|      if(obj.length() > 1) {
  ------------------
  |  Branch (984:10): [True: 0, False: 16]
  ------------------
  985|      0|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  986|      0|      }
  987|     16|   }
  988|  13.9k|}

_ZN5Botan11DER_EncoderC2ERNSt3__16vectorIhNS1_9allocatorIhEEEE:
   89|  4.45k|DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   90|  4.45k|   m_append_output = [&vec](const uint8_t b[], size_t l) {
   91|  4.45k|      if(l > 0) {
   92|  4.45k|         vec.insert(vec.end(), b, b + l);
   93|  4.45k|      }
   94|  4.45k|   };
   95|  4.45k|}
_ZN5Botan11DER_Encoder12DER_Sequence13push_contentsERS0_:
  100|    243|void DER_Encoder::DER_Sequence::push_contents(DER_Encoder& der) {
  101|    243|   const auto real_class_tag = m_class_tag | ASN1_Class::Constructed;
  102|       |
  103|    243|   if(m_sort_contents) {
  ------------------
  |  Branch (103:7): [True: 0, False: 243]
  ------------------
  104|      0|      std::sort(m_set_contents.begin(), m_set_contents.end());
  105|      0|      for(const auto& set_elem : m_set_contents) {
  ------------------
  |  Branch (105:32): [True: 0, False: 0]
  ------------------
  106|      0|         m_contents += set_elem;
  107|      0|      }
  108|      0|      m_set_contents.clear();
  109|      0|   }
  110|       |
  111|    243|   der.add_object(m_type_tag, real_class_tag, m_contents.data(), m_contents.size());
  112|    243|   m_contents.clear();
  113|    243|}
_ZN5Botan11DER_Encoder12DER_Sequence9add_bytesEPKhmS3_m:
  130|    243|void DER_Encoder::DER_Sequence::add_bytes(const uint8_t hdr[], size_t hdr_len, const uint8_t val[], size_t val_len) {
  131|    243|   if(m_sort_contents) {
  ------------------
  |  Branch (131:7): [True: 0, False: 243]
  ------------------
  132|      0|      secure_vector<uint8_t> m;
  133|      0|      m.reserve(hdr_len + val_len);
  134|      0|      m += std::make_pair(hdr, hdr_len);
  135|      0|      m += std::make_pair(val, val_len);
  136|      0|      m_set_contents.push_back(std::move(m));
  137|    243|   } else {
  138|    243|      m_contents += std::make_pair(hdr, hdr_len);
  139|    243|      m_contents += std::make_pair(val, val_len);
  140|    243|   }
  141|    243|}
_ZN5Botan11DER_Encoder12DER_SequenceC2ENS_9ASN1_TypeENS_10ASN1_ClassEb:
  154|    243|      m_type_tag(type_tag),
  155|    243|      m_class_tag(class_tag),
  156|    243|      m_sort_contents(sort_contents || (type_tag == ASN1_Type::Set && class_tag == ASN1_Class::Universal)) {}
  ------------------
  |  Branch (156:23): [True: 0, False: 243]
  |  Branch (156:41): [True: 0, False: 243]
  |  Branch (156:71): [True: 0, False: 0]
  ------------------
_ZN5Botan11DER_Encoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  192|    243|DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  193|    243|   return start_cons(type_tag, class_tag, false);
  194|    243|}
_ZN5Botan11DER_Encoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassEb:
  200|    243|DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag, bool sort_contents) {
  201|    243|   m_subsequences.push_back(DER_Sequence(type_tag, class_tag, sort_contents));
  202|    243|   return (*this);
  203|    243|}
_ZN5Botan11DER_Encoder8end_consEv:
  208|    243|DER_Encoder& DER_Encoder::end_cons() {
  209|    243|   if(m_subsequences.empty()) {
  ------------------
  |  Branch (209:7): [True: 0, False: 243]
  ------------------
  210|      0|      throw Invalid_State("DER_Encoder::end_cons: No such sequence");
  211|      0|   }
  212|       |
  213|    243|   DER_Sequence last_seq = std::move(m_subsequences[m_subsequences.size() - 1]);
  214|    243|   m_subsequences.pop_back();
  215|    243|   last_seq.push_contents(*this);
  216|       |
  217|    243|   return (*this);
  218|    243|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEPKhm:
  285|  4.69k|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
  286|  4.69k|   std::vector<uint8_t> hdr;
  287|  4.69k|   encode_tag(hdr, type_tag, class_tag);
  288|  4.69k|   encode_length(hdr, length);
  289|       |
  290|  4.69k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (290:7): [True: 243, False: 4.45k]
  ------------------
  291|    243|      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
  292|  4.45k|   } else if(m_append_output) {
  ------------------
  |  Branch (292:14): [True: 4.44k, False: 4]
  ------------------
  293|  4.44k|      m_append_output(hdr.data(), hdr.size());
  294|  4.44k|      m_append_output(rep, length);
  295|  4.44k|   } else {
  296|      4|      m_default_outbuf += hdr;
  297|      4|      m_default_outbuf += std::make_pair(rep, length);
  298|      4|   }
  299|       |
  300|  4.69k|   return (*this);
  301|  4.69k|}
_ZN5Botan4ASN116integer_contentsERKNS_6BigIntE:
  356|  8.76k|std::vector<uint8_t> ASN1::integer_contents(const BigInt& n) {
  357|  8.76k|   if(n == 0) {
  ------------------
  |  Branch (357:7): [True: 330, False: 8.43k]
  ------------------
  358|    330|      return {0x00};
  359|    330|   }
  360|       |
  361|       |   // Serialize magnitude with one extra leading byte
  362|  8.43k|   auto contents = n.serialize(n.bytes() + 1);
  363|       |
  364|  8.43k|   if(n.signum() < 0) {
  ------------------
  |  Branch (364:7): [True: 936, False: 7.50k]
  ------------------
  365|       |      // Two's complement: bitwise NOT then increment
  366|  7.86k|      for(auto& byte : contents) {
  ------------------
  |  Branch (366:22): [True: 7.86k, False: 936]
  ------------------
  367|  7.86k|         byte = ~byte;
  368|  7.86k|      }
  369|  1.32k|      for(size_t i = contents.size(); i > 0; --i) {
  ------------------
  |  Branch (369:39): [True: 1.32k, False: 0]
  ------------------
  370|  1.32k|         if(++contents[i - 1] != 0) {
  ------------------
  |  Branch (370:13): [True: 936, False: 389]
  ------------------
  371|    936|            break;
  372|    936|         }
  373|  1.32k|      }
  374|    936|   }
  375|       |
  376|       |   /*
  377|       |   * DER requires the leading byte be emitted only if it required
  378|       |   */
  379|  8.43k|   BOTAN_ASSERT_NOMSG(contents.size() >= 2);
  ------------------
  |  |   84|  8.43k|   do {                                                                     \
  |  |   85|  8.43k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  8.43k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 8.43k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  8.43k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 8.43k]
  |  |  ------------------
  ------------------
  380|  8.43k|   const bool leading_byte_redundant =
  381|  8.43k|      (contents[0] == 0x00 && (contents[1] & 0x80) == 0) || (contents[0] == 0xFF && (contents[1] & 0x80) != 0);
  ------------------
  |  Branch (381:8): [True: 7.50k, False: 936]
  |  Branch (381:31): [True: 7.19k, False: 312]
  |  Branch (381:62): [True: 936, False: 312]
  |  Branch (381:85): [True: 812, False: 124]
  ------------------
  382|       |
  383|  8.43k|   if(leading_byte_redundant) {
  ------------------
  |  Branch (383:7): [True: 8.00k, False: 436]
  ------------------
  384|  8.00k|      contents.erase(contents.begin());
  385|  8.00k|   }
  386|  8.43k|   return contents;
  387|  8.76k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_110encode_tagERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeENS_10ASN1_ClassE:
   26|  4.69k|void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   27|  4.69k|   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   28|  4.69k|   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
   29|       |
   30|  4.69k|   if((class_tag | 0xE0) != 0xE0) {
  ------------------
  |  Branch (30:7): [True: 4, False: 4.69k]
  ------------------
   31|      4|      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   32|      4|   }
   33|       |
   34|  4.69k|   if(type_tag <= 30) {
  ------------------
  |  Branch (34:7): [True: 4.49k, False: 195]
  ------------------
   35|  4.49k|      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   36|  4.49k|   } else {
   37|    195|      size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
   38|    195|      blocks = (blocks - (blocks % 7)) / 7;
   39|       |
   40|    195|      BOTAN_ASSERT_NOMSG(blocks > 0);
  ------------------
  |  |   84|    195|   do {                                                                     \
  |  |   85|    195|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|    195|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 195]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|    195|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 195]
  |  |  ------------------
  ------------------
   41|       |
   42|    195|      encoded_tag.push_back(static_cast<uint8_t>(class_tag | 0x1F));
   43|    727|      for(size_t i = 0; i != blocks - 1; ++i) {
  ------------------
  |  Branch (43:25): [True: 532, False: 195]
  ------------------
   44|    532|         encoded_tag.push_back(0x80 | ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
   45|    532|      }
   46|    195|      encoded_tag.push_back(type_tag & 0x7F);
   47|    195|   }
   48|  4.69k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_113encode_lengthERNSt3__16vectorIhNS1_9allocatorIhEEEEm:
   53|  4.69k|void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   54|  4.69k|   if(length <= 127) {
  ------------------
  |  Branch (54:7): [True: 4.69k, False: 0]
  ------------------
   55|  4.69k|      encoded_length.push_back(static_cast<uint8_t>(length));
   56|  4.69k|   } else {
   57|      0|      const size_t bytes_needed = significant_bytes(length);
   58|       |
   59|      0|      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));
   60|       |
   61|      0|      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
  ------------------
  |  Branch (61:53): [True: 0, False: 0]
  ------------------
   62|      0|         encoded_length.push_back(get_byte_var(i, length));
   63|      0|      }
   64|      0|   }
   65|  4.69k|}
der_enc.cpp:_ZZN5Botan11DER_EncoderC1ERNSt3__16vectorIhNS1_9allocatorIhEEEEENK3$_0clEPKhm:
   90|  8.89k|   m_append_output = [&vec](const uint8_t b[], size_t l) {
   91|  8.89k|      if(l > 0) {
  ------------------
  |  Branch (91:10): [True: 8.78k, False: 115]
  ------------------
   92|  8.78k|         vec.insert(vec.end(), b, b + l);
   93|  8.78k|      }
   94|  8.89k|   };

_ZN5Botan7OID_MapC2Ev:
   11|      1|OID_Map::OID_Map() {
   12|      1|   m_str2oid = OID_Map::load_str2oid_map();
   13|      1|   m_oid2str = OID_Map::load_oid2str_map();
   14|      1|}
_ZN5Botan7OID_Map15global_registryEv:
   16|    960|OID_Map& OID_Map::global_registry() {
   17|    960|   static OID_Map g_map;
   18|    960|   return g_map;
   19|    960|}
_ZN5Botan7OID_Map7str2oidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   88|    960|OID OID_Map::str2oid(std::string_view str) {
   89|    960|   if(auto oid = lookup_static_oid_name(str)) {
  ------------------
  |  Branch (89:12): [True: 960, False: 0]
  ------------------
   90|    960|      return std::move(*oid);
   91|    960|   }
   92|       |
   93|      0|   const lock_guard_type<mutex_type> lock(m_mutex);
   94|      0|   const auto i = m_str2oid.find(std::string(str));
   95|      0|   if(i != m_str2oid.end()) {
  ------------------
  |  Branch (95:7): [True: 0, False: 0]
  ------------------
   96|      0|      return i->second;
   97|      0|   }
   98|       |
   99|      0|   return OID();
  100|      0|}

_ZN5Botan7OID_Map22lookup_static_oid_nameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  746|    960|std::optional<OID> OID_Map::lookup_static_oid_name(std::string_view req) {
  747|    960|   const uint32_t hc = hash_oid_name(req);
  748|       |
  749|    960|   switch(hc) {
  750|      0|      case 0x00545:
  ------------------
  |  Branch (750:7): [True: 0, False: 960]
  ------------------
  751|      0|         return if_match(req, "Twofish/GCM", {1, 3, 6, 1, 4, 1, 25258, 3, 102});
  752|      0|      case 0x00CF3:
  ------------------
  |  Branch (752:7): [True: 0, False: 960]
  ------------------
  753|      0|         return if_match(req, "SphincsPlus-sha2-192f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 4});
  754|      0|      case 0x015FE:
  ------------------
  |  Branch (754:7): [True: 0, False: 960]
  ------------------
  755|      0|         return if_match(req, "FrodoKEM-640-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 14, 1});
  756|      0|      case 0x01F9E:
  ------------------
  |  Branch (756:7): [True: 0, False: 960]
  ------------------
  757|      0|         return if_match(req, "MD5", {1, 2, 840, 113549, 2, 5});
  758|      0|      case 0x02293:
  ------------------
  |  Branch (758:7): [True: 0, False: 960]
  ------------------
  759|      0|         return if_match(req, "SphincsPlus-shake-192f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 4});
  760|      0|      case 0x02B93:
  ------------------
  |  Branch (760:7): [True: 0, False: 960]
  ------------------
  761|      0|         return if_match(req, "Microsoft SmartcardLogon", {1, 3, 6, 1, 4, 1, 311, 20, 2, 2});
  762|      0|      case 0x041D5:
  ------------------
  |  Branch (762:7): [True: 0, False: 960]
  ------------------
  763|      0|         return if_match(req, "secp160k1", {1, 3, 132, 0, 9});
  764|      0|      case 0x044B3:
  ------------------
  |  Branch (764:7): [True: 0, False: 960]
  ------------------
  765|      0|         return if_match(req, "Camellia-256/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 8});
  766|      0|      case 0x048B2:
  ------------------
  |  Branch (766:7): [True: 0, False: 960]
  ------------------
  767|      0|         return if_match(req, "secp160r1", {1, 3, 132, 0, 8});
  768|      0|      case 0x048B3:
  ------------------
  |  Branch (768:7): [True: 0, False: 960]
  ------------------
  769|      0|         return if_match(req, "secp160r2", {1, 3, 132, 0, 30});
  770|      0|      case 0x05CDA:
  ------------------
  |  Branch (770:7): [True: 0, False: 960]
  ------------------
  771|      0|         return if_match(req, "X520.Country", {2, 5, 4, 6});
  772|      0|      case 0x07783:
  ------------------
  |  Branch (772:7): [True: 0, False: 960]
  ------------------
  773|      0|         return if_match(req, "PKIX.ServerAuth", {1, 3, 6, 1, 5, 5, 7, 3, 1});
  774|      0|      case 0x086C7:
  ------------------
  |  Branch (774:7): [True: 0, False: 960]
  ------------------
  775|      0|         return if_match(req, "numsp384d1", {1, 3, 6, 1, 4, 1, 25258, 4, 2});
  776|      0|      case 0x08A92:
  ------------------
  |  Branch (776:7): [True: 0, False: 960]
  ------------------
  777|      0|         return if_match(req, "RSA/PKCS1v15(SHA-1)", {1, 2, 840, 113549, 1, 1, 5});
  778|      0|      case 0x09EA0:
  ------------------
  |  Branch (778:7): [True: 0, False: 960]
  ------------------
  779|      0|         return if_match(req, "DES/CBC", {1, 3, 14, 3, 2, 7});
  780|      0|      case 0x0B2D6:
  ------------------
  |  Branch (780:7): [True: 0, False: 960]
  ------------------
  781|      0|         return if_match(req, "ECDSA/SHA-3(512)", {2, 16, 840, 1, 101, 3, 4, 3, 12});
  782|      0|      case 0x0BA72:
  ------------------
  |  Branch (782:7): [True: 0, False: 960]
  ------------------
  783|      0|         return if_match(req, "SphincsPlus-sha2-128s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 1});
  784|      0|      case 0x0BE23:
  ------------------
  |  Branch (784:7): [True: 0, False: 960]
  ------------------
  785|      0|         return if_match(req, "ECGDSA", {1, 3, 36, 3, 3, 2, 5, 2, 1});
  786|      0|      case 0x0C109:
  ------------------
  |  Branch (786:7): [True: 0, False: 960]
  ------------------
  787|      0|         return if_match(req, "PKCS9.FriendlyName", {1, 2, 840, 113549, 1, 9, 20});
  788|      0|      case 0x0D012:
  ------------------
  |  Branch (788:7): [True: 0, False: 960]
  ------------------
  789|      0|         return if_match(req, "SphincsPlus-shake-128s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 1});
  790|      0|      case 0x0DCE9:
  ------------------
  |  Branch (790:7): [True: 0, False: 960]
  ------------------
  791|      0|         return if_match(req, "ClassicMcEliece_8192128f", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 10});
  792|      0|      case 0x0E52A:
  ------------------
  |  Branch (792:7): [True: 0, False: 960]
  ------------------
  793|      0|         return if_match(req, "numsp512d1", {1, 3, 6, 1, 4, 1, 25258, 4, 3});
  794|      0|      case 0x0F9CC:
  ------------------
  |  Branch (794:7): [True: 0, False: 960]
  ------------------
  795|      0|         return if_match(req, "PKCS9.UnstructuredName", {1, 2, 840, 113549, 1, 9, 2});
  796|      0|      case 0x0FF45:
  ------------------
  |  Branch (796:7): [True: 0, False: 960]
  ------------------
  797|      0|         return if_match(req, "Camellia-256/GCM", {0, 3, 4401, 5, 3, 1, 9, 46});
  798|      0|      case 0x1033D:
  ------------------
  |  Branch (798:7): [True: 0, False: 960]
  ------------------
  799|      0|         return if_match(req, "DSA/SHA-3(384)", {2, 16, 840, 1, 101, 3, 4, 3, 7});
  800|      0|      case 0x1139D:
  ------------------
  |  Branch (800:7): [True: 0, False: 960]
  ------------------
  801|      0|         return if_match(req, "secp192k1", {1, 3, 132, 0, 31});
  802|      0|      case 0x113D6:
  ------------------
  |  Branch (802:7): [True: 0, False: 960]
  ------------------
  803|      0|         return if_match(req, "X520.DNQualifier", {2, 5, 4, 46});
  804|      0|      case 0x11A7A:
  ------------------
  |  Branch (804:7): [True: 0, False: 960]
  ------------------
  805|      0|         return if_match(req, "secp192r1", {1, 2, 840, 10045, 3, 1, 1});
  806|      0|      case 0x12096:
  ------------------
  |  Branch (806:7): [True: 0, False: 960]
  ------------------
  807|      0|         return if_match(req, "SM2_Kex", {1, 2, 156, 10197, 1, 301, 2});
  808|      0|      case 0x13FC1:
  ------------------
  |  Branch (808:7): [True: 0, False: 960]
  ------------------
  809|      0|         return if_match(req, "X520.GenerationalQualifier", {2, 5, 4, 44});
  810|      0|      case 0x1445B:
  ------------------
  |  Branch (810:7): [True: 0, False: 960]
  ------------------
  811|      0|         return if_match(req, "PKCS5.PBKDF2", {1, 2, 840, 113549, 1, 5, 12});
  812|      0|      case 0x1495D:
  ------------------
  |  Branch (812:7): [True: 0, False: 960]
  ------------------
  813|      0|         return if_match(req, "eFrodoKEM-1344-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 17, 3});
  814|      0|      case 0x14E30:
  ------------------
  |  Branch (814:7): [True: 0, False: 960]
  ------------------
  815|      0|         return if_match(req, "ClassicMcEliece_460896", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 3});
  816|      0|      case 0x14FB1:
  ------------------
  |  Branch (816:7): [True: 0, False: 960]
  ------------------
  817|      0|         return if_match(req, "XMSS-draft12", {1, 3, 6, 1, 4, 1, 25258, 1, 8});
  818|      0|      case 0x156E3:
  ------------------
  |  Branch (818:7): [True: 0, False: 960]
  ------------------
  819|      0|         return if_match(req, "Compression.Zlib", {1, 2, 840, 113549, 1, 9, 16, 3, 8});
  820|      0|      case 0x1579E:
  ------------------
  |  Branch (820:7): [True: 0, False: 960]
  ------------------
  821|      0|         return if_match(req, "Streebog-512", {1, 2, 643, 7, 1, 1, 2, 3});
  822|      0|      case 0x1701A:
  ------------------
  |  Branch (822:7): [True: 0, False: 960]
  ------------------
  823|      0|         return if_match(req, "X509v3.AnyExtendedKeyUsage", {2, 5, 29, 37, 0});
  824|      0|      case 0x175EF:
  ------------------
  |  Branch (824:7): [True: 0, False: 960]
  ------------------
  825|      0|         return if_match(req, "Kyber-1024-90s-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 11, 3});
  826|      0|      case 0x17709:
  ------------------
  |  Branch (826:7): [True: 0, False: 960]
  ------------------
  827|      0|         return if_match(req, "X520.GivenName", {2, 5, 4, 42});
  828|      0|      case 0x17AD9:
  ------------------
  |  Branch (828:7): [True: 0, False: 960]
  ------------------
  829|      0|         return if_match(req, "RSA/PKCS1v15(SM3)", {1, 2, 156, 10197, 1, 504});
  830|      0|      case 0x17CE2:
  ------------------
  |  Branch (830:7): [True: 0, False: 960]
  ------------------
  831|      0|         return if_match(req, "SLH-DSA-SHA2-256f", {2, 16, 840, 1, 101, 3, 4, 3, 25});
  832|      0|      case 0x17CEF:
  ------------------
  |  Branch (832:7): [True: 0, False: 960]
  ------------------
  833|      0|         return if_match(req, "SLH-DSA-SHA2-256s", {2, 16, 840, 1, 101, 3, 4, 3, 24});
  834|      0|      case 0x18618:
  ------------------
  |  Branch (834:7): [True: 0, False: 960]
  ------------------
  835|      0|         return if_match(req, "FrodoKEM-976-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 15, 2});
  836|      0|      case 0x19480:
  ------------------
  |  Branch (836:7): [True: 0, False: 960]
  ------------------
  837|      0|         return if_match(req, "eFrodoKEM-1344-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 16, 3});
  838|      0|      case 0x1958A:
  ------------------
  |  Branch (838:7): [True: 0, False: 960]
  ------------------
  839|      0|         return if_match(req, "X509v3.InvalidityDate", {2, 5, 29, 24});
  840|      0|      case 0x19851:
  ------------------
  |  Branch (840:7): [True: 0, False: 960]
  ------------------
  841|      0|         return if_match(req, "DSA/SHA-1", {1, 2, 840, 10040, 4, 3});
  842|      0|      case 0x1B2E7:
  ------------------
  |  Branch (842:7): [True: 0, False: 960]
  ------------------
  843|      0|         return if_match(req, "KeyWrap.AES-128", {2, 16, 840, 1, 101, 3, 4, 1, 5});
  844|      0|      case 0x1B9BE:
  ------------------
  |  Branch (844:7): [True: 0, False: 960]
  ------------------
  845|      0|         return if_match(req, "KeyWrap.AES-192", {2, 16, 840, 1, 101, 3, 4, 1, 25});
  846|      0|      case 0x1D439:
  ------------------
  |  Branch (846:7): [True: 0, False: 960]
  ------------------
  847|      0|         return if_match(req, "SphincsPlus-haraka-192f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 4});
  848|      0|      case 0x2065B:
  ------------------
  |  Branch (848:7): [True: 0, False: 960]
  ------------------
  849|      0|         return if_match(req, "KeyWrap.CAST-128", {1, 2, 840, 113533, 7, 66, 15});
  850|      0|      case 0x216A0:
  ------------------
  |  Branch (850:7): [True: 0, False: 960]
  ------------------
  851|      0|         return if_match(req, "ML-KEM-512", {2, 16, 840, 1, 101, 3, 4, 4, 1});
  852|      0|      case 0x2216B:
  ------------------
  |  Branch (852:7): [True: 0, False: 960]
  ------------------
  853|      0|         return if_match(req, "GOST-34.10-2012-512", {1, 2, 643, 7, 1, 1, 1, 2});
  854|      0|      case 0x22C2C:
  ------------------
  |  Branch (854:7): [True: 0, False: 960]
  ------------------
  855|      0|         return if_match(req, "ElGamal", {1, 3, 6, 1, 4, 1, 3029, 1, 2, 1});
  856|      0|      case 0x2559A:
  ------------------
  |  Branch (856:7): [True: 0, False: 960]
  ------------------
  857|      0|         return if_match(req, "X520.Initials", {2, 5, 4, 43});
  858|      0|      case 0x271AC:
  ------------------
  |  Branch (858:7): [True: 0, False: 960]
  ------------------
  859|      0|         return if_match(req, "PKIX.AutonomousSysIds", {1, 3, 6, 1, 5, 5, 7, 1, 8});
  860|      0|      case 0x2808B:
  ------------------
  |  Branch (860:7): [True: 0, False: 960]
  ------------------
  861|      0|         return if_match(req, "PKCS7.Data", {1, 2, 840, 113549, 1, 7, 1});
  862|      0|      case 0x281B8:
  ------------------
  |  Branch (862:7): [True: 0, False: 960]
  ------------------
  863|      0|         return if_match(req, "SphincsPlus-haraka-128s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 1});
  864|      0|      case 0x282FE:
  ------------------
  |  Branch (864:7): [True: 0, False: 960]
  ------------------
  865|      0|         return if_match(req, "PKIX.OCSP.Nonce", {1, 3, 6, 1, 5, 5, 7, 48, 1, 2});
  866|      0|      case 0x29999:
  ------------------
  |  Branch (866:7): [True: 0, False: 960]
  ------------------
  867|      0|         return if_match(req, "DSA/SHA-3(256)", {2, 16, 840, 1, 101, 3, 4, 3, 6});
  868|      0|      case 0x2A83D:
  ------------------
  |  Branch (868:7): [True: 0, False: 960]
  ------------------
  869|      0|         return if_match(req, "SHA-224", {2, 16, 840, 1, 101, 3, 4, 2, 4});
  870|      0|      case 0x2AB30:
  ------------------
  |  Branch (870:7): [True: 0, False: 960]
  ------------------
  871|      0|         return if_match(req, "SHA-256", {2, 16, 840, 1, 101, 3, 4, 2, 1});
  872|      0|      case 0x2ABEF:
  ------------------
  |  Branch (872:7): [True: 0, False: 960]
  ------------------
  873|      0|         return if_match(req, "KeyWrap.AES-256", {2, 16, 840, 1, 101, 3, 4, 1, 45});
  874|      0|      case 0x2BAEF:
  ------------------
  |  Branch (874:7): [True: 0, False: 960]
  ------------------
  875|      0|         return if_match(req, "SM2_Sig/SM3", {1, 2, 156, 10197, 1, 501});
  876|      0|      case 0x2C39A:
  ------------------
  |  Branch (876:7): [True: 0, False: 960]
  ------------------
  877|      0|         return if_match(req, "ECGDSA/RIPEMD-160", {1, 3, 36, 3, 3, 2, 5, 4, 1});
  878|      0|      case 0x2C54F:
  ------------------
  |  Branch (878:7): [True: 0, False: 960]
  ------------------
  879|      0|         return if_match(req, "ECDSA/SHA-3(224)", {2, 16, 840, 1, 101, 3, 4, 3, 9});
  880|      0|      case 0x2EEA6:
  ------------------
  |  Branch (880:7): [True: 0, False: 960]
  ------------------
  881|      0|         return if_match(req, "RSA/PKCS1v15(RIPEMD-160)", {1, 3, 36, 3, 3, 1, 2});
  882|      0|      case 0x2EFBA:
  ------------------
  |  Branch (882:7): [True: 0, False: 960]
  ------------------
  883|      0|         return if_match(req, "Kyber-512-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 7, 1});
  884|      0|      case 0x2F0AD:
  ------------------
  |  Branch (884:7): [True: 0, False: 960]
  ------------------
  885|      0|         return if_match(req, "PKCS7.EncryptedData", {1, 2, 840, 113549, 1, 7, 6});
  886|      0|      case 0x2F219:
  ------------------
  |  Branch (886:7): [True: 0, False: 960]
  ------------------
  887|      0|         return if_match(req, "PBE-SHA1-2DES", {1, 2, 840, 113549, 1, 12, 1, 4});
  888|      0|      case 0x3133E:
  ------------------
  |  Branch (888:7): [True: 0, False: 960]
  ------------------
  889|      0|         return if_match(req, "SLH-DSA-SHA2-128f", {2, 16, 840, 1, 101, 3, 4, 3, 21});
  890|      0|      case 0x3134B:
  ------------------
  |  Branch (890:7): [True: 0, False: 960]
  ------------------
  891|      0|         return if_match(req, "SLH-DSA-SHA2-128s", {2, 16, 840, 1, 101, 3, 4, 3, 20});
  892|      0|      case 0x3160D:
  ------------------
  |  Branch (892:7): [True: 0, False: 960]
  ------------------
  893|      0|         return if_match(req, "RSA/PKCS1v15(SHA-3(224))", {2, 16, 840, 1, 101, 3, 4, 3, 13});
  894|      0|      case 0x319E0:
  ------------------
  |  Branch (894:7): [True: 0, False: 960]
  ------------------
  895|      0|         return if_match(req, "GOST-34.10-2012-256/Streebog-256", {1, 2, 643, 7, 1, 1, 3, 2});
  896|      0|      case 0x31B3D:
  ------------------
  |  Branch (896:7): [True: 0, False: 960]
  ------------------
  897|      0|         return if_match(req, "HMAC(SHA-512)", {1, 2, 840, 113549, 2, 11});
  898|      0|      case 0x31C6D:
  ------------------
  |  Branch (898:7): [True: 0, False: 960]
  ------------------
  899|      0|         return if_match(req, "secp384r1", {1, 3, 132, 0, 34});
  900|      0|      case 0x32899:
  ------------------
  |  Branch (900:7): [True: 0, False: 960]
  ------------------
  901|      0|         return if_match(req, "TripleDES/CBC", {1, 2, 840, 113549, 3, 7});
  902|    778|      case 0x33C9C:
  ------------------
  |  Branch (902:7): [True: 778, False: 182]
  ------------------
  903|    778|         return if_match(req, "PKIX.SmtpUTF8Mailbox", {1, 3, 6, 1, 5, 5, 7, 8, 9});
  904|      0|      case 0x33D04:
  ------------------
  |  Branch (904:7): [True: 0, False: 960]
  ------------------
  905|      0|         return if_match(req, "PKCS12.SecretBag", {1, 2, 840, 113549, 1, 12, 10, 1, 5});
  906|      0|      case 0x3615D:
  ------------------
  |  Branch (906:7): [True: 0, False: 960]
  ------------------
  907|      0|         return if_match(req, "FrodoKEM-976-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 14, 2});
  908|      0|      case 0x361B8:
  ------------------
  |  Branch (908:7): [True: 0, False: 960]
  ------------------
  909|      0|         return if_match(req, "Ed25519", {1, 3, 101, 112});
  910|      0|      case 0x3649D:
  ------------------
  |  Branch (910:7): [True: 0, False: 960]
  ------------------
  911|      0|         return if_match(req, "SHAKE-128", {2, 16, 840, 1, 101, 3, 4, 2, 11});
  912|      0|      case 0x36693:
  ------------------
  |  Branch (912:7): [True: 0, False: 960]
  ------------------
  913|      0|         return if_match(req, "ClassicMcEliece_348864", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 1});
  914|      0|      case 0x373C7:
  ------------------
  |  Branch (914:7): [True: 0, False: 960]
  ------------------
  915|      0|         return if_match(req, "ML-DSA-4x4", {2, 16, 840, 1, 101, 3, 4, 3, 17});
  916|      0|      case 0x3750B:
  ------------------
  |  Branch (916:7): [True: 0, False: 960]
  ------------------
  917|      0|         return if_match(req, "ClassicMcEliece_8192128", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 9});
  918|      0|      case 0x39890:
  ------------------
  |  Branch (918:7): [True: 0, False: 960]
  ------------------
  919|      0|         return if_match(req, "Ed448", {1, 3, 101, 113});
  920|      0|      case 0x3A438:
  ------------------
  |  Branch (920:7): [True: 0, False: 960]
  ------------------
  921|      0|         return if_match(req, "SHA-384", {2, 16, 840, 1, 101, 3, 4, 2, 2});
  922|      0|      case 0x3A963:
  ------------------
  |  Branch (922:7): [True: 0, False: 960]
  ------------------
  923|      0|         return if_match(req, "DH", {1, 2, 840, 10046, 2, 1});
  924|      0|      case 0x3AC83:
  ------------------
  |  Branch (924:7): [True: 0, False: 960]
  ------------------
  925|      0|         return if_match(req, "MGF1", {1, 2, 840, 113549, 1, 1, 8});
  926|      0|      case 0x3ACBA:
  ------------------
  |  Branch (926:7): [True: 0, False: 960]
  ------------------
  927|      0|         return if_match(req, "X509v3.IssuerAlternativeName", {2, 5, 29, 18});
  928|      0|      case 0x3B273:
  ------------------
  |  Branch (928:7): [True: 0, False: 960]
  ------------------
  929|      0|         return if_match(req, "KeyWrap.TripleDES", {1, 2, 840, 113549, 1, 9, 16, 3, 6});
  930|      0|      case 0x3B91E:
  ------------------
  |  Branch (930:7): [True: 0, False: 960]
  ------------------
  931|      0|         return if_match(req, "X509v3.PrivateKeyUsagePeriod", {2, 5, 29, 16});
  932|      0|      case 0x3BC8A:
  ------------------
  |  Branch (932:7): [True: 0, False: 960]
  ------------------
  933|      0|         return if_match(req, "SLH-DSA-SHAKE-192f", {2, 16, 840, 1, 101, 3, 4, 3, 29});
  934|      0|      case 0x3BC97:
  ------------------
  |  Branch (934:7): [True: 0, False: 960]
  ------------------
  935|      0|         return if_match(req, "SLH-DSA-SHAKE-192s", {2, 16, 840, 1, 101, 3, 4, 3, 28});
  936|      0|      case 0x3D127:
  ------------------
  |  Branch (936:7): [True: 0, False: 960]
  ------------------
  937|      0|         return if_match(req, "DSA", {1, 2, 840, 10040, 4, 1});
  938|      0|      case 0x3E249:
  ------------------
  |  Branch (938:7): [True: 0, False: 960]
  ------------------
  939|      0|         return if_match(req, "HSS-LMS", {1, 2, 840, 113549, 1, 9, 16, 3, 17});
  940|      0|      case 0x3E7D5:
  ------------------
  |  Branch (940:7): [True: 0, False: 960]
  ------------------
  941|      0|         return if_match(req, "RSA/PKCS1v15(SHA-3(256))", {2, 16, 840, 1, 101, 3, 4, 3, 14});
  942|      0|      case 0x3F748:
  ------------------
  |  Branch (942:7): [True: 0, False: 960]
  ------------------
  943|      0|         return if_match(req, "GOST.OGRN", {1, 2, 643, 100, 1});
  944|      0|      case 0x3F99F:
  ------------------
  |  Branch (944:7): [True: 0, False: 960]
  ------------------
  945|      0|         return if_match(req, "X509v3.BasicConstraints", {2, 5, 29, 19});
  946|      0|      case 0x40726:
  ------------------
  |  Branch (946:7): [True: 0, False: 960]
  ------------------
  947|      0|         return if_match(req, "SHA-3(512)", {2, 16, 840, 1, 101, 3, 4, 2, 10});
  948|      0|      case 0x407BF:
  ------------------
  |  Branch (948:7): [True: 0, False: 960]
  ------------------
  949|      0|         return if_match(req, "ML-KEM-768", {2, 16, 840, 1, 101, 3, 4, 4, 2});
  950|      0|      case 0x41334:
  ------------------
  |  Branch (950:7): [True: 0, False: 960]
  ------------------
  951|      0|         return if_match(req, "ECDSA/SHA-3(384)", {2, 16, 840, 1, 101, 3, 4, 3, 11});
  952|      0|      case 0x42DF3:
  ------------------
  |  Branch (952:7): [True: 0, False: 960]
  ------------------
  953|      0|         return if_match(req, "X509v3.CRLDistributionPoints", {2, 5, 29, 31});
  954|      0|      case 0x437FB:
  ------------------
  |  Branch (954:7): [True: 0, False: 960]
  ------------------
  955|      0|         return if_match(req, "brainpool160r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 1});
  956|      0|      case 0x441F5:
  ------------------
  |  Branch (956:7): [True: 0, False: 960]
  ------------------
  957|      0|         return if_match(req, "gost_256A", {1, 2, 643, 7, 1, 2, 1, 1, 1});
  958|      0|      case 0x441F6:
  ------------------
  |  Branch (958:7): [True: 0, False: 960]
  ------------------
  959|      0|         return if_match(req, "gost_256B", {1, 2, 643, 7, 1, 2, 1, 1, 2});
  960|      0|      case 0x44221:
  ------------------
  |  Branch (960:7): [True: 0, False: 960]
  ------------------
  961|      0|         return if_match(req, "GOST-34.10-2012-512/Streebog-512", {1, 2, 643, 7, 1, 1, 3, 3});
  962|      0|      case 0x44322:
  ------------------
  |  Branch (962:7): [True: 0, False: 960]
  ------------------
  963|      0|         return if_match(req, "ClassicMcEliece_6960119pc", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 3});
  964|      0|      case 0x44973:
  ------------------
  |  Branch (964:7): [True: 0, False: 960]
  ------------------
  965|      0|         return if_match(req, "Kyber-512-90s-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 11, 1});
  966|      0|      case 0x45C27:
  ------------------
  |  Branch (966:7): [True: 0, False: 960]
  ------------------
  967|      0|         return if_match(req, "RSA/PKCS1v15(SHA-512-256)", {1, 2, 840, 113549, 1, 1, 16});
  968|      0|      case 0x45C85:
  ------------------
  |  Branch (968:7): [True: 0, False: 960]
  ------------------
  969|      0|         return if_match(req, "X509v3.ReasonCode", {2, 5, 29, 21});
  970|      0|      case 0x45DA5:
  ------------------
  |  Branch (970:7): [True: 0, False: 960]
  ------------------
  971|      0|         return if_match(req, "SHAKE-256", {2, 16, 840, 1, 101, 3, 4, 2, 12});
  972|      0|      case 0x4663C:
  ------------------
  |  Branch (972:7): [True: 0, False: 960]
  ------------------
  973|      0|         return if_match(req, "X509v3.PolicyConstraints", {2, 5, 29, 36});
  974|      0|      case 0x480F7:
  ------------------
  |  Branch (974:7): [True: 0, False: 960]
  ------------------
  975|      0|         return if_match(req, "Serpent/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 4});
  976|      0|      case 0x48627:
  ------------------
  |  Branch (976:7): [True: 0, False: 960]
  ------------------
  977|      0|         return if_match(req, "Dilithium-4x4-AES-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 10, 1});
  978|      0|      case 0x48861:
  ------------------
  |  Branch (978:7): [True: 0, False: 960]
  ------------------
  979|      0|         return if_match(req, "ChaCha20Poly1305", {1, 2, 840, 113549, 1, 9, 16, 3, 18});
  980|      0|      case 0x4A292:
  ------------------
  |  Branch (980:7): [True: 0, False: 960]
  ------------------
  981|      0|         return if_match(req, "frp256v1", {1, 2, 250, 1, 223, 101, 256, 1});
  982|      0|      case 0x4A9EE:
  ------------------
  |  Branch (982:7): [True: 0, False: 960]
  ------------------
  983|      0|         return if_match(req, "ClassicMcEliece_6960119f", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 8});
  984|      0|      case 0x4BF87:
  ------------------
  |  Branch (984:7): [True: 0, False: 960]
  ------------------
  985|      0|         return if_match(req, "PKIX.TNAuthList", {1, 3, 6, 1, 5, 5, 7, 1, 26});
  986|      0|      case 0x4C088:
  ------------------
  |  Branch (986:7): [True: 0, False: 960]
  ------------------
  987|      0|         return if_match(req, "eFrodoKEM-976-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 17, 2});
  988|      0|      case 0x4C513:
  ------------------
  |  Branch (988:7): [True: 0, False: 960]
  ------------------
  989|      0|         return if_match(req, "DSA/SHA-224", {2, 16, 840, 1, 101, 3, 4, 3, 1});
  990|      0|      case 0x4C806:
  ------------------
  |  Branch (990:7): [True: 0, False: 960]
  ------------------
  991|      0|         return if_match(req, "DSA/SHA-256", {2, 16, 840, 1, 101, 3, 4, 3, 2});
  992|      0|      case 0x4D740:
  ------------------
  |  Branch (992:7): [True: 0, False: 960]
  ------------------
  993|      0|         return if_match(req, "X509v3.AnyPolicy", {2, 5, 29, 32, 0});
  994|      0|      case 0x4DE49:
  ------------------
  |  Branch (994:7): [True: 0, False: 960]
  ------------------
  995|      0|         return if_match(req, "RSA/PKCS1v15(SHA-512)", {1, 2, 840, 113549, 1, 1, 13});
  996|      0|      case 0x4ED5D:
  ------------------
  |  Branch (996:7): [True: 0, False: 960]
  ------------------
  997|      0|         return if_match(req, "CAST-128/CBC", {1, 2, 840, 113533, 7, 66, 10});
  998|      0|      case 0x4FCDC:
  ------------------
  |  Branch (998:7): [True: 0, False: 960]
  ------------------
  999|      0|         return if_match(req, "RSA", {1, 2, 840, 113549, 1, 1, 1});
 1000|      0|      case 0x501CB:
  ------------------
  |  Branch (1000:7): [True: 0, False: 960]
  ------------------
 1001|      0|         return if_match(req, "ECDSA/SHA-224", {1, 2, 840, 10045, 4, 3, 1});
 1002|      0|      case 0x50395:
  ------------------
  |  Branch (1002:7): [True: 0, False: 960]
  ------------------
 1003|      0|         return if_match(req, "GOST-34.10/GOST-R-34.11-94", {1, 2, 643, 2, 2, 3});
 1004|      0|      case 0x504BE:
  ------------------
  |  Branch (1004:7): [True: 0, False: 960]
  ------------------
 1005|      0|         return if_match(req, "ECDSA/SHA-256", {1, 2, 840, 10045, 4, 3, 2});
 1006|      0|      case 0x509C3:
  ------------------
  |  Branch (1006:7): [True: 0, False: 960]
  ------------------
 1007|      0|         return if_match(req, "brainpool192r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 3});
 1008|      0|      case 0x509F9:
  ------------------
  |  Branch (1008:7): [True: 0, False: 960]
  ------------------
 1009|      0|         return if_match(req, "PKCS9.ContentType", {1, 2, 840, 113549, 1, 9, 3});
 1010|      0|      case 0x50B26:
  ------------------
  |  Branch (1010:7): [True: 0, False: 960]
  ------------------
 1011|      0|         return if_match(req, "FrodoKEM-640-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 15, 1});
 1012|      0|      case 0x50D78:
  ------------------
  |  Branch (1012:7): [True: 0, False: 960]
  ------------------
 1013|      0|         return if_match(req, "x962_p192v2", {1, 2, 840, 10045, 3, 1, 2});
 1014|      0|      case 0x50D79:
  ------------------
  |  Branch (1014:7): [True: 0, False: 960]
  ------------------
 1015|      0|         return if_match(req, "x962_p192v3", {1, 2, 840, 10045, 3, 1, 3});
 1016|      0|      case 0x51DC6:
  ------------------
  |  Branch (1016:7): [True: 0, False: 960]
  ------------------
 1017|      0|         return if_match(req, "AES-128/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 1});
 1018|      0|      case 0x52DB6:
  ------------------
  |  Branch (1018:7): [True: 0, False: 960]
  ------------------
 1019|      0|         return if_match(req, "HMAC(SHA-224)", {1, 2, 840, 113549, 2, 8});
 1020|      0|      case 0x53E11:
  ------------------
  |  Branch (1020:7): [True: 0, False: 960]
  ------------------
 1021|      0|         return if_match(req, "FrodoKEM-1344-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 14, 3});
 1022|      0|      case 0x54012:
  ------------------
  |  Branch (1022:7): [True: 0, False: 960]
  ------------------
 1023|      0|         return if_match(req, "PKIX.TimeStamping", {1, 3, 6, 1, 5, 5, 7, 3, 8});
 1024|      0|      case 0x5407A:
  ------------------
  |  Branch (1024:7): [True: 0, False: 960]
  ------------------
 1025|      0|         return if_match(req, "Serpent/CBC", {1, 3, 6, 1, 4, 1, 25258, 3, 1});
 1026|      0|      case 0x5576D:
  ------------------
  |  Branch (1026:7): [True: 0, False: 960]
  ------------------
 1027|      0|         return if_match(req, "SphincsPlus-sha2-128f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 2});
 1028|      0|      case 0x55EF6:
  ------------------
  |  Branch (1028:7): [True: 0, False: 960]
  ------------------
 1029|      0|         return if_match(req, "AES-192/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 2});
 1030|      0|      case 0x55FFA:
  ------------------
  |  Branch (1030:7): [True: 0, False: 960]
  ------------------
 1031|      0|         return if_match(req, "ML-DSA-6x5", {2, 16, 840, 1, 101, 3, 4, 3, 18});
 1032|      0|      case 0x56826:
  ------------------
  |  Branch (1032:7): [True: 0, False: 960]
  ------------------
 1033|      0|         return if_match(req, "brainpool320r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 9});
 1034|      0|      case 0x56D0D:
  ------------------
  |  Branch (1034:7): [True: 0, False: 960]
  ------------------
 1035|      0|         return if_match(req, "SphincsPlus-shake-128f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 2});
 1036|      0|      case 0x57077:
  ------------------
  |  Branch (1036:7): [True: 0, False: 960]
  ------------------
 1037|      0|         return if_match(req, "XMSS-draft6", {1, 3, 6, 1, 4, 1, 25258, 1, 5});
 1038|      0|      case 0x5818B:
  ------------------
  |  Branch (1038:7): [True: 0, False: 960]
  ------------------
 1039|      0|         return if_match(req, "ECGDSA/SHA-224", {1, 3, 36, 3, 3, 2, 5, 4, 3});
 1040|      0|      case 0x5847E:
  ------------------
  |  Branch (1040:7): [True: 0, False: 960]
  ------------------
 1041|      0|         return if_match(req, "ECGDSA/SHA-256", {1, 3, 36, 3, 3, 2, 5, 4, 4});
 1042|      0|      case 0x5898B:
  ------------------
  |  Branch (1042:7): [True: 0, False: 960]
  ------------------
 1043|      0|         return if_match(req, "SHA-512", {2, 16, 840, 1, 101, 3, 4, 2, 3});
 1044|      0|      case 0x58991:
  ------------------
  |  Branch (1044:7): [True: 0, False: 960]
  ------------------
 1045|      0|         return if_match(req, "PKIX.OCSP.NoCheck", {1, 3, 6, 1, 5, 5, 7, 48, 1, 5});
 1046|      0|      case 0x59717:
  ------------------
  |  Branch (1046:7): [True: 0, False: 960]
  ------------------
 1047|      0|         return if_match(req, "X509v3.SubjectKeyIdentifier", {2, 5, 29, 14});
 1048|      0|      case 0x5A1E1:
  ------------------
  |  Branch (1048:7): [True: 0, False: 960]
  ------------------
 1049|      0|         return if_match(req, "PKCS12.KeyBag", {1, 2, 840, 113549, 1, 12, 10, 1, 1});
 1050|      0|      case 0x5A570:
  ------------------
  |  Branch (1050:7): [True: 0, False: 960]
  ------------------
 1051|      0|         return if_match(req, "X520.CommonName", {2, 5, 4, 3});
 1052|      0|      case 0x5A990:
  ------------------
  |  Branch (1052:7): [True: 0, False: 960]
  ------------------
 1053|      0|         return if_match(req, "ECDSA/SHA-3(256)", {2, 16, 840, 1, 101, 3, 4, 3, 10});
 1054|      0|      case 0x5AB0E:
  ------------------
  |  Branch (1054:7): [True: 0, False: 960]
  ------------------
 1055|      0|         return if_match(req, "SphincsPlus-sha2-256s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 5});
 1056|      0|      case 0x5AC4A:
  ------------------
  |  Branch (1056:7): [True: 0, False: 960]
  ------------------
 1057|      0|         return if_match(req, "X520.Surname", {2, 5, 4, 4});
 1058|      0|      case 0x5AF2C:
  ------------------
  |  Branch (1058:7): [True: 0, False: 960]
  ------------------
 1059|      0|         return if_match(req, "ClassicMcEliece_8192128pc", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 5});
 1060|      0|      case 0x5BC39:
  ------------------
  |  Branch (1060:7): [True: 0, False: 960]
  ------------------
 1061|      0|         return if_match(req, "X509v3.KeyUsage", {2, 5, 29, 15});
 1062|      0|      case 0x5BDDB:
  ------------------
  |  Branch (1062:7): [True: 0, False: 960]
  ------------------
 1063|      0|         return if_match(req, "numsp256d1", {1, 3, 6, 1, 4, 1, 25258, 4, 1});
 1064|      0|      case 0x5C0AE:
  ------------------
  |  Branch (1064:7): [True: 0, False: 960]
  ------------------
 1065|      0|         return if_match(req, "SphincsPlus-shake-256s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 5});
 1066|      0|      case 0x5C10E:
  ------------------
  |  Branch (1066:7): [True: 0, False: 960]
  ------------------
 1067|      0|         return if_match(req, "DSA/SHA-384", {2, 16, 840, 1, 101, 3, 4, 3, 3});
 1068|      0|      case 0x5CFE5:
  ------------------
  |  Branch (1068:7): [True: 0, False: 960]
  ------------------
 1069|      0|         return if_match(req, "PKCS9.X509Certificate", {1, 2, 840, 113549, 1, 9, 22, 1});
 1070|      0|      case 0x5D1CF:
  ------------------
  |  Branch (1070:7): [True: 0, False: 960]
  ------------------
 1071|      0|         return if_match(req, "X520.SerialNumber", {2, 5, 4, 5});
 1072|      0|      case 0x5D375:
  ------------------
  |  Branch (1072:7): [True: 0, False: 960]
  ------------------
 1073|      0|         return if_match(req, "SM4/OCB", {1, 2, 156, 10197, 1, 104, 100});
 1074|      0|      case 0x5DD49:
  ------------------
  |  Branch (1074:7): [True: 0, False: 960]
  ------------------
 1075|      0|         return if_match(req, "AES-128/CBC", {2, 16, 840, 1, 101, 3, 4, 1, 2});
 1076|      0|      case 0x5DE4E:
  ------------------
  |  Branch (1076:7): [True: 0, False: 960]
  ------------------
 1077|      0|         return if_match(req, "AES-128/CCM", {2, 16, 840, 1, 101, 3, 4, 1, 7});
 1078|      0|      case 0x5DF23:
  ------------------
  |  Branch (1078:7): [True: 0, False: 960]
  ------------------
 1079|      0|         return if_match(req, "HMAC(SHA-512-256)", {1, 2, 840, 113549, 2, 13});
 1080|      0|      case 0x5ED04:
  ------------------
  |  Branch (1080:7): [True: 0, False: 960]
  ------------------
 1081|      0|         return if_match(req, "SM2", {1, 2, 156, 10197, 1, 301, 1});
 1082|      0|      case 0x5ED05:
  ------------------
  |  Branch (1082:7): [True: 0, False: 960]
  ------------------
 1083|      0|         return if_match(req, "SM3", {1, 2, 156, 10197, 1, 401});
 1084|      0|      case 0x5FDC6:
  ------------------
  |  Branch (1084:7): [True: 0, False: 960]
  ------------------
 1085|      0|         return if_match(req, "ECDSA/SHA-384", {1, 2, 840, 10045, 4, 3, 3});
 1086|      0|      case 0x6199F:
  ------------------
  |  Branch (1086:7): [True: 0, False: 960]
  ------------------
 1087|      0|         return if_match(req, "SHA-3(224)", {2, 16, 840, 1, 101, 3, 4, 2, 7});
 1088|      0|      case 0x61E79:
  ------------------
  |  Branch (1088:7): [True: 0, False: 960]
  ------------------
 1089|      0|         return if_match(req, "AES-192/CBC", {2, 16, 840, 1, 101, 3, 4, 1, 22});
 1090|      0|      case 0x61F7E:
  ------------------
  |  Branch (1090:7): [True: 0, False: 960]
  ------------------
 1091|      0|         return if_match(req, "AES-192/CCM", {2, 16, 840, 1, 101, 3, 4, 1, 27});
 1092|      0|      case 0x64947:
  ------------------
  |  Branch (1092:7): [True: 0, False: 960]
  ------------------
 1093|      0|         return if_match(req, "OpenPGP.Ed25519", {1, 3, 6, 1, 4, 1, 11591, 15, 1});
 1094|      0|      case 0x652E7:
  ------------------
  |  Branch (1094:7): [True: 0, False: 960]
  ------------------
 1095|      0|         return if_match(req, "sm2p256v1", {1, 2, 156, 10197, 1, 301});
 1096|      0|      case 0x6697B:
  ------------------
  |  Branch (1096:7): [True: 0, False: 960]
  ------------------
 1097|      0|         return if_match(req, "FrodoKEM-1344-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 15, 3});
 1098|      0|      case 0x67B2C:
  ------------------
  |  Branch (1098:7): [True: 0, False: 960]
  ------------------
 1099|      0|         return if_match(req, "X520.State", {2, 5, 4, 8});
 1100|      0|      case 0x67B9B:
  ------------------
  |  Branch (1100:7): [True: 0, False: 960]
  ------------------
 1101|      0|         return if_match(req, "HMAC(SHA-384)", {1, 2, 840, 113549, 2, 10});
 1102|      0|      case 0x67D86:
  ------------------
  |  Branch (1102:7): [True: 0, False: 960]
  ------------------
 1103|      0|         return if_match(req, "ECGDSA/SHA-384", {1, 3, 36, 3, 3, 2, 5, 4, 5});
 1104|      0|      case 0x68A0B:
  ------------------
  |  Branch (1104:7): [True: 0, False: 960]
  ------------------
 1105|      0|         return if_match(req, "Camellia-128/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 6});
 1106|      0|      case 0x68E33:
  ------------------
  |  Branch (1106:7): [True: 0, False: 960]
  ------------------
 1107|      0|         return if_match(req, "PKCS9.ExtensionRequest", {1, 2, 840, 113549, 1, 9, 14});
 1108|      0|      case 0x69126:
  ------------------
  |  Branch (1108:7): [True: 0, False: 960]
  ------------------
 1109|      0|         return if_match(req, "X509v3.SubjectAlternativeName", {2, 5, 29, 17});
 1110|      0|      case 0x692F8:
  ------------------
  |  Branch (1110:7): [True: 0, False: 960]
  ------------------
 1111|      0|         return if_match(req, "SM4/CBC", {1, 2, 156, 10197, 1, 104, 2});
 1112|      0|      case 0x695E1:
  ------------------
  |  Branch (1112:7): [True: 0, False: 960]
  ------------------
 1113|      0|         return if_match(req, "Dilithium-4x4-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 9, 1});
 1114|      0|      case 0x696DC:
  ------------------
  |  Branch (1114:7): [True: 0, False: 960]
  ------------------
 1115|      0|         return if_match(req, "PKIX.IpAddrBlocks", {1, 3, 6, 1, 5, 5, 7, 1, 7});
 1116|      0|      case 0x6A7CA:
  ------------------
  |  Branch (1116:7): [True: 0, False: 960]
  ------------------
 1117|      0|         return if_match(req, "ECDSA", {1, 2, 840, 10045, 2, 1});
 1118|      0|      case 0x6BD26:
  ------------------
  |  Branch (1118:7): [True: 0, False: 960]
  ------------------
 1119|      0|         return if_match(req, "GOST.INN", {1, 2, 643, 3, 131, 1, 1});
 1120|      0|      case 0x6CB3B:
  ------------------
  |  Branch (1120:7): [True: 0, False: 960]
  ------------------
 1121|      0|         return if_match(req, "Camellia-192/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 7});
 1122|      0|      case 0x6E602:
  ------------------
  |  Branch (1122:7): [True: 0, False: 960]
  ------------------
 1123|      0|         return if_match(req, "Dilithium-8x7-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 9, 3});
 1124|      0|      case 0x6F0C2:
  ------------------
  |  Branch (1124:7): [True: 0, False: 960]
  ------------------
 1125|      0|         return if_match(req, "RSA/PKCS1v15(SHA-224)", {1, 2, 840, 113549, 1, 1, 14});
 1126|      0|      case 0x6F9F8:
  ------------------
  |  Branch (1126:7): [True: 0, False: 960]
  ------------------
 1127|      0|         return if_match(req, "PKCS12.SafeContentsBag", {1, 2, 840, 113549, 1, 12, 10, 1, 6});
 1128|      0|      case 0x6FB26:
  ------------------
  |  Branch (1128:7): [True: 0, False: 960]
  ------------------
 1129|      0|         return if_match(req, "PKIX.AuthorityInformationAccess", {1, 3, 6, 1, 5, 5, 7, 1, 1});
 1130|      0|      case 0x70BB6:
  ------------------
  |  Branch (1130:7): [True: 0, False: 960]
  ------------------
 1131|      0|         return if_match(req, "brainpool384r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 11});
 1132|      0|      case 0x70EA6:
  ------------------
  |  Branch (1132:7): [True: 0, False: 960]
  ------------------
 1133|      0|         return if_match(req, "PKCS12.PKCS8ShroudedKeyBag", {1, 2, 840, 113549, 1, 12, 10, 1, 2});
 1134|      0|      case 0x71EB3:
  ------------------
  |  Branch (1134:7): [True: 0, False: 960]
  ------------------
 1135|      0|         return if_match(req, "SphincsPlus-haraka-128f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 2});
 1136|      0|      case 0x7382C:
  ------------------
  |  Branch (1136:7): [True: 0, False: 960]
  ------------------
 1137|      0|         return if_match(req, "ML-KEM-1024", {2, 16, 840, 1, 101, 3, 4, 4, 3});
 1138|      0|      case 0x743BD:
  ------------------
  |  Branch (1138:7): [True: 0, False: 960]
  ------------------
 1139|      0|         return if_match(req, "AES-256/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 3});
 1140|      0|      case 0x7498E:
  ------------------
  |  Branch (1140:7): [True: 0, False: 960]
  ------------------
 1141|      0|         return if_match(req, "Camellia-128/CBC", {1, 2, 392, 200011, 61, 1, 1, 1, 2});
 1142|      0|      case 0x74C2E:
  ------------------
  |  Branch (1142:7): [True: 0, False: 960]
  ------------------
 1143|      0|         return if_match(req, "ML-DSA-8x7", {2, 16, 840, 1, 101, 3, 4, 3, 19});
 1144|      0|      case 0x7505F:
  ------------------
  |  Branch (1144:7): [True: 0, False: 960]
  ------------------
 1145|      0|         return if_match(req, "PKIX.XMPPAddr", {1, 3, 6, 1, 5, 5, 7, 8, 5});
 1146|      0|      case 0x7517A:
  ------------------
  |  Branch (1146:7): [True: 0, False: 960]
  ------------------
 1147|      0|         return if_match(req, "RSA/PKCS1v15(MD2)", {1, 2, 840, 113549, 1, 1, 2});
 1148|      0|      case 0x7546B:
  ------------------
  |  Branch (1148:7): [True: 0, False: 960]
  ------------------
 1149|      0|         return if_match(req, "RSA/PKCS1v15(MD5)", {1, 2, 840, 113549, 1, 1, 4});
 1150|      0|      case 0x75921:
  ------------------
  |  Branch (1150:7): [True: 0, False: 960]
  ------------------
 1151|      0|         return if_match(req, "ClassicMcEliece_348864f", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 2});
 1152|      0|      case 0x76784:
  ------------------
  |  Branch (1152:7): [True: 0, False: 960]
  ------------------
 1153|      0|         return if_match(req, "SHA-3(384)", {2, 16, 840, 1, 101, 3, 4, 2, 9});
 1154|      0|      case 0x768FD:
  ------------------
  |  Branch (1154:7): [True: 0, False: 960]
  ------------------
 1155|      0|         return if_match(req, "PKCS9.LocalKeyId", {1, 2, 840, 113549, 1, 9, 21});
 1156|      0|      case 0x76A19:
  ------------------
  |  Branch (1156:7): [True: 0, False: 960]
  ------------------
 1157|      0|         return if_match(req, "brainpool512r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 13});
 1158|      0|      case 0x77254:
  ------------------
  |  Branch (1158:7): [True: 0, False: 960]
  ------------------
 1159|      0|         return if_match(req, "SphincsPlus-haraka-256s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 5});
 1160|      0|      case 0x77ADC:
  ------------------
  |  Branch (1160:7): [True: 0, False: 960]
  ------------------
 1161|      0|         return if_match(req, "secp224k1", {1, 3, 132, 0, 32});
 1162|      0|      case 0x781B9:
  ------------------
  |  Branch (1162:7): [True: 0, False: 960]
  ------------------
 1163|      0|         return if_match(req, "secp224r1", {1, 3, 132, 0, 33});
 1164|      0|      case 0x78ABE:
  ------------------
  |  Branch (1164:7): [True: 0, False: 960]
  ------------------
 1165|      0|         return if_match(req, "Camellia-192/CBC", {1, 2, 392, 200011, 61, 1, 1, 1, 3});
 1166|      0|      case 0x792F2:
  ------------------
  |  Branch (1166:7): [True: 0, False: 960]
  ------------------
 1167|      0|         return if_match(req, "ClassicMcEliece_6688128pc", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 1});
 1168|      0|      case 0x7A661:
  ------------------
  |  Branch (1168:7): [True: 0, False: 960]
  ------------------
 1169|      0|         return if_match(req, "DSA/SHA-512", {2, 16, 840, 1, 101, 3, 4, 3, 4});
 1170|      0|      case 0x7A977:
  ------------------
  |  Branch (1170:7): [True: 0, False: 960]
  ------------------
 1171|      0|         return if_match(req, "X509v3.ExtendedKeyUsage", {2, 5, 29, 37});
 1172|      0|      case 0x7AE67:
  ------------------
  |  Branch (1172:7): [True: 0, False: 960]
  ------------------
 1173|      0|         return if_match(req, "SM2_Enc", {1, 2, 156, 10197, 1, 301, 3});
 1174|      0|      case 0x7B602:
  ------------------
  |  Branch (1174:7): [True: 0, False: 960]
  ------------------
 1175|      0|         return if_match(req, "Twofish/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 5});
 1176|      0|      case 0x7B9A1:
  ------------------
  |  Branch (1176:7): [True: 0, False: 960]
  ------------------
 1177|      0|         return if_match(req, "SphincsPlus-sha2-192s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 3});
 1178|      0|      case 0x7BB0A:
  ------------------
  |  Branch (1178:7): [True: 0, False: 960]
  ------------------
 1179|      0|         return if_match(req, "SLH-DSA-SHAKE-256f", {2, 16, 840, 1, 101, 3, 4, 3, 31});
 1180|      0|      case 0x7BB17:
  ------------------
  |  Branch (1180:7): [True: 0, False: 960]
  ------------------
 1181|      0|         return if_match(req, "SLH-DSA-SHAKE-256s", {2, 16, 840, 1, 101, 3, 4, 3, 30});
 1182|      0|      case 0x7BCF3:
  ------------------
  |  Branch (1182:7): [True: 0, False: 960]
  ------------------
 1183|      0|         return if_match(req, "PKIX.EmailProtection", {1, 3, 6, 1, 5, 5, 7, 3, 4});
 1184|      0|      case 0x7CC2C:
  ------------------
  |  Branch (1184:7): [True: 0, False: 960]
  ------------------
 1185|      0|         return if_match(req, "SHA-512-256", {2, 16, 840, 1, 101, 3, 4, 2, 6});
 1186|      0|      case 0x7CF41:
  ------------------
  |  Branch (1186:7): [True: 0, False: 960]
  ------------------
 1187|      0|         return if_match(req, "SphincsPlus-shake-192s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 3});
 1188|      0|      case 0x7DB91:
  ------------------
  |  Branch (1188:7): [True: 0, False: 960]
  ------------------
 1189|      0|         return if_match(req, "GOST-34.10", {1, 2, 643, 2, 2, 19});
 1190|      0|      case 0x7E319:
  ------------------
  |  Branch (1190:7): [True: 0, False: 960]
  ------------------
 1191|      0|         return if_match(req, "ECDSA/SHA-512", {1, 2, 840, 10045, 4, 3, 4});
 1192|      0|      case 0x7E874:
  ------------------
  |  Branch (1192:7): [True: 0, False: 960]
  ------------------
 1193|      0|         return if_match(req, "ClassicMcEliece_6688128f", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 6});
 1194|      0|      case 0x7EAAF:
  ------------------
  |  Branch (1194:7): [True: 0, False: 960]
  ------------------
 1195|      0|         return if_match(req, "eFrodoKEM-640-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 16, 1});
 1196|      0|      case 0x7F51F:
  ------------------
  |  Branch (1196:7): [True: 0, False: 960]
  ------------------
 1197|      0|         return if_match(req, "PKIX.IPsecTunnel", {1, 3, 6, 1, 5, 5, 7, 3, 6});
 1198|      0|      case 0x80272:
  ------------------
  |  Branch (1198:7): [True: 0, False: 960]
  ------------------
 1199|      0|         return if_match(req, "X520.Organization", {2, 5, 4, 10});
 1200|      0|      case 0x80340:
  ------------------
  |  Branch (1200:7): [True: 0, False: 960]
  ------------------
 1201|      0|         return if_match(req, "AES-256/CBC", {2, 16, 840, 1, 101, 3, 4, 1, 42});
 1202|      0|      case 0x80445:
  ------------------
  |  Branch (1202:7): [True: 0, False: 960]
  ------------------
 1203|      0|         return if_match(req, "AES-256/CCM", {2, 16, 840, 1, 101, 3, 4, 1, 47});
 1204|      0|      case 0x80E71:
  ------------------
  |  Branch (1204:7): [True: 0, False: 960]
  ------------------
 1205|      0|         return if_match(req, "PKIX.STIRTNList", {1, 3, 6, 1, 5, 5, 7, 48, 14});
 1206|      0|      case 0x811F7:
  ------------------
  |  Branch (1206:7): [True: 0, False: 960]
  ------------------
 1207|      0|         return if_match(req, "HMAC(SHA-256)", {1, 2, 840, 113549, 2, 9});
 1208|      0|      case 0x82434:
  ------------------
  |  Branch (1208:7): [True: 0, False: 960]
  ------------------
 1209|      0|         return if_match(req, "PKCS9.X509CRL", {1, 2, 840, 113549, 1, 9, 23, 1});
 1210|      0|      case 0x82B47:
  ------------------
  |  Branch (1210:7): [True: 0, False: 960]
  ------------------
 1211|      0|         return if_match(req, "Threefish-512/CBC", {1, 3, 6, 1, 4, 1, 25258, 3, 2});
 1212|      0|      case 0x83EA7:
  ------------------
  |  Branch (1212:7): [True: 0, False: 960]
  ------------------
 1213|      0|         return if_match(req, "RSA/PKCS1v15(SHA-384)", {1, 2, 840, 113549, 1, 1, 12});
 1214|      0|      case 0x84596:
  ------------------
  |  Branch (1214:7): [True: 0, False: 960]
  ------------------
 1215|      0|         return if_match(req, "eFrodoKEM-640-AES", {1, 3, 6, 1, 4, 1, 25258, 1, 17, 1});
 1216|      0|      case 0x8469F:
  ------------------
  |  Branch (1216:7): [True: 0, False: 960]
  ------------------
 1217|      0|         return if_match(req, "ClassicMcEliece_6960119pcf", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 4});
 1218|      0|      case 0x84CA4:
  ------------------
  |  Branch (1218:7): [True: 0, False: 960]
  ------------------
 1219|      0|         return if_match(req, "secp256k1", {1, 3, 132, 0, 10});
 1220|      0|      case 0x85381:
  ------------------
  |  Branch (1220:7): [True: 0, False: 960]
  ------------------
 1221|      0|         return if_match(req, "secp256r1", {1, 2, 840, 10045, 3, 1, 7});
 1222|      0|      case 0x854FC:
  ------------------
  |  Branch (1222:7): [True: 0, False: 960]
  ------------------
 1223|      0|         return if_match(req, "PKIX.IPsecUser", {1, 3, 6, 1, 5, 5, 7, 3, 7});
 1224|      0|      case 0x85F51:
  ------------------
  |  Branch (1224:7): [True: 0, False: 960]
  ------------------
 1225|      0|         return if_match(req, "Serpent/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 4});
 1226|      0|      case 0x862D9:
  ------------------
  |  Branch (1226:7): [True: 0, False: 960]
  ------------------
 1227|      0|         return if_match(req, "ECGDSA/SHA-512", {1, 3, 36, 3, 3, 2, 5, 4, 6});
 1228|      0|      case 0x87585:
  ------------------
  |  Branch (1228:7): [True: 0, False: 960]
  ------------------
 1229|      0|         return if_match(req, "Twofish/CBC", {1, 3, 6, 1, 4, 1, 25258, 3, 3});
 1230|      0|      case 0x877D1:
  ------------------
  |  Branch (1230:7): [True: 0, False: 960]
  ------------------
 1231|      0|         return if_match(req, "PKCS9.EmailAddress", {1, 2, 840, 113549, 1, 9, 1});
 1232|     91|      case 0x87D27:
  ------------------
  |  Branch (1232:7): [True: 91, False: 869]
  ------------------
 1233|     91|         return if_match(req, "PKIX.CertificateAuthorityIssuers", {1, 3, 6, 1, 5, 5, 7, 48, 2});
 1234|      0|      case 0x87E42:
  ------------------
  |  Branch (1234:7): [True: 0, False: 960]
  ------------------
 1235|      0|         return if_match(req, "X509v3.AuthorityKeyIdentifier", {2, 5, 29, 35});
 1236|      0|      case 0x889B1:
  ------------------
  |  Branch (1236:7): [True: 0, False: 960]
  ------------------
 1237|      0|         return if_match(req, "ECDSA/SHA-1", {1, 2, 840, 10045, 4, 1});
 1238|      0|      case 0x89658:
  ------------------
  |  Branch (1238:7): [True: 0, False: 960]
  ------------------
 1239|      0|         return if_match(req, "PBE-PKCS5v20", {1, 2, 840, 113549, 1, 5, 13});
 1240|      0|      case 0x8976D:
  ------------------
  |  Branch (1240:7): [True: 0, False: 960]
  ------------------
 1241|      0|         return if_match(req, "PKCS9.MessageDigest", {1, 2, 840, 113549, 1, 9, 4});
 1242|      0|      case 0x8B002:
  ------------------
  |  Branch (1242:7): [True: 0, False: 960]
  ------------------
 1243|      0|         return if_match(req, "Camellia-256/OCB", {1, 3, 6, 1, 4, 1, 25258, 3, 2, 8});
 1244|      0|      case 0x8B935:
  ------------------
  |  Branch (1244:7): [True: 0, False: 960]
  ------------------
 1245|      0|         return if_match(req, "ClassicMcEliece_6688128", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 5});
 1246|      0|      case 0x8BB11:
  ------------------
  |  Branch (1246:7): [True: 0, False: 960]
  ------------------
 1247|      0|         return if_match(req, "X509v3.NoRevocationAvailable", {2, 5, 29, 56});
 1248|      0|      case 0x8CE3D:
  ------------------
  |  Branch (1248:7): [True: 0, False: 960]
  ------------------
 1249|      0|         return if_match(req, "PKCS9.ChallengePassword", {1, 2, 840, 113549, 1, 9, 7});
 1250|      0|      case 0x8D45C:
  ------------------
  |  Branch (1250:7): [True: 0, False: 960]
  ------------------
 1251|      0|         return if_match(req, "ECKCDSA", {1, 0, 14888, 3, 0, 5});
 1252|      0|      case 0x8E0C1:
  ------------------
  |  Branch (1252:7): [True: 0, False: 960]
  ------------------
 1253|      0|         return if_match(req, "X509v3.CertificatePolicies", {2, 5, 29, 32});
 1254|      0|      case 0x8E39A:
  ------------------
  |  Branch (1254:7): [True: 0, False: 960]
  ------------------
 1255|      0|         return if_match(req, "HSS-LMS-Private-Key", {1, 3, 6, 1, 4, 1, 25258, 1, 13});
 1256|      0|      case 0x8EC51:
  ------------------
  |  Branch (1256:7): [True: 0, False: 960]
  ------------------
 1257|      0|         return if_match(req, "Kyber-768-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 7, 2});
 1258|      0|      case 0x8F94A:
  ------------------
  |  Branch (1258:7): [True: 0, False: 960]
  ------------------
 1259|      0|         return if_match(req, "Dilithium-6x5-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 9, 2});
 1260|      0|      case 0x8FC20:
  ------------------
  |  Branch (1260:7): [True: 0, False: 960]
  ------------------
 1261|      0|         return if_match(req, "AES-128/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 1});
 1262|      0|      case 0x8FDE0:
  ------------------
  |  Branch (1262:7): [True: 0, False: 960]
  ------------------
 1263|      0|         return if_match(req, "SHA-3(256)", {2, 16, 840, 1, 101, 3, 4, 2, 8});
 1264|      0|      case 0x919E3:
  ------------------
  |  Branch (1264:7): [True: 0, False: 960]
  ------------------
 1265|      0|         return if_match(req, "Serpent/GCM", {1, 3, 6, 1, 4, 1, 25258, 3, 101});
 1266|      0|      case 0x91C1A:
  ------------------
  |  Branch (1266:7): [True: 0, False: 960]
  ------------------
 1267|      0|         return if_match(req, "X25519", {1, 3, 101, 110});
 1268|      0|      case 0x91DC4:
  ------------------
  |  Branch (1268:7): [True: 0, False: 960]
  ------------------
 1269|      0|         return if_match(req, "McEliece", {1, 3, 6, 1, 4, 1, 25258, 1, 3});
 1270|      0|      case 0x93467:
  ------------------
  |  Branch (1270:7): [True: 0, False: 960]
  ------------------
 1271|      0|         return if_match(req, "Dilithium-6x5-AES-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 10, 2});
 1272|      0|      case 0x93D50:
  ------------------
  |  Branch (1272:7): [True: 0, False: 960]
  ------------------
 1273|      0|         return if_match(req, "AES-192/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 2});
 1274|      0|      case 0x95166:
  ------------------
  |  Branch (1274:7): [True: 0, False: 960]
  ------------------
 1275|      0|         return if_match(req, "SLH-DSA-SHAKE-128f", {2, 16, 840, 1, 101, 3, 4, 3, 27});
 1276|      0|      case 0x95173:
  ------------------
  |  Branch (1276:7): [True: 0, False: 960]
  ------------------
 1277|      0|         return if_match(req, "SLH-DSA-SHAKE-128s", {2, 16, 840, 1, 101, 3, 4, 3, 26});
 1278|     91|      case 0x952D6:
  ------------------
  |  Branch (1278:7): [True: 91, False: 869]
  ------------------
 1279|     91|         return if_match(req, "PKIX.OCSP", {1, 3, 6, 1, 5, 5, 7, 48, 1});
 1280|      0|      case 0x959B9:
  ------------------
  |  Branch (1280:7): [True: 0, False: 960]
  ------------------
 1281|      0|         return if_match(req, "PKIX.IPsecEndSystem", {1, 3, 6, 1, 5, 5, 7, 3, 5});
 1282|      0|      case 0x96F85:
  ------------------
  |  Branch (1282:7): [True: 0, False: 960]
  ------------------
 1283|      0|         return if_match(req, "Camellia-256/CBC", {1, 2, 392, 200011, 61, 1, 1, 1, 4});
 1284|      0|      case 0x97D5E:
  ------------------
  |  Branch (1284:7): [True: 0, False: 960]
  ------------------
 1285|      0|         return if_match(req, "HMAC(SHA-1)", {1, 2, 840, 113549, 2, 7});
 1286|      0|      case 0x9805C:
  ------------------
  |  Branch (1286:7): [True: 0, False: 960]
  ------------------
 1287|      0|         return if_match(req, "SEED/CBC", {1, 2, 410, 200004, 1, 4});
 1288|      0|      case 0x980E7:
  ------------------
  |  Branch (1288:7): [True: 0, False: 960]
  ------------------
 1289|      0|         return if_match(req, "SphincsPlus-haraka-192s-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 3});
 1290|      0|      case 0x980F5:
  ------------------
  |  Branch (1290:7): [True: 0, False: 960]
  ------------------
 1291|      0|         return if_match(req, "GOST.SubjectSigningTool", {1, 2, 643, 100, 111});
 1292|      0|      case 0x98B03:
  ------------------
  |  Branch (1292:7): [True: 0, False: 960]
  ------------------
 1293|      0|         return if_match(req, "XMSS", {0, 4, 0, 127, 0, 15, 1, 1, 13, 0});
 1294|      0|      case 0x9A6B2:
  ------------------
  |  Branch (1294:7): [True: 0, False: 960]
  ------------------
 1295|      0|         return if_match(req, "ECKCDSA/SHA-1", {1, 2, 410, 200004, 1, 100, 4, 3});
 1296|      0|      case 0x9B1CF:
  ------------------
  |  Branch (1296:7): [True: 0, False: 960]
  ------------------
 1297|      0|         return if_match(req, "SM4/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 9});
 1298|      0|      case 0x9B6B2:
  ------------------
  |  Branch (1298:7): [True: 0, False: 960]
  ------------------
 1299|      0|         return if_match(req, "AES-128/GCM", {2, 16, 840, 1, 101, 3, 4, 1, 6});
 1300|      0|      case 0x9B6BB:
  ------------------
  |  Branch (1300:7): [True: 0, False: 960]
  ------------------
 1301|      0|         return if_match(req, "X520.OrganizationalUnit", {2, 5, 4, 11});
 1302|      0|      case 0x9B851:
  ------------------
  |  Branch (1302:7): [True: 0, False: 960]
  ------------------
 1303|      0|         return if_match(req, "OpenPGP.Curve25519", {1, 3, 6, 1, 4, 1, 3029, 1, 5, 1});
 1304|      0|      case 0x9C80B:
  ------------------
  |  Branch (1304:7): [True: 0, False: 960]
  ------------------
 1305|      0|         return if_match(req, "SLH-DSA-SHA2-192f", {2, 16, 840, 1, 101, 3, 4, 3, 23});
 1306|      0|      case 0x9C818:
  ------------------
  |  Branch (1306:7): [True: 0, False: 960]
  ------------------
 1307|      0|         return if_match(req, "SLH-DSA-SHA2-192s", {2, 16, 840, 1, 101, 3, 4, 3, 22});
 1308|      0|      case 0x9CD2B:
  ------------------
  |  Branch (1308:7): [True: 0, False: 960]
  ------------------
 1309|      0|         return if_match(req, "Scrypt", {1, 3, 6, 1, 4, 1, 11591, 4, 11});
 1310|      0|      case 0x9CDE1:
  ------------------
  |  Branch (1310:7): [True: 0, False: 960]
  ------------------
 1311|      0|         return if_match(req, "GOST-34.10-2012-256/SHA-256", {1, 3, 6, 1, 4, 1, 25258, 1, 6, 1});
 1312|      0|      case 0x9CF73:
  ------------------
  |  Branch (1312:7): [True: 0, False: 960]
  ------------------
 1313|      0|         return if_match(req, "ClassicMcEliece_460896f", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 4});
 1314|      0|      case 0x9D354:
  ------------------
  |  Branch (1314:7): [True: 0, False: 960]
  ------------------
 1315|      0|         return if_match(req, "RIPEMD-160", {1, 3, 36, 3, 2, 1});
 1316|      0|      case 0x9D503:
  ------------------
  |  Branch (1316:7): [True: 0, False: 960]
  ------------------
 1317|      0|         return if_match(req, "RSA/PKCS1v15(SHA-256)", {1, 2, 840, 113549, 1, 1, 11});
 1318|      0|      case 0x9EC88:
  ------------------
  |  Branch (1318:7): [True: 0, False: 960]
  ------------------
 1319|      0|         return if_match(req, "DSA/SHA-3(512)", {2, 16, 840, 1, 101, 3, 4, 3, 8});
 1320|      0|      case 0x9EF36:
  ------------------
  |  Branch (1320:7): [True: 0, False: 960]
  ------------------
 1321|      0|         return if_match(req, "ClassicMcEliece_6960119", {1, 3, 6, 1, 4, 1, 22554, 5, 1, 7});
 1322|      0|      case 0x9F764:
  ------------------
  |  Branch (1322:7): [True: 0, False: 960]
  ------------------
 1323|      0|         return if_match(req, "X448", {1, 3, 101, 111});
 1324|      0|      case 0x9F7E2:
  ------------------
  |  Branch (1324:7): [True: 0, False: 960]
  ------------------
 1325|      0|         return if_match(req, "AES-192/GCM", {2, 16, 840, 1, 101, 3, 4, 1, 26});
 1326|      0|      case 0x9F9C5:
  ------------------
  |  Branch (1326:7): [True: 0, False: 960]
  ------------------
 1327|      0|         return if_match(req, "ClassicMcEliece_6688128pcf", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 2});
 1328|      0|      case 0xA0805:
  ------------------
  |  Branch (1328:7): [True: 0, False: 960]
  ------------------
 1329|      0|         return if_match(req, "PKCS9.SDSICertificate", {1, 2, 840, 113549, 1, 9, 22, 2});
 1330|      0|      case 0xA2B5B:
  ------------------
  |  Branch (1330:7): [True: 0, False: 960]
  ------------------
 1331|      0|         return if_match(req, "X509v3.CRLNumber", {2, 5, 29, 20});
 1332|      0|      case 0xA3005:
  ------------------
  |  Branch (1332:7): [True: 0, False: 960]
  ------------------
 1333|      0|         return if_match(req, "X520.Title", {2, 5, 4, 12});
 1334|      0|      case 0xA323F:
  ------------------
  |  Branch (1334:7): [True: 0, False: 960]
  ------------------
 1335|      0|         return if_match(req, "X509v3.NameConstraints", {2, 5, 29, 30});
 1336|      0|      case 0xA3C55:
  ------------------
  |  Branch (1336:7): [True: 0, False: 960]
  ------------------
 1337|      0|         return if_match(req, "X520.Pseudonym", {2, 5, 4, 65});
 1338|      0|      case 0xA4809:
  ------------------
  |  Branch (1338:7): [True: 0, False: 960]
  ------------------
 1339|      0|         return if_match(req, "SphincsPlus-sha2-256f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 6});
 1340|      0|      case 0xA57AF:
  ------------------
  |  Branch (1340:7): [True: 0, False: 960]
  ------------------
 1341|      0|         return if_match(req, "secp521r1", {1, 3, 132, 0, 35});
 1342|      0|      case 0xA5DA9:
  ------------------
  |  Branch (1342:7): [True: 0, False: 960]
  ------------------
 1343|      0|         return if_match(req, "SphincsPlus-shake-256f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 6});
 1344|      0|      case 0xA6865:
  ------------------
  |  Branch (1344:7): [True: 0, False: 960]
  ------------------
 1345|      0|         return if_match(req, "Camellia-128/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 6});
 1346|      0|      case 0xA6C61:
  ------------------
  |  Branch (1346:7): [True: 0, False: 960]
  ------------------
 1347|      0|         return if_match(req, "SM4/GCM", {1, 2, 156, 10197, 1, 104, 8});
 1348|      0|      case 0xA8439:
  ------------------
  |  Branch (1348:7): [True: 0, False: 960]
  ------------------
 1349|      0|         return if_match(req, "PKCS12.CertBag", {1, 2, 840, 113549, 1, 12, 10, 1, 3});
 1350|      0|      case 0xA9061:
  ------------------
  |  Branch (1350:7): [True: 0, False: 960]
  ------------------
 1351|      0|         return if_match(req, "Kyber-768-90s-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 11, 2});
 1352|      0|      case 0xAA995:
  ------------------
  |  Branch (1352:7): [True: 0, False: 960]
  ------------------
 1353|      0|         return if_match(req, "Camellia-192/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 7});
 1354|      0|      case 0xAAE2B:
  ------------------
  |  Branch (1354:7): [True: 0, False: 960]
  ------------------
 1355|      0|         return if_match(req, "Dilithium-8x7-AES-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 10, 3});
 1356|      0|      case 0xABCED:
  ------------------
  |  Branch (1356:7): [True: 0, False: 960]
  ------------------
 1357|      0|         return if_match(req, "GOST.IssuerSigningTool", {1, 2, 643, 100, 112});
 1358|      0|      case 0xABD24:
  ------------------
  |  Branch (1358:7): [True: 0, False: 960]
  ------------------
 1359|      0|         return if_match(req, "RSA/OAEP", {1, 2, 840, 113549, 1, 1, 7});
 1360|      0|      case 0xAC2EC:
  ------------------
  |  Branch (1360:7): [True: 0, False: 960]
  ------------------
 1361|      0|         return if_match(req, "Streebog-256", {1, 2, 643, 7, 1, 1, 2, 2});
 1362|      0|      case 0xAC3DD:
  ------------------
  |  Branch (1362:7): [True: 0, False: 960]
  ------------------
 1363|      0|         return if_match(req, "Certificate Comment", {2, 16, 840, 1, 113730, 1, 13});
 1364|      0|      case 0xAC511:
  ------------------
  |  Branch (1364:7): [True: 0, False: 960]
  ------------------
 1365|      0|         return if_match(req, "PBE-SHA1-3DES", {1, 2, 840, 113549, 1, 12, 1, 3});
 1366|      0|      case 0xAE6FE:
  ------------------
  |  Branch (1366:7): [True: 0, False: 960]
  ------------------
 1367|      0|         return if_match(req, "PKIX.ClientAuth", {1, 3, 6, 1, 5, 5, 7, 3, 2});
 1368|      0|      case 0xAE8D3:
  ------------------
  |  Branch (1368:7): [True: 0, False: 960]
  ------------------
 1369|      0|         return if_match(req, "ClassicMcEliece_8192128pcf", {1, 3, 6, 1, 4, 1, 25258, 1, 18, 6});
 1370|      0|      case 0xAF476:
  ------------------
  |  Branch (1370:7): [True: 0, False: 960]
  ------------------
 1371|      0|         return if_match(req, "ECDH", {1, 3, 132, 1, 12});
 1372|      0|      case 0xAFA6A:
  ------------------
  |  Branch (1372:7): [True: 0, False: 960]
  ------------------
 1373|      0|         return if_match(req, "RSA/PKCS1v15(SHA-3(384))", {2, 16, 840, 1, 101, 3, 4, 3, 15});
 1374|      0|      case 0xB2217:
  ------------------
  |  Branch (1374:7): [True: 0, False: 960]
  ------------------
 1375|      0|         return if_match(req, "AES-256/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 3});
 1376|      0|      case 0xB22F7:
  ------------------
  |  Branch (1376:7): [True: 0, False: 960]
  ------------------
 1377|      0|         return if_match(req, "Camellia-128/GCM", {0, 3, 4401, 5, 3, 1, 9, 6});
 1378|      0|      case 0xB23DE:
  ------------------
  |  Branch (1378:7): [True: 0, False: 960]
  ------------------
 1379|      0|         return if_match(req, "X520.Locality", {2, 5, 4, 7});
 1380|      0|      case 0xB2FBD:
  ------------------
  |  Branch (1380:7): [True: 0, False: 960]
  ------------------
 1381|      0|         return if_match(req, "ECKCDSA/SHA-224", {1, 2, 410, 200004, 1, 100, 4, 4});
 1382|      0|      case 0xB32B0:
  ------------------
  |  Branch (1382:7): [True: 0, False: 960]
  ------------------
 1383|      0|         return if_match(req, "ECKCDSA/SHA-256", {1, 2, 410, 200004, 1, 100, 4, 5});
 1384|      0|      case 0xB360E:
  ------------------
  |  Branch (1384:7): [True: 0, False: 960]
  ------------------
 1385|      0|         return if_match(req, "eFrodoKEM-976-SHAKE", {1, 3, 6, 1, 4, 1, 25258, 1, 16, 2});
 1386|      0|      case 0xB4368:
  ------------------
  |  Branch (1386:7): [True: 0, False: 960]
  ------------------
 1387|      0|         return if_match(req, "ECGDSA/SHA-1", {1, 3, 36, 3, 3, 2, 5, 4, 2});
 1388|      0|      case 0xB58CD:
  ------------------
  |  Branch (1388:7): [True: 0, False: 960]
  ------------------
 1389|      0|         return if_match(req, "RSA/PKCS1v15(SHA-3(512))", {2, 16, 840, 1, 101, 3, 4, 3, 16});
 1390|      0|      case 0xB6427:
  ------------------
  |  Branch (1390:7): [True: 0, False: 960]
  ------------------
 1391|      0|         return if_match(req, "Camellia-192/GCM", {0, 3, 4401, 5, 3, 1, 9, 26});
 1392|      0|      case 0xB7102:
  ------------------
  |  Branch (1392:7): [True: 0, False: 960]
  ------------------
 1393|      0|         return if_match(req, "brainpool224r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 5});
 1394|      0|      case 0xB710D:
  ------------------
  |  Branch (1394:7): [True: 0, False: 960]
  ------------------
 1395|      0|         return if_match(req, "X509v3.CRLIssuingDistributionPoint", {2, 5, 29, 28});
 1396|      0|      case 0xB72D4:
  ------------------
  |  Branch (1396:7): [True: 0, False: 960]
  ------------------
 1397|      0|         return if_match(req, "Microsoft UPN", {1, 3, 6, 1, 4, 1, 311, 20, 2, 3});
 1398|      0|      case 0xB73A5:
  ------------------
  |  Branch (1398:7): [True: 0, False: 960]
  ------------------
 1399|      0|         return if_match(req, "RSA/PSS", {1, 2, 840, 113549, 1, 1, 10});
 1400|      0|      case 0xB84B3:
  ------------------
  |  Branch (1400:7): [True: 0, False: 960]
  ------------------
 1401|      0|         return if_match(req, "PKIX.CodeSigning", {1, 3, 6, 1, 5, 5, 7, 3, 3});
 1402|      0|      case 0xB8CB9:
  ------------------
  |  Branch (1402:7): [True: 0, False: 960]
  ------------------
 1403|      0|         return if_match(req, "GOST-34.10-2012-256", {1, 2, 643, 7, 1, 1, 1, 1});
 1404|      0|      case 0xB945C:
  ------------------
  |  Branch (1404:7): [True: 0, False: 960]
  ------------------
 1405|      0|         return if_match(req, "Twofish/SIV", {1, 3, 6, 1, 4, 1, 25258, 3, 4, 5});
 1406|      0|      case 0xB94E4:
  ------------------
  |  Branch (1406:7): [True: 0, False: 960]
  ------------------
 1407|      0|         return if_match(req, "gost_512A", {1, 2, 643, 7, 1, 2, 1, 2, 1});
 1408|      0|      case 0xB94E5:
  ------------------
  |  Branch (1408:7): [True: 0, False: 960]
  ------------------
 1409|      0|         return if_match(req, "gost_512B", {1, 2, 643, 7, 1, 2, 1, 2, 2});
 1410|      0|      case 0xBA1D8:
  ------------------
  |  Branch (1410:7): [True: 0, False: 960]
  ------------------
 1411|      0|         return if_match(req, "X520.StreetAddress", {2, 5, 4, 9});
 1412|      0|      case 0xBCB45:
  ------------------
  |  Branch (1412:7): [True: 0, False: 960]
  ------------------
 1413|      0|         return if_match(req, "PKCS12.CRLBag", {1, 2, 840, 113549, 1, 12, 10, 1, 4});
 1414|      0|      case 0xBCC82:
  ------------------
  |  Branch (1414:7): [True: 0, False: 960]
  ------------------
 1415|      0|         return if_match(req, "x962_p239v1", {1, 2, 840, 10045, 3, 1, 4});
 1416|      0|      case 0xBCC83:
  ------------------
  |  Branch (1416:7): [True: 0, False: 960]
  ------------------
 1417|      0|         return if_match(req, "x962_p239v2", {1, 2, 840, 10045, 3, 1, 5});
 1418|      0|      case 0xBCC84:
  ------------------
  |  Branch (1418:7): [True: 0, False: 960]
  ------------------
 1419|      0|         return if_match(req, "x962_p239v3", {1, 2, 840, 10045, 3, 1, 6});
 1420|      0|      case 0xBD92B:
  ------------------
  |  Branch (1420:7): [True: 0, False: 960]
  ------------------
 1421|      0|         return if_match(req, "X509v3.HoldInstructionCode", {2, 5, 29, 23});
 1422|      0|      case 0xBDCA9:
  ------------------
  |  Branch (1422:7): [True: 0, False: 960]
  ------------------
 1423|      0|         return if_match(req, "AES-256/GCM", {2, 16, 840, 1, 101, 3, 4, 1, 46});
 1424|      0|      case 0xBE48D:
  ------------------
  |  Branch (1424:7): [True: 0, False: 960]
  ------------------
 1425|      0|         return if_match(req, "PKIX.OCSP.BasicResponse", {1, 3, 6, 1, 5, 5, 7, 48, 1, 1});
 1426|      0|      case 0xBF71E:
  ------------------
  |  Branch (1426:7): [True: 0, False: 960]
  ------------------
 1427|      0|         return if_match(req, "Kyber-1024-r3", {1, 3, 6, 1, 4, 1, 25258, 1, 7, 3});
 1428|      0|      case 0xBFF01:
  ------------------
  |  Branch (1428:7): [True: 0, False: 960]
  ------------------
 1429|      0|         return if_match(req, "DSA/SHA-3(224)", {2, 16, 840, 1, 101, 3, 4, 3, 5});
 1430|      0|      case 0xC0F4F:
  ------------------
  |  Branch (1430:7): [True: 0, False: 960]
  ------------------
 1431|      0|         return if_match(req, "SphincsPlus-haraka-256f-r3.1", {1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 6});
 1432|      0|      case 0xC1875:
  ------------------
  |  Branch (1432:7): [True: 0, False: 960]
  ------------------
 1433|      0|         return if_match(req, "SHA-1", {1, 3, 14, 3, 2, 26});
 1434|      0|      case 0xC28D1:
  ------------------
  |  Branch (1434:7): [True: 0, False: 960]
  ------------------
 1435|      0|         return if_match(req, "PKIX.OCSPSigning", {1, 3, 6, 1, 5, 5, 7, 3, 9});
 1436|      0|      case 0xC42CA:
  ------------------
  |  Branch (1436:7): [True: 0, False: 960]
  ------------------
 1437|      0|         return if_match(req, "brainpool256r1", {1, 3, 36, 3, 3, 2, 8, 1, 1, 7});
 1438|      0|      default:
  ------------------
  |  Branch (1438:7): [True: 0, False: 960]
  ------------------
 1439|      0|         return {};
 1440|    960|   }
 1441|    960|}
_ZN5Botan7OID_Map16load_oid2str_mapEv:
 1443|      1|std::unordered_map<OID, std::string> OID_Map::load_oid2str_map() {
 1444|      1|   return {
 1445|      1|      {OID{2, 5, 8, 1, 1}, "RSA"},
 1446|      1|      {OID{1, 3, 6, 1, 4, 1, 8301, 3, 1, 2, 9, 0, 38}, "secp521r1"},
 1447|      1|      {OID{1, 2, 643, 2, 2, 35, 1}, "gost_256A"},
 1448|      1|      {OID{1, 2, 643, 2, 2, 36, 0}, "gost_256A"},
 1449|      1|   };
 1450|      1|}
_ZN5Botan7OID_Map16load_str2oid_mapEv:
 1452|      1|std::unordered_map<std::string, OID> OID_Map::load_str2oid_map() {
 1453|      1|   return {
 1454|      1|      {"Curve25519", OID{1, 3, 101, 110}},
 1455|      1|      {"SM2_Sig", OID{1, 2, 156, 10197, 1, 301, 1}},
 1456|      1|      {"RSA/EMSA3(MD2)", OID{1, 2, 840, 113549, 1, 1, 2}},
 1457|      1|      {"RSA/EMSA3(MD5)", OID{1, 2, 840, 113549, 1, 1, 4}},
 1458|      1|      {"RSA/EMSA3(SHA-1)", OID{1, 2, 840, 113549, 1, 1, 5}},
 1459|      1|      {"RSA/EMSA3(SHA-256)", OID{1, 2, 840, 113549, 1, 1, 11}},
 1460|      1|      {"RSA/EMSA3(SHA-384)", OID{1, 2, 840, 113549, 1, 1, 12}},
 1461|      1|      {"RSA/EMSA3(SHA-512)", OID{1, 2, 840, 113549, 1, 1, 13}},
 1462|      1|      {"RSA/EMSA3(SHA-224)", OID{1, 2, 840, 113549, 1, 1, 14}},
 1463|      1|      {"RSA/EMSA3(SHA-512-256)", OID{1, 2, 840, 113549, 1, 1, 16}},
 1464|      1|      {"RSA/EMSA3(SHA-3(224))", OID{2, 16, 840, 1, 101, 3, 4, 3, 13}},
 1465|      1|      {"RSA/EMSA3(SHA-3(256))", OID{2, 16, 840, 1, 101, 3, 4, 3, 14}},
 1466|      1|      {"RSA/EMSA3(SHA-3(384))", OID{2, 16, 840, 1, 101, 3, 4, 3, 15}},
 1467|      1|      {"RSA/EMSA3(SHA-3(512))", OID{2, 16, 840, 1, 101, 3, 4, 3, 16}},
 1468|      1|      {"RSA/EMSA3(SM3)", OID{1, 2, 156, 10197, 1, 504}},
 1469|      1|      {"RSA/EMSA3(RIPEMD-160)", OID{1, 3, 36, 3, 3, 1, 2}},
 1470|      1|      {"RSA/EMSA4", OID{1, 2, 840, 113549, 1, 1, 10}},
 1471|      1|      {"PBES2", OID{1, 2, 840, 113549, 1, 5, 13}},
 1472|      1|   };
 1473|      1|}
static_oids.cpp:_ZN5Botan12_GLOBAL__N_113hash_oid_nameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   34|    960|uint32_t hash_oid_name(std::string_view s) {
   35|    960|   uint64_t hash = 0x8188B31879A4879A;
   36|       |
   37|  19.2k|   for(const char c : s) {
  ------------------
  |  Branch (37:21): [True: 19.2k, False: 960]
  ------------------
   38|  19.2k|      hash *= 251;
   39|  19.2k|      hash += c;
   40|  19.2k|   }
   41|       |
   42|    960|   return static_cast<uint32_t>(hash % 805289);
   43|    960|}
static_oids.cpp:_ZN5Botan12_GLOBAL__N_18if_matchENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_St16initializer_listIjE:
   26|    960|std::optional<OID> if_match(std::string_view req, std::string_view actual, std::initializer_list<uint32_t> oid) {
   27|    960|   if(req == actual) {
  ------------------
  |  Branch (27:7): [True: 960, False: 0]
  ------------------
   28|    960|      return OID(oid);
   29|    960|   } else {
   30|      0|      return {};
   31|      0|   }
   32|    960|}

_ZN5Botan13base64_decodeEPhPKcmb:
  208|    181|size_t base64_decode(uint8_t output[], const char input[], size_t input_length, bool ignore_ws) {
  209|    181|#if defined(BOTAN_HAS_BASE64_AVX512)
  210|    181|   if(input_length >= 128 && CPUID::has(CPUID::Feature::AVX512, CPUID::Feature::POPCNT)) {
  ------------------
  |  Branch (210:7): [True: 45, False: 136]
  |  Branch (210:30): [True: 0, False: 45]
  ------------------
  211|       |      // Decoding directly stops at the first block containing whitespace,
  212|       |      // padding, or an invalid character
  213|      0|      const uint8_t* in8 = as_span_of_bytes(input, input_length).data();
  214|      0|      const size_t bulk = base64_decode_avx512(output, in8, input_length);
  215|      0|      size_t written = bulk / 4 * 3;
  216|       |
  217|      0|      const uint8_t* rest = in8 + bulk;
  218|      0|      size_t rest_len = input_length - bulk;
  219|       |
  220|       |      // If the stop may have been due to whitespace, compact the remainder
  221|       |      // and continue decoding
  222|      0|      secure_vector<uint8_t> compacted;
  223|      0|      if(ignore_ws && rest_len > 128) {
  ------------------
  |  Branch (223:10): [True: 0, False: 0]
  |  Branch (223:23): [True: 0, False: 0]
  ------------------
  224|      0|         compacted.resize(rest_len);
  225|      0|         const size_t clean_len = base64_strip_ws_avx512(compacted.data(), rest, rest_len);
  226|      0|         rest = compacted.data();
  227|      0|         rest_len = clean_len;
  228|       |
  229|      0|         const size_t bulk2 = base64_decode_avx512(output + written, rest, rest_len);
  230|      0|         written += bulk2 / 4 * 3;
  231|      0|         rest += bulk2;
  232|      0|         rest_len -= bulk2;
  233|      0|      }
  234|       |
  235|       |      // The scalar decoder handles the final blocks, and with them all of
  236|       |      // the padding logic and error reporting
  237|      0|      const size_t tail_written =
  238|      0|         base_decode_full(Base64(), output + written, cast_uint8_ptr_to_char(rest), rest_len, ignore_ws);
  239|       |
  240|      0|      return written + tail_written;
  241|      0|   }
  242|    181|#endif
  243|       |
  244|    181|   return base_decode_full(Base64(), output, input, input_length, ignore_ws);
  245|    181|}
_ZN5Botan13base64_decodeEPKcmb:
  258|    181|secure_vector<uint8_t> base64_decode(const char input[], size_t input_length, bool ignore_ws) {
  259|    181|   secure_vector<uint8_t> bin(Base64::decode_max_output(input_length));
  260|    181|   const size_t written = base64_decode(bin.data(), input, input_length, ignore_ws);
  261|    181|   bin.resize(written);
  262|    181|   return bin;
  263|    181|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6417decode_max_outputEm:
   49|    362|      static constexpr size_t decode_max_output(size_t input_length) {
   50|       |         // Cannot overflow since each block shrinks when decoded
   51|    362|         return ceil_division(input_length, m_encoding_bytes_out) * m_encoding_bytes_in;
   52|    362|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6413bits_consumedEv:
   40|     37|      static constexpr size_t bits_consumed() noexcept { return m_encoding_bits; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEc:
  118|  50.4k|uint8_t Base64::lookup_binary_value(char input) noexcept {
  119|  50.4k|   const auto has_zero_byte = [](uint64_t v) { return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080); };
  120|       |
  121|       |   // Assumes each byte is either 0x00 or 0x80
  122|  50.4k|   const auto index_of_first_set_byte = [](uint64_t v) {
  123|  50.4k|      return ((((v - 1) & 0x0101010101010101) * 0x0101010101010101) >> 56) - 1;
  124|  50.4k|   };
  125|       |
  126|  50.4k|   constexpr uint64_t lo = 0x0101010101010101;
  127|       |
  128|  50.4k|   const uint8_t x = static_cast<uint8_t>(input);
  129|       |
  130|  50.4k|   const uint64_t x8 = x * lo;
  131|       |
  132|       |   // Defines the valid ASCII ranges of base64, except the special chars (below)
  133|  50.4k|   constexpr uint64_t val_l = make_uint64(0, 0, 0, 0, 0, 'A', 'a', '0');
  134|  50.4k|   constexpr uint64_t val_u = make_uint64(0, 0, 0, 0, 0, 26, 26, 10);
  135|       |
  136|       |   // If x is in one of the ranges return a mask. Otherwise we xor in at the
  137|       |   // high word which will be our invalid marker
  138|  50.4k|   const auto v_mask = swar_in_range<uint64_t>(x8, val_l, val_u) ^ 0x80000000;
  139|       |
  140|       |   // This is the offset added to x to get the value
  141|  50.4k|   const uint64_t val_v = 0xbfb904 ^ (0xFF000000 - (x << 24));
  142|       |
  143|  50.4k|   const uint8_t z = x + static_cast<uint8_t>(val_v >> (8 * index_of_first_set_byte(v_mask)));
  144|       |
  145|       |   // Valid base64 special characters, and some whitespace chars
  146|  50.4k|   constexpr uint64_t specials_i = make_uint64(0, '+', '/', '=', ' ', '\n', '\t', '\r');
  147|       |
  148|  50.4k|   const uint64_t specials_v = 0x3e3f8180808080 ^ (static_cast<uint64_t>(z) << 56);
  149|       |
  150|  50.4k|   const uint64_t smask = has_zero_byte(x8 ^ specials_i) ^ 0x8000000000000000;
  151|       |
  152|  50.4k|   return static_cast<uint8_t>(specials_v >> (8 * index_of_first_set_byte(smask)));
  153|  50.4k|}
base64.cpp:_ZZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEcENK3$_0clEm:
  122|   100k|   const auto index_of_first_set_byte = [](uint64_t v) {
  123|   100k|      return ((((v - 1) & 0x0101010101010101) * 0x0101010101010101) >> 56) - 1;
  124|   100k|   };
base64.cpp:_ZZN5Botan12_GLOBAL__N_16Base6419lookup_binary_valueEcENK3$_1clEm:
  119|  50.4k|   const auto has_zero_byte = [](uint64_t v) { return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080); };
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6414check_bad_charEhcb:
  156|  37.0k|bool Base64::check_bad_char(uint8_t bin, char input, bool ignore_ws) {
  157|  37.0k|   if(bin <= 0x3F) {
  ------------------
  |  Branch (157:7): [True: 8.09k, False: 28.9k]
  ------------------
  158|  8.09k|      return true;
  159|  28.9k|   } else if(!(bin == 0x81 || (bin == 0x80 && ignore_ws))) {
  ------------------
  |  Branch (159:16): [True: 247, False: 28.7k]
  |  Branch (159:32): [True: 28.6k, False: 56]
  |  Branch (159:47): [True: 28.6k, False: 0]
  ------------------
  160|     56|      throw Invalid_Argument(fmt("base64_decode: invalid character '{}'", format_char_for_display(input)));
  161|     56|   }
  162|  28.9k|   return false;
  163|  37.0k|}
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base644nameEv:
   30|     40|      static std::string name() { return "base64"; }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base646decodeEPhPKh:
   60|  2.02k|      static void decode(uint8_t* out_ptr, const uint8_t decode_buf[4]) {
   61|  2.02k|         out_ptr[0] = (decode_buf[0] << 2) | (decode_buf[1] >> 4);
   62|  2.02k|         out_ptr[1] = (decode_buf[1] << 4) | (decode_buf[2] >> 2);
   63|  2.02k|         out_ptr[2] = (decode_buf[2] << 6) | decode_buf[3];
   64|  2.02k|      }
base64.cpp:_ZN5Botan12_GLOBAL__N_16Base6415bytes_to_removeEm:
   66|    110|      static size_t bytes_to_remove(size_t final_truncate) { return final_truncate; }

_ZNK5Botan6BigInt7byte_atEm:
  116|  16.6k|uint8_t BigInt::byte_at(size_t n) const {
  117|  16.6k|   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));
  118|  16.6k|}
_ZNK5Botan6BigInt8cmp_wordEm:
  120|  8.76k|int32_t BigInt::cmp_word(word other) const {
  121|  8.76k|   if(signum() < 0) {
  ------------------
  |  Branch (121:7): [True: 936, False: 7.83k]
  ------------------
  122|    936|      return -1;  // other is positive ...
  123|    936|   }
  124|       |
  125|  7.83k|   const size_t sw = this->sig_words();
  126|  7.83k|   if(sw > 1) {
  ------------------
  |  Branch (126:7): [True: 1.37k, False: 6.45k]
  ------------------
  127|  1.37k|      return 1;  // must be larger since other is just one word ...
  128|  1.37k|   }
  129|       |
  130|  6.45k|   return bigint_cmp(this->_data(), sw, &other, 1);
  131|  7.83k|}
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  189|  14.1k|void BigInt::Data::set_to_zero() {
  190|  14.1k|   m_reg.resize(m_reg.capacity());
  191|  14.1k|   clear_mem(m_reg.data(), m_reg.size());
  192|  14.1k|   m_sig_words = 0;
  193|  14.1k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  213|  14.1k|size_t BigInt::Data::calc_sig_words() const {
  214|  14.1k|   const size_t sz = m_reg.size();
  215|  14.1k|   size_t sig = sz;
  216|       |
  217|  14.1k|   word sub = 1;
  218|       |
  219|   129k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (219:22): [True: 115k, False: 14.1k]
  ------------------
  220|   115k|      const word w = m_reg[sz - i - 1];
  221|   115k|      sub &= ct_is_zero(w);
  222|   115k|      sig -= sub;
  223|   115k|   }
  224|       |
  225|       |   /*
  226|       |   * This depends on the data so is poisoned, but unpoison it here as
  227|       |   * later conditionals are made on the size.
  228|       |   */
  229|  14.1k|   CT::unpoison(sig);
  230|       |
  231|  14.1k|   return sig;
  232|  14.1k|}
_ZNK5Botan6BigInt5bytesEv:
  292|  18.6k|size_t BigInt::bytes() const {
  293|  18.6k|   return ceil_tobytes(bits());
  294|  18.6k|}
_ZNK5Botan6BigInt13top_bits_freeEv:
  296|  22.8k|size_t BigInt::top_bits_free() const {
  297|  22.8k|   const size_t words = sig_words();
  298|       |
  299|  22.8k|   const word top_word = word_at(words - 1);
  300|  22.8k|   const size_t bits_used = high_bit(CT::value_barrier(top_word));
  301|  22.8k|   CT::unpoison(bits_used);
  302|  22.8k|   return WordInfo<word>::bits - bits_used;
  303|  22.8k|}
_ZNK5Botan6BigInt4bitsEv:
  305|  22.9k|size_t BigInt::bits() const {
  306|  22.9k|   const size_t words = sig_words();
  307|       |
  308|  22.9k|   if(words == 0) {
  ------------------
  |  Branch (308:7): [True: 70, False: 22.8k]
  ------------------
  309|     70|      return 0;
  310|     70|   }
  311|       |
  312|  22.8k|   const size_t full_words = (words - 1) * WordInfo<word>::bits;
  313|  22.8k|   const size_t top_bits = WordInfo<word>::bits - top_bits_free();
  314|       |
  315|  22.8k|   return full_words + top_bits;
  316|  22.9k|}
_ZNK5Botan6BigInt12serialize_toENSt3__14spanIhLm18446744073709551615EEE:
  393|  9.34k|void BigInt::serialize_to(std::span<uint8_t> output) const {
  394|  9.34k|   BOTAN_ARG_CHECK(this->bytes() <= output.size(), "Insufficient output space");
  ------------------
  |  |   35|  9.34k|   do {                                                          \
  |  |   36|  9.34k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */              \
  |  |   37|  9.34k|      if(!(expr)) {                                              \
  |  |  ------------------
  |  |  |  Branch (37:10): [True: 0, False: 9.34k]
  |  |  ------------------
  |  |   38|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */     \
  |  |   39|      0|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   40|      0|      }                                                          \
  |  |   41|  9.34k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (41:12): [Folded, False: 9.34k]
  |  |  ------------------
  ------------------
  395|       |
  396|  9.34k|   this->binary_encode(output.data(), output.size());
  397|  9.34k|}
_ZNK5Botan6BigInt13binary_encodeEPhm:
  402|  9.34k|void BigInt::binary_encode(uint8_t output[], size_t len) const {
  403|  9.34k|   const size_t full_words = len / sizeof(word);
  404|  9.34k|   const size_t extra_bytes = len % sizeof(word);
  405|       |
  406|  13.8k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (406:22): [True: 4.52k, False: 9.34k]
  ------------------
  407|  4.52k|      const word w = word_at(i);
  408|  4.52k|      store_be(w, output + (len - (i + 1) * sizeof(word)));
  409|  4.52k|   }
  410|       |
  411|  9.34k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (411:7): [True: 9.26k, False: 76]
  ------------------
  412|  9.26k|      const word w = word_at(full_words);
  413|       |
  414|  32.7k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (414:25): [True: 23.4k, False: 9.26k]
  ------------------
  415|  23.4k|         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);
  416|  23.4k|      }
  417|  9.26k|   }
  418|  9.34k|}
_ZN5Botan6BigInt17assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  423|  14.1k|void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {
  424|  14.1k|   clear();
  425|       |
  426|  14.1k|   const size_t length = bytes.size();
  427|  14.1k|   const size_t full_words = length / sizeof(word);
  428|  14.1k|   const size_t extra_bytes = length % sizeof(word);
  429|       |
  430|  14.1k|   const size_t total_words = full_words + (extra_bytes > 0 ? 1 : 0);
  ------------------
  |  Branch (430:45): [True: 12.6k, False: 1.47k]
  ------------------
  431|       |
  432|  14.1k|   secure_vector<word> reg(8 * ceil_division<size_t>(total_words, 8));
  433|       |
  434|  20.1k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (434:22): [True: 6.06k, False: 14.1k]
  ------------------
  435|  6.06k|      reg[i] = load_be<word>(bytes.last<sizeof(word)>());
  436|  6.06k|      bytes = bytes.first(bytes.size() - sizeof(word));
  437|  6.06k|   }
  438|       |
  439|  14.1k|   if(!bytes.empty()) {
  ------------------
  |  Branch (439:7): [True: 12.6k, False: 1.47k]
  ------------------
  440|  12.6k|      BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());
  ------------------
  |  |   84|  12.6k|   do {                                                                     \
  |  |   85|  12.6k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  12.6k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 12.6k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  12.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 12.6k]
  |  |  ------------------
  ------------------
  441|  12.6k|      std::array<uint8_t, sizeof(word)> last_partial_word = {0};
  442|  12.6k|      copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);
  443|  12.6k|      reg[full_words] = load_be<word>(last_partial_word);
  444|  12.6k|   }
  445|       |
  446|  14.1k|   m_data.swap(reg);
  447|  14.1k|}
_ZNK5Botan6BigInt20_const_time_unpoisonEv:
  559|  29.2k|void BigInt::_const_time_unpoison() const {
  560|  29.2k|   CT::unpoison(m_data.const_data(), m_data.size());
  561|  29.2k|}

_ZN5Botan8PEM_Code6decodeERNS_10DataSourceERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   64|    355|secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   65|    355|   const size_t RANDOM_CHAR_LIMIT = 8;
   66|       |
   67|    355|   label.clear();
   68|       |
   69|    355|   const std::string PEM_HEADER1 = "-----BEGIN ";
   70|    355|   const std::string PEM_HEADER2 = "-----";
   71|    355|   size_t position = 0;
   72|       |
   73|  26.9k|   while(position != PEM_HEADER1.length()) {
  ------------------
  |  Branch (73:10): [True: 26.6k, False: 313]
  ------------------
   74|  26.6k|      auto b = source.read_byte();
   75|       |
   76|  26.6k|      if(!b) {
  ------------------
  |  Branch (76:10): [True: 41, False: 26.6k]
  ------------------
   77|     41|         throw Decoding_Error("PEM: No PEM header found");
   78|     41|      }
   79|  26.6k|      if(static_cast<char>(*b) == PEM_HEADER1[position]) {
  ------------------
  |  Branch (79:10): [True: 3.77k, False: 22.8k]
  ------------------
   80|  3.77k|         ++position;
   81|  22.8k|      } else if(position >= RANDOM_CHAR_LIMIT) {
  ------------------
  |  Branch (81:17): [True: 1, False: 22.8k]
  ------------------
   82|      1|         throw Decoding_Error("PEM: Malformed PEM header");
   83|  22.8k|      } else {
   84|  22.8k|         position = 0;
   85|  22.8k|      }
   86|  26.6k|   }
   87|    313|   position = 0;
   88|  5.04k|   while(position != PEM_HEADER2.length()) {
  ------------------
  |  Branch (88:10): [True: 4.77k, False: 268]
  ------------------
   89|  4.77k|      auto b = source.read_byte();
   90|       |
   91|  4.77k|      if(!b) {
  ------------------
  |  Branch (91:10): [True: 41, False: 4.73k]
  ------------------
   92|     41|         throw Decoding_Error("PEM: No PEM header found");
   93|     41|      }
   94|  4.73k|      if(static_cast<char>(*b) == PEM_HEADER2[position]) {
  ------------------
  |  Branch (94:10): [True: 1.35k, False: 3.37k]
  ------------------
   95|  1.35k|         ++position;
   96|  3.37k|      } else if(position > 0) {
  ------------------
  |  Branch (96:17): [True: 3, False: 3.37k]
  ------------------
   97|      3|         throw Decoding_Error("PEM: Malformed PEM header");
   98|      3|      }
   99|       |
  100|  4.73k|      if(position == 0) {
  ------------------
  |  Branch (100:10): [True: 3.37k, False: 1.35k]
  ------------------
  101|  3.37k|         if(label.size() >= 128) {
  ------------------
  |  Branch (101:13): [True: 1, False: 3.37k]
  ------------------
  102|      1|            throw Decoding_Error("PEM: Label too long");
  103|      1|         }
  104|  3.37k|         label += static_cast<char>(*b);
  105|  3.37k|      }
  106|  4.73k|   }
  107|       |
  108|    268|   std::vector<char> b64;
  109|       |
  110|    268|   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
  111|    268|   position = 0;
  112|  99.7k|   while(position != PEM_TRAILER.length()) {
  ------------------
  |  Branch (112:10): [True: 99.5k, False: 181]
  ------------------
  113|  99.5k|      auto b = source.read_byte();
  114|       |
  115|  99.5k|      if(!b) {
  ------------------
  |  Branch (115:10): [True: 76, False: 99.5k]
  ------------------
  116|     76|         throw Decoding_Error("PEM: No PEM trailer found");
  117|     76|      }
  118|  99.5k|      if(static_cast<char>(*b) == PEM_TRAILER[position]) {
  ------------------
  |  Branch (118:10): [True: 3.88k, False: 95.6k]
  ------------------
  119|  3.88k|         ++position;
  120|  95.6k|      } else if(position > 0) {
  ------------------
  |  Branch (120:17): [True: 11, False: 95.6k]
  ------------------
  121|     11|         throw Decoding_Error("PEM: Malformed PEM trailer");
  122|     11|      }
  123|       |
  124|  99.5k|      if(position == 0) {
  ------------------
  |  Branch (124:10): [True: 95.6k, False: 3.88k]
  ------------------
  125|  95.6k|         b64.push_back(*b);
  126|  95.6k|      }
  127|  99.5k|   }
  128|       |
  129|    181|   return base64_decode(b64.data(), b64.size());
  130|    268|}
_ZN5Botan8PEM_Code7matchesERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
  146|  3.85k|bool matches(DataSource& source, std::string_view extra, size_t search_range) {
  147|  3.85k|   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
  148|       |
  149|  3.85k|   std::array<uint8_t, 4096> stack_buf{};
  150|  3.85k|   std::vector<uint8_t> heap_buf;
  151|  3.85k|   uint8_t* search_buf = stack_buf.data();
  152|  3.85k|   if(search_range > stack_buf.size()) {
  ------------------
  |  Branch (152:7): [True: 0, False: 3.85k]
  ------------------
  153|      0|      heap_buf.resize(search_range);
  154|      0|      search_buf = heap_buf.data();
  155|      0|   }
  156|       |
  157|  3.85k|   const size_t got = source.peek(search_buf, search_range, 0);
  158|       |
  159|  3.85k|   if(got < PEM_HEADER.length()) {
  ------------------
  |  Branch (159:7): [True: 475, False: 3.38k]
  ------------------
  160|    475|      return false;
  161|    475|   }
  162|       |
  163|  3.38k|   return std::search(search_buf, search_buf + got, PEM_HEADER.begin(), PEM_HEADER.end()) != search_buf + got;
  164|  3.85k|}

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

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

_ZN5Botan19next_utf8_codepointENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEERm:
   53|  17.4k|uint32_t next_utf8_codepoint(std::string_view utf8, size_t& pos) {
   54|  17.4k|   const auto read_continuation = [&]() -> uint32_t {
   55|  17.4k|      if(pos >= utf8.size()) {
   56|  17.4k|         throw Decoding_Error("Invalid UTF-8 sequence");
   57|  17.4k|      }
   58|  17.4k|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   59|  17.4k|      if((b & 0xC0) != 0x80) {
   60|  17.4k|         throw Decoding_Error("Invalid UTF-8 sequence");
   61|  17.4k|      }
   62|  17.4k|      return b & 0x3F;
   63|  17.4k|   };
   64|       |
   65|  17.4k|   if(pos >= utf8.size()) {
  ------------------
  |  Branch (65:7): [True: 0, False: 17.4k]
  ------------------
   66|      0|      throw Decoding_Error("Invalid UTF-8 sequence");
   67|      0|   }
   68|  17.4k|   const uint8_t lead = static_cast<uint8_t>(utf8[pos++]);
   69|  17.4k|   uint32_t c = 0;
   70|       |
   71|  17.4k|   if(lead <= 0x7F) {
  ------------------
  |  Branch (71:7): [True: 17.0k, False: 360]
  ------------------
   72|  17.0k|      c = lead;
   73|  17.0k|   } else if((lead & 0xE0) == 0xC0) {
  ------------------
  |  Branch (73:14): [True: 109, False: 251]
  ------------------
   74|    109|      c = (lead & 0x1F) << 6;
   75|    109|      c |= read_continuation();
   76|    109|      if(c < 0x80) {
  ------------------
  |  Branch (76:10): [True: 11, False: 98]
  ------------------
   77|     11|         throw Decoding_Error("Overlong UTF-8 sequence");
   78|     11|      }
   79|    251|   } else if((lead & 0xF0) == 0xE0) {
  ------------------
  |  Branch (79:14): [True: 100, False: 151]
  ------------------
   80|    100|      c = (lead & 0x0F) << 12;
   81|    100|      c |= read_continuation() << 6;
   82|    100|      c |= read_continuation();
   83|    100|      if(c < 0x800) {
  ------------------
  |  Branch (83:10): [True: 7, False: 93]
  ------------------
   84|      7|         throw Decoding_Error("Overlong UTF-8 sequence");
   85|      7|      }
   86|    151|   } else if((lead & 0xF8) == 0xF0) {
  ------------------
  |  Branch (86:14): [True: 92, False: 59]
  ------------------
   87|     92|      c = (lead & 0x07) << 18;
   88|     92|      c |= read_continuation() << 12;
   89|     92|      c |= read_continuation() << 6;
   90|     92|      c |= read_continuation();
   91|     92|      if(c < 0x10000) {
  ------------------
  |  Branch (91:10): [True: 6, False: 86]
  ------------------
   92|      6|         throw Decoding_Error("Overlong UTF-8 sequence");
   93|      6|      }
   94|     92|   } else {
   95|     59|      throw Decoding_Error("Invalid UTF-8 sequence");
   96|     59|   }
   97|       |
   98|  17.3k|   if(c > 0x10FFFF) {
  ------------------
  |  Branch (98:7): [True: 4, False: 17.3k]
  ------------------
   99|      4|      throw Decoding_Error("UTF-8 sequence encodes value outside Unicode range");
  100|      4|   }
  101|  17.3k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (101:7): [True: 80, False: 17.2k]
  |  Branch (101:22): [True: 8, False: 72]
  ------------------
  102|      8|      throw Decoding_Error("UTF-8 sequence encodes surrogate code point");
  103|      8|   }
  104|       |
  105|  17.3k|   return c;
  106|  17.3k|}
_ZN5Botan13is_valid_utf8ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  108|  2.81k|bool is_valid_utf8(std::string_view utf8) {
  109|  2.81k|   try {
  110|  2.81k|      size_t pos = 0;
  111|  20.2k|      while(pos < utf8.size()) {
  ------------------
  |  Branch (111:13): [True: 17.4k, False: 2.81k]
  ------------------
  112|  17.4k|         const uint32_t c = next_utf8_codepoint(utf8, pos);
  113|  17.4k|         BOTAN_UNUSED(c);
  ------------------
  |  |  151|  17.4k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  114|  17.4k|      }
  115|  2.81k|   } catch(Decoding_Error&) {
  116|    148|      return false;
  117|    148|   }
  118|  2.66k|   return true;
  119|  2.81k|}
_ZN5Botan12ucs2_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  121|    250|std::string ucs2_to_utf8(std::span<const uint8_t> ucs2) {
  122|    250|   if(ucs2.size() % 2 != 0) {
  ------------------
  |  Branch (122:7): [True: 3, False: 247]
  ------------------
  123|      3|      throw Decoding_Error("Invalid length for UCS-2 string");
  124|      3|   }
  125|       |
  126|    247|   const size_t chars = ucs2.size() / 2;
  127|       |
  128|    247|   std::string s;
  129|  1.31k|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (129:22): [True: 1.07k, False: 247]
  ------------------
  130|  1.07k|      const uint32_t c = load_be<uint16_t>(ucs2.data(), i);
  131|  1.07k|      append_utf8_for(s, c);
  132|  1.07k|   }
  133|       |
  134|    247|   return s;
  135|    250|}
_ZN5Botan12ucs4_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  155|     95|std::string ucs4_to_utf8(std::span<const uint8_t> ucs4) {
  156|     95|   if(ucs4.size() % 4 != 0) {
  ------------------
  |  Branch (156:7): [True: 3, False: 92]
  ------------------
  157|      3|      throw Decoding_Error("Invalid length for UCS-4 string");
  158|      3|   }
  159|       |
  160|     92|   const size_t chars = ucs4.size() / 4;
  161|       |
  162|     92|   std::string s;
  163|    292|   for(size_t i = 0; i != chars; ++i) {
  ------------------
  |  Branch (163:22): [True: 200, False: 92]
  ------------------
  164|    200|      const uint32_t c = load_be<uint32_t>(ucs4.data(), i);
  165|    200|      append_utf8_for(s, c);
  166|    200|   }
  167|       |
  168|     92|   return s;
  169|     95|}
_ZN5Botan14latin1_to_utf8ENSt3__14spanIKhLm18446744073709551615EEE:
  190|    299|std::string latin1_to_utf8(std::span<const uint8_t> chars) {
  191|    299|   std::string s;
  192|  4.27k|   for(const uint8_t b : chars) {
  ------------------
  |  Branch (192:24): [True: 4.27k, False: 299]
  ------------------
  193|  4.27k|      append_utf8_for(s, static_cast<uint32_t>(b));
  194|  4.27k|   }
  195|    299|   return s;
  196|    299|}
_ZN5Botan21is_ascii_control_charEc:
  198|     56|bool is_ascii_control_char(char c) {
  199|     56|   const uint8_t b = static_cast<uint8_t>(c);
  200|     56|   return b < 0x20 || b == 0x7F;
  ------------------
  |  Branch (200:11): [True: 21, False: 35]
  |  Branch (200:23): [True: 2, False: 33]
  ------------------
  201|     56|}
_ZN5Botan23format_char_for_displayEc:
  243|     56|std::string format_char_for_display(char c) {
  244|     56|   std::string out;
  245|     56|   out += '\'';
  246|       |
  247|     56|   if(c == '\t') {
  ------------------
  |  Branch (247:7): [True: 0, False: 56]
  ------------------
  248|      0|      out += "\\t";
  249|     56|   } else if(c == '\n') {
  ------------------
  |  Branch (249:14): [True: 0, False: 56]
  ------------------
  250|      0|      out += "\\n";
  251|     56|   } else if(c == '\r') {
  ------------------
  |  Branch (251:14): [True: 0, False: 56]
  ------------------
  252|      0|      out += "\\r";
  253|     56|   } else if(is_ascii_control_char(c) || static_cast<uint8_t>(c) >= 0x80) {
  ------------------
  |  Branch (253:14): [True: 23, False: 33]
  |  Branch (253:42): [True: 22, False: 11]
  ------------------
  254|     45|      const auto b = static_cast<uint8_t>(c);
  255|     45|      out += "\\x";
  256|     45|      out += nibble_to_hex(b >> 4);
  257|     45|      out += nibble_to_hex(b);
  258|     45|   } else {
  259|     11|      out += c;
  260|     11|   }
  261|       |
  262|     56|   out += '\'';
  263|       |
  264|     56|   return out;
  265|     56|}
charset.cpp:_ZZN5Botan19next_utf8_codepointENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEERmENK3$_0clEv:
   54|    555|   const auto read_continuation = [&]() -> uint32_t {
   55|    555|      if(pos >= utf8.size()) {
  ------------------
  |  Branch (55:10): [True: 16, False: 539]
  ------------------
   56|     16|         throw Decoding_Error("Invalid UTF-8 sequence");
   57|     16|      }
   58|    539|      const uint8_t b = static_cast<uint8_t>(utf8[pos++]);
   59|    539|      if((b & 0xC0) != 0x80) {
  ------------------
  |  Branch (59:10): [True: 37, False: 502]
  ------------------
   60|     37|         throw Decoding_Error("Invalid UTF-8 sequence");
   61|     37|      }
   62|    502|      return b & 0x3F;
   63|    539|   };
charset.cpp:_ZN5Botan12_GLOBAL__N_115append_utf8_forERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj:
   17|  5.54k|void append_utf8_for(std::string& s, uint32_t c) {
   18|  5.54k|   if(c >= 0xD800 && c < 0xE000) {
  ------------------
  |  Branch (18:7): [True: 438, False: 5.10k]
  |  Branch (18:22): [True: 9, False: 429]
  ------------------
   19|      9|      throw Decoding_Error("Invalid Unicode character");
   20|      9|   }
   21|       |
   22|  5.53k|   if(c <= 0x7F) {
  ------------------
  |  Branch (22:7): [True: 3.45k, False: 2.08k]
  ------------------
   23|  3.45k|      const uint8_t b0 = static_cast<uint8_t>(c);
   24|  3.45k|      s.push_back(static_cast<char>(b0));
   25|  3.45k|   } else if(c <= 0x7FF) {
  ------------------
  |  Branch (25:14): [True: 1.14k, False: 946]
  ------------------
   26|  1.14k|      const uint8_t b0 = 0xC0 | static_cast<uint8_t>(c >> 6);
   27|  1.14k|      const uint8_t b1 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   28|  1.14k|      s.push_back(static_cast<char>(b0));
   29|  1.14k|      s.push_back(static_cast<char>(b1));
   30|  1.14k|   } else if(c <= 0xFFFF) {
  ------------------
  |  Branch (30:14): [True: 783, False: 163]
  ------------------
   31|    783|      const uint8_t b0 = 0xE0 | static_cast<uint8_t>(c >> 12);
   32|    783|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   33|    783|      const uint8_t b2 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   34|    783|      s.push_back(static_cast<char>(b0));
   35|    783|      s.push_back(static_cast<char>(b1));
   36|    783|      s.push_back(static_cast<char>(b2));
   37|    783|   } else if(c <= 0x10FFFF) {
  ------------------
  |  Branch (37:14): [True: 112, False: 51]
  ------------------
   38|    112|      const uint8_t b0 = 0xF0 | static_cast<uint8_t>(c >> 18);
   39|    112|      const uint8_t b1 = 0x80 | static_cast<uint8_t>((c >> 12) & 0x3F);
   40|    112|      const uint8_t b2 = 0x80 | static_cast<uint8_t>((c >> 6) & 0x3F);
   41|    112|      const uint8_t b3 = 0x80 | static_cast<uint8_t>(c & 0x3F);
   42|    112|      s.push_back(static_cast<char>(b0));
   43|    112|      s.push_back(static_cast<char>(b1));
   44|    112|      s.push_back(static_cast<char>(b2));
   45|    112|      s.push_back(static_cast<char>(b3));
   46|    112|   } else {
   47|     51|      throw Decoding_Error("Invalid Unicode character");
   48|     51|   }
   49|  5.53k|}

_ZN5Botan5CPUID10CPUID_DataC2Ev:
   80|      1|CPUID::CPUID_Data::CPUID_Data() {
   81|       |   // NOLINTBEGIN(*-prefer-member-initializer)
   82|      1|#if defined(BOTAN_HAS_CPUID_DETECTION)
   83|      1|   m_processor_features = detect_cpu_features(~cleared_cpuid_bits());
   84|       |#else
   85|       |   m_processor_features = 0;
   86|       |#endif
   87|       |   // NOLINTEND(*-prefer-member-initializer)
   88|      1|}
cpuid.cpp:_ZN5Botan12_GLOBAL__N_118cleared_cpuid_bitsEv:
   59|      1|uint32_t cleared_cpuid_bits() {
   60|      1|   uint32_t cleared = 0;
   61|       |
   62|      1|   #if defined(BOTAN_HAS_OS_UTILS)
   63|      1|   std::string clear_cpuid_env;
   64|      1|   if(OS::read_env_variable(clear_cpuid_env, "BOTAN_CLEAR_CPUID")) {
  ------------------
  |  Branch (64:7): [True: 0, False: 1]
  ------------------
   65|      0|      for(const auto& cpuid : split_on(clear_cpuid_env, ',')) {
  ------------------
  |  Branch (65:29): [True: 0, False: 0]
  ------------------
   66|      0|         if(auto bit = CPUID::bit_from_string(cpuid)) {
  ------------------
  |  Branch (66:18): [True: 0, False: 0]
  ------------------
   67|      0|            cleared |= bit->as_u32();
   68|      0|         }
   69|      0|      }
   70|      0|   }
   71|      1|   #endif
   72|       |
   73|      1|   return cleared;
   74|      1|}

_ZN5Botan5CPUID10CPUID_Data19detect_cpu_featuresEj:
   62|      1|uint32_t CPUID::CPUID_Data::detect_cpu_features(uint32_t allowed) {
   63|      1|   enum class x86_CPUID_1_bits : uint64_t {
   64|      1|      RDTSC = (1ULL << 4),
   65|      1|      SSE2 = (1ULL << 26),
   66|      1|      CLMUL = (1ULL << 33),
   67|      1|      SSSE3 = (1ULL << 41),
   68|      1|      SSE41 = (1ULL << 51),
   69|      1|      POPCNT = (1ULL << 55),
   70|      1|      AESNI = (1ULL << 57),
   71|       |      // AVX + OSXSAVE
   72|      1|      OSXSAVE = (1ULL << 59) | (1ULL << 60),
   73|      1|      RDRAND = (1ULL << 62)
   74|      1|   };
   75|       |
   76|      1|   enum class x86_CPUID_7_bits : uint64_t {
   77|      1|      BMI1 = (1ULL << 3),
   78|      1|      AVX2 = (1ULL << 5),
   79|      1|      BMI2 = (1ULL << 8),
   80|      1|      BMI_1_AND_2 = BMI1 | BMI2,
   81|      1|      AVX512_F = (1ULL << 16),
   82|      1|      AVX512_DQ = (1ULL << 17),
   83|      1|      RDSEED = (1ULL << 18),
   84|      1|      ADX = (1ULL << 19),
   85|      1|      AVX512_IFMA = (1ULL << 21),
   86|      1|      SHA = (1ULL << 29),
   87|      1|      AVX512_BW = (1ULL << 30),
   88|      1|      AVX512_VL = (1ULL << 31),
   89|      1|      AVX512_VBMI = (1ULL << 33),
   90|      1|      AVX512_VBMI2 = (1ULL << 38),
   91|      1|      GFNI = (1ULL << 40),
   92|      1|      AVX512_VAES = (1ULL << 41),
   93|      1|      AVX512_VCLMUL = (1ULL << 42),
   94|      1|      AVX512_VBITALG = (1ULL << 44),
   95|       |
   96|       |      /*
   97|       |      We only enable AVX512 support if all of the below flags are available
   98|       |
   99|       |      This is more than we strictly need for most uses, however it also has
  100|       |      the effect of preventing execution of AVX512 codepaths on cores that
  101|       |      have serious downclocking problems when AVX512 code executes,
  102|       |      especially Intel Skylake.
  103|       |
  104|       |      VBMI2/VBITALG are the key flags here as they restrict us to Intel Ice
  105|       |      Lake/Rocket Lake, or AMD Zen4, all of which do not have penalties for
  106|       |      executing AVX512.
  107|       |
  108|       |      There is nothing stopping some future processor from supporting the
  109|       |      above flags and having AVX512 penalties, but maybe you should not have
  110|       |      bought such a processor.
  111|       |      */
  112|      1|      AVX512_PROFILE =
  113|      1|         AVX512_F | AVX512_DQ | AVX512_IFMA | AVX512_BW | AVX512_VL | AVX512_VBMI | AVX512_VBMI2 | AVX512_VBITALG,
  114|      1|   };
  115|       |
  116|       |   // NOLINTNEXTLINE(performance-enum-size)
  117|      1|   enum class x86_CPUID_7_1_bits : uint64_t {
  118|      1|      SHA512 = (1 << 0),
  119|      1|      SM3 = (1 << 1),
  120|      1|      SM4 = (1 << 2),
  121|      1|   };
  122|       |
  123|      1|   uint32_t feat = 0;
  124|      1|   uint32_t cpuid[4] = {0};
  125|      1|   bool has_sse41 = false;
  126|      1|   bool has_os_ymm_support = false;
  127|      1|   bool has_os_zmm_support = false;
  128|       |
  129|       |   // CPUID 0: vendor identification, max sublevel
  130|      1|   invoke_cpuid(0, cpuid);
  131|       |
  132|      1|   const uint32_t max_supported_sublevel = cpuid[0];
  133|       |
  134|      1|   if(max_supported_sublevel >= 1) {
  ------------------
  |  Branch (134:7): [True: 1, False: 0]
  ------------------
  135|       |      // CPUID 1: feature bits
  136|      1|      invoke_cpuid(1, cpuid);
  137|      1|      const uint64_t flags0 = (static_cast<uint64_t>(cpuid[2]) << 32) | cpuid[3];
  138|       |
  139|      1|      feat |= if_set(flags0, x86_CPUID_1_bits::RDTSC, CPUFeature::Bit::RDTSC, allowed);
  140|       |
  141|      1|      feat |= if_set(flags0, x86_CPUID_1_bits::RDRAND, CPUFeature::Bit::RDRAND, allowed);
  142|       |
  143|      1|      feat |= if_set(flags0, x86_CPUID_1_bits::POPCNT, CPUFeature::Bit::POPCNT, allowed);
  144|       |
  145|      1|      feat |= if_set(flags0, x86_CPUID_1_bits::SSE2, CPUFeature::Bit::SSE2, allowed);
  146|       |
  147|      1|      if(is_set(feat, CPUFeature::Bit::SSE2)) {
  ------------------
  |  Branch (147:10): [True: 1, False: 0]
  ------------------
  148|      1|         feat |= if_set(flags0, x86_CPUID_1_bits::SSSE3, CPUFeature::Bit::SSSE3, allowed);
  149|       |
  150|      1|         if(is_set(feat, CPUFeature::Bit::SSSE3)) {
  ------------------
  |  Branch (150:13): [True: 1, False: 0]
  ------------------
  151|      1|            feat |= if_set(flags0, x86_CPUID_1_bits::CLMUL, CPUFeature::Bit::CLMUL, allowed);
  152|      1|            feat |= if_set(flags0, x86_CPUID_1_bits::AESNI, CPUFeature::Bit::AESNI, allowed);
  153|       |
  154|       |            // SSE4.1 is not tracked as a feature, but is required by the SHA-NI code
  155|      1|            const uint64_t sse41 = static_cast<uint64_t>(x86_CPUID_1_bits::SSE41);
  156|      1|            has_sse41 = (flags0 & sse41) == sse41;
  157|      1|         }
  158|       |
  159|      1|         const uint64_t osxsave64 = static_cast<uint64_t>(x86_CPUID_1_bits::OSXSAVE);
  160|      1|         if((flags0 & osxsave64) == osxsave64) {
  ------------------
  |  Branch (160:13): [True: 1, False: 0]
  ------------------
  161|      1|            const uint64_t xcr_flags = xgetbv();
  162|      1|            if((xcr_flags & 0x6) == 0x6) {
  ------------------
  |  Branch (162:16): [True: 1, False: 0]
  ------------------
  163|      1|               has_os_ymm_support = true;
  164|      1|               has_os_zmm_support = (xcr_flags & 0xE0) == 0xE0;
  165|      1|            }
  166|      1|         }
  167|      1|      }
  168|      1|   }
  169|       |
  170|      1|   if(max_supported_sublevel >= 7) {
  ------------------
  |  Branch (170:7): [True: 1, False: 0]
  ------------------
  171|      1|      clear_mem(cpuid, 4);
  172|      1|      invoke_cpuid_sublevel(7, 0, cpuid);
  173|       |
  174|      1|      const uint64_t flags7 = (static_cast<uint64_t>(cpuid[2]) << 32) | cpuid[1];
  175|       |
  176|      1|      clear_mem(cpuid, 4);
  177|      1|      invoke_cpuid_sublevel(7, 1, cpuid);
  178|      1|      const uint32_t flags7_1 = cpuid[0];
  179|       |
  180|      1|      feat |= if_set(flags7, x86_CPUID_7_bits::RDSEED, CPUFeature::Bit::RDSEED, allowed);
  181|      1|      feat |= if_set(flags7, x86_CPUID_7_bits::ADX, CPUFeature::Bit::ADX, allowed);
  182|       |
  183|       |      /*
  184|       |      We only set the BMI bit if both BMI1 and BMI2 are supported, since
  185|       |      typically we want to use both extensions in the same code.
  186|       |      */
  187|      1|      feat |= if_set(flags7, x86_CPUID_7_bits::BMI_1_AND_2, CPUFeature::Bit::BMI, allowed);
  188|       |
  189|      1|      if(is_set(feat, CPUFeature::Bit::SSSE3)) {
  ------------------
  |  Branch (189:10): [True: 1, False: 0]
  ------------------
  190|       |         // The SHA-NI code uses SSE4.1 instructions in addition to SSSE3
  191|      1|         if(has_sse41) {
  ------------------
  |  Branch (191:13): [True: 1, False: 0]
  ------------------
  192|      1|            feat |= if_set(flags7, x86_CPUID_7_bits::SHA, CPUFeature::Bit::SHA, allowed);
  193|      1|         }
  194|       |
  195|       |         // We only consider AVX2 if SSSE3 is supported
  196|      1|         if(has_os_ymm_support) {
  ------------------
  |  Branch (196:13): [True: 1, False: 0]
  ------------------
  197|      1|            feat |= if_set(flags7, x86_CPUID_7_bits::AVX2, CPUFeature::Bit::AVX2, allowed);
  198|       |
  199|      1|            if(is_set(feat, CPUFeature::Bit::AVX2)) {
  ------------------
  |  Branch (199:16): [True: 1, False: 0]
  ------------------
  200|      1|               feat |= if_set(flags7, x86_CPUID_7_bits::GFNI, CPUFeature::Bit::GFNI, allowed);
  201|      1|               feat |= if_set(flags7, x86_CPUID_7_bits::AVX512_VAES, CPUFeature::Bit::AVX2_AES, allowed);
  202|      1|               feat |= if_set(flags7_1, x86_CPUID_7_1_bits::SHA512, CPUFeature::Bit::SHA512, allowed);
  203|       |               // The SM3/SM4 instructions are VEX encoded and the code using them also uses AVX2
  204|      1|               feat |= if_set(flags7_1, x86_CPUID_7_1_bits::SM3, CPUFeature::Bit::SM3, allowed);
  205|      1|               feat |= if_set(flags7_1, x86_CPUID_7_1_bits::SM4, CPUFeature::Bit::SM4, allowed);
  206|       |
  207|       |               // The VPCLMULQDQ code also uses the legacy 128-bit PCLMULQDQ instruction
  208|      1|               if(is_set(feat, CPUFeature::Bit::CLMUL)) {
  ------------------
  |  Branch (208:19): [True: 1, False: 0]
  ------------------
  209|      1|                  feat |= if_set(flags7, x86_CPUID_7_bits::AVX512_VCLMUL, CPUFeature::Bit::AVX2_CLMUL, allowed);
  210|      1|               }
  211|       |
  212|       |               // Likewise we only consider AVX-512 if AVX2 is supported
  213|      1|               if(has_os_zmm_support) {
  ------------------
  |  Branch (213:19): [True: 0, False: 1]
  ------------------
  214|      0|                  feat |= if_set(flags7, x86_CPUID_7_bits::AVX512_PROFILE, CPUFeature::Bit::AVX512, allowed);
  215|       |
  216|      0|                  if(is_set(feat, CPUFeature::Bit::AVX512)) {
  ------------------
  |  Branch (216:22): [True: 0, False: 0]
  ------------------
  217|      0|                     feat |= if_set(flags7, x86_CPUID_7_bits::AVX512_VAES, CPUFeature::Bit::AVX512_AES, allowed);
  218|      0|                     if(is_set(feat, CPUFeature::Bit::CLMUL)) {
  ------------------
  |  Branch (218:25): [True: 0, False: 0]
  ------------------
  219|      0|                        feat |= if_set(flags7, x86_CPUID_7_bits::AVX512_VCLMUL, CPUFeature::Bit::AVX512_CLMUL, allowed);
  220|      0|                     }
  221|      0|                  }
  222|      0|               }
  223|      1|            }
  224|      1|         }
  225|      1|      }
  226|      1|   }
  227|       |
  228|       |/*
  229|       |   * If we don't have access to CPUID, we can still safely assume that
  230|       |   * any x86-64 processor has SSE2 and RDTSC
  231|       |   */
  232|      1|#if defined(BOTAN_TARGET_ARCH_IS_X86_64)
  233|      1|   if(feat == 0) {
  ------------------
  |  Branch (233:7): [True: 0, False: 1]
  ------------------
  234|      0|      feat |= CPUFeature::Bit::SSE2 & allowed;
  235|      0|      feat |= CPUFeature::Bit::RDTSC & allowed;
  236|      0|   }
  237|      1|#endif
  238|       |
  239|      1|   return feat;
  240|      1|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_112invoke_cpuidEjPj:
   24|      2|void invoke_cpuid(uint32_t type, uint32_t out[4]) {
   25|      2|   clear_mem(out, 4);
   26|       |
   27|      2|#if defined(BOTAN_USE_GCC_INLINE_ASM)
   28|       |   // NOLINTNEXTLINE(*-no-assembler)
   29|      2|   asm volatile("cpuid\n\t" : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3]) : "0"(type));
   30|       |
   31|       |#elif defined(BOTAN_BUILD_COMPILER_IS_MSVC)
   32|       |   __cpuid((int*)out, type);
   33|       |
   34|       |#else
   35|       |   BOTAN_UNUSED(type);
   36|       |   #warning "No way of calling x86 cpuid instruction for this compiler"
   37|       |#endif
   38|      2|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_16xgetbvEv:
   56|      1|BOTAN_FUNC_ISA("xsave") uint64_t xgetbv() {
   57|       |   return _xgetbv(0);
   58|      1|}
cpuid_x86.cpp:_ZN5Botan12_GLOBAL__N_121invoke_cpuid_sublevelEjjPj:
   40|      2|void invoke_cpuid_sublevel(uint32_t type, uint32_t level, uint32_t out[4]) {
   41|      2|   clear_mem(out, 4);
   42|       |
   43|      2|#if defined(BOTAN_USE_GCC_INLINE_ASM)
   44|       |   // NOLINTNEXTLINE(*-no-assembler)
   45|      2|   asm volatile("cpuid\n\t" : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3]) : "0"(type), "2"(level));
   46|       |
   47|       |#elif defined(BOTAN_BUILD_COMPILER_IS_MSVC)
   48|       |   __cpuidex((int*)out, type, level);
   49|       |
   50|       |#else
   51|       |   BOTAN_UNUSED(type, level);
   52|       |   #warning "No way of calling x86 cpuid instruction for this compiler"
   53|       |#endif
   54|      2|}

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

_ZN5Botan7DNSName11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  134|  1.36k|std::optional<DNSName> DNSName::from_string(std::string_view name) {
  135|  1.36k|   if(auto canon = check_and_canonicalize_dns_name(name)) {
  ------------------
  |  Branch (135:12): [True: 1.22k, False: 137]
  ------------------
  136|       |      // TODO(C++23) std::string::contains
  137|  1.22k|      if(canon->find('*') != std::string::npos) {
  ------------------
  |  Branch (137:10): [True: 11, False: 1.21k]
  ------------------
  138|     11|         return {};
  139|     11|      }
  140|  1.21k|      return DNSName(std::move(*canon));
  141|  1.22k|   } else {
  142|    137|      return {};
  143|    137|   }
  144|  1.36k|}
_ZN5Botan7DNSName15from_san_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  147|    923|std::optional<DNSName> DNSName::from_san_string(std::string_view name) {
  148|    923|   if(auto canon = check_and_canonicalize_dns_name(name)) {
  ------------------
  |  Branch (148:12): [True: 889, False: 34]
  ------------------
  149|       |      /*
  150|       |      Validate the wildcard shape: at most one "*", and if present it must be in
  151|       |      the leftmost label (no "." before it). This matches the RFC 6125 6.4.3
  152|       |      form that host_wildcard_match accepts and rejects eg "*.*.example.com" or
  153|       |      "foo.*.example.com"
  154|       |      */
  155|    889|      const auto first_star = canon->find('*');
  156|    889|      if(first_star != std::string::npos) {
  ------------------
  |  Branch (156:10): [True: 56, False: 833]
  ------------------
  157|     56|         if(canon->find('*', first_star + 1) != std::string::npos) {
  ------------------
  |  Branch (157:13): [True: 12, False: 44]
  ------------------
  158|     12|            return std::nullopt;
  159|     12|         }
  160|     44|         const auto first_dot = canon->find('.');
  161|     44|         if(first_dot != std::string::npos && first_dot < first_star) {
  ------------------
  |  Branch (161:13): [True: 26, False: 18]
  |  Branch (161:47): [True: 4, False: 22]
  ------------------
  162|      4|            return std::nullopt;
  163|      4|         }
  164|       |         /*
  165|       |         RFC 6125 6.4.3: "the client SHOULD NOT attempt to match a presented
  166|       |         identifier where the wildcard character is embedded within an
  167|       |         A-label or U-label"
  168|       |         */
  169|     40|         if(canon->starts_with("xn--")) {
  ------------------
  |  Branch (169:13): [True: 3, False: 37]
  ------------------
  170|      3|            return std::nullopt;
  171|      3|         }
  172|       |         // A wildcard match requires at least three labels, so shorter
  173|       |         // patterns ("*", "*.com") could never match any host
  174|     37|         if(std::count(canon->begin(), canon->end(), '.') < 2) {
  ------------------
  |  Branch (174:13): [True: 20, False: 17]
  ------------------
  175|     20|            return std::nullopt;
  176|     20|         }
  177|     37|      }
  178|    850|      return DNSName(std::move(*canon));
  179|    889|   } else {
  180|     34|      return {};
  181|     34|   }
  182|    923|}
dns_name.cpp:_ZN5Botan12_GLOBAL__N_131check_and_canonicalize_dns_nameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   21|  2.28k|std::optional<std::string> check_and_canonicalize_dns_name(std::string_view name) {
   22|       |   /*
   23|       |   * RFC 1035 limits names to "255 octets or less", but that is in the wire
   24|       |   * encoding, which includes a length octet per label plus the root label.
   25|       |   * In presentation form (without a trailing dot) the limit is 253.
   26|       |   */
   27|  2.28k|   if(name.size() > 253) {
  ------------------
  |  Branch (27:7): [True: 0, False: 2.28k]
  ------------------
   28|      0|      return {};
   29|      0|   }
   30|       |
   31|       |   // DNS names are not empty
   32|  2.28k|   if(name.empty()) {
  ------------------
  |  Branch (32:7): [True: 0, False: 2.28k]
  ------------------
   33|      0|      return {};
   34|      0|   }
   35|       |
   36|       |   // DNS names do not start with or end with a dot
   37|  2.28k|   if(name.starts_with('.') || name.ends_with('.')) {
  ------------------
  |  Branch (37:7): [True: 9, False: 2.27k]
  |  Branch (37:32): [True: 3, False: 2.27k]
  ------------------
   38|     12|      return {};
   39|     12|   }
   40|       |
   41|       |   /*
   42|       |   * Table mapping uppercase to lowercase and only including values valid for
   43|       |   * DNS names: A-Z, a-z, 0-9, '-', '.', plus '*' for wildcarding (RFC 1035)
   44|       |   */
   45|       |   // clang-format off
   46|  2.27k|   constexpr uint8_t DNS_CHAR_MAPPING[128] = {
   47|  2.27k|      '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
   48|  2.27k|      '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
   49|  2.27k|      '\0', '\0', '\0', '\0',  '*', '\0', '\0',  '-',  '.', '\0',  '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',  '8',
   50|  2.27k|       '9', '\0', '\0', '\0', '\0', '\0', '\0', '\0',  'a',  'b',  'c',  'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',
   51|  2.27k|       'l',  'm',  'n',  'o',  'p',  'q',  'r',  's',  't',  'u',  'v',  'w',  'x',  'y',  'z', '\0', '\0', '\0', '\0',
   52|  2.27k|       '\0', '\0',  'a',  'b',  'c',  'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',  'p',  'q',
   53|  2.27k|       'r',  's',  't',  'u',  'v',  'w',  'x',  'y',  'z', '\0', '\0', '\0', '\0', '\0',
   54|  2.27k|   };
   55|       |   // clang-format on
   56|       |
   57|  2.27k|   std::string canon;
   58|  2.27k|   canon.reserve(name.size());
   59|       |
   60|       |   // RFC 1035: DNS labels must not exceed 63 characters
   61|  2.27k|   size_t current_label_length = 0;
   62|       |
   63|       |   // Tracks if the name consists only of digits and dots
   64|  2.27k|   bool all_numeric = true;
   65|       |
   66|  16.9k|   for(size_t i = 0; i != name.size(); ++i) {
  ------------------
  |  Branch (66:22): [True: 14.7k, False: 2.13k]
  ------------------
   67|  14.7k|      const char c = name[i];
   68|       |
   69|  14.7k|      if(c == '.') {
  ------------------
  |  Branch (69:10): [True: 417, False: 14.3k]
  ------------------
   70|       |         // Sequential dot (.) characters are not allowed
   71|    417|         if(i > 0 && name[i - 1] == '.') {
  ------------------
  |  Branch (71:13): [True: 417, False: 0]
  |  Branch (71:22): [True: 4, False: 413]
  ------------------
   72|      4|            return {};
   73|      4|         }
   74|       |
   75|       |         // Empty labels are not allowed
   76|    413|         if(current_label_length == 0) {
  ------------------
  |  Branch (76:13): [True: 0, False: 413]
  ------------------
   77|      0|            return {};
   78|      0|         }
   79|    413|         current_label_length = 0;  // Reset for next label
   80|  14.3k|      } else {
   81|  14.3k|         current_label_length++;
   82|       |
   83|       |         // Labels cannot exceed maximum DNS label length
   84|  14.3k|         if(current_label_length > 63) {
  ------------------
  |  Branch (84:13): [True: 4, False: 14.3k]
  ------------------
   85|      4|            return {};
   86|      4|         }
   87|  14.3k|      }
   88|       |
   89|  14.7k|      const uint8_t cu = static_cast<uint8_t>(c);
   90|       |      // DNS names are not allowed to include any high-bit set characters
   91|  14.7k|      if(cu >= 128) {
  ------------------
  |  Branch (91:10): [True: 41, False: 14.7k]
  ------------------
   92|     41|         return {};
   93|     41|      }
   94|  14.7k|      const uint8_t mapped = DNS_CHAR_MAPPING[cu];
   95|       |      // DNS names are from a restricted character set
   96|  14.7k|      if(mapped == 0) {
  ------------------
  |  Branch (96:10): [True: 78, False: 14.6k]
  ------------------
   97|     78|         return {};
   98|     78|      }
   99|       |
  100|  14.6k|      if(mapped != '.' && (mapped < '0' || mapped > '9')) {
  ------------------
  |  Branch (100:10): [True: 14.2k, False: 413]
  |  Branch (100:28): [True: 537, False: 13.6k]
  |  Branch (100:44): [True: 7.97k, False: 5.72k]
  ------------------
  101|  8.50k|         all_numeric = false;
  102|  8.50k|      }
  103|       |
  104|  14.6k|      if(mapped == '-') {
  ------------------
  |  Branch (104:10): [True: 447, False: 14.1k]
  ------------------
  105|       |         // DNS labels are not allowed to include a leading or trailing hyphen
  106|    447|         if(i == 0 || (i > 0 && name[i - 1] == '.')) {
  ------------------
  |  Branch (106:13): [True: 4, False: 443]
  |  Branch (106:24): [True: 443, False: 0]
  |  Branch (106:33): [True: 4, False: 439]
  ------------------
  107|      8|            return {};  // leading hyphen
  108|      8|         }
  109|       |
  110|    439|         if(i == name.size() - 1 || (i < name.size() - 1 && name[i + 1] == '.')) {
  ------------------
  |  Branch (110:13): [True: 5, False: 434]
  |  Branch (110:38): [True: 434, False: 0]
  |  Branch (110:61): [True: 3, False: 431]
  ------------------
  111|      8|            return {};  // trailing hyphen
  112|      8|         }
  113|    439|      }
  114|  14.6k|      canon.push_back(static_cast<char>(mapped));
  115|  14.6k|   }
  116|       |
  117|       |   // This should never be hit, due to earlier validation steps
  118|  2.13k|   if(current_label_length == 0) {
  ------------------
  |  Branch (118:7): [True: 0, False: 2.13k]
  ------------------
  119|      0|      return {};
  120|      0|   }
  121|       |
  122|       |   // An entirely numeric name ("1.2.3.4") is either a misplaced IP address
  123|       |   // or an attempt at confusing some other system; reject outright
  124|  2.13k|   if(all_numeric) {
  ------------------
  |  Branch (124:7): [True: 16, False: 2.11k]
  ------------------
  125|     16|      return {};
  126|     16|   }
  127|       |
  128|  2.11k|   return canon;
  129|  2.13k|}

_ZN5Botan12EmailAddress11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   78|    647|std::optional<EmailAddress> EmailAddress::from_string(std::string_view addr) {
   79|    647|   auto parsed = parse_email_address(addr);
   80|       |
   81|    647|   if(parsed) {
  ------------------
  |  Branch (81:7): [True: 494, False: 153]
  ------------------
   82|       |      // Verify the local-part is all ASCII
   83|  1.72k|      for(const char c : parsed->first) {
  ------------------
  |  Branch (83:24): [True: 1.72k, False: 488]
  ------------------
   84|  1.72k|         if(static_cast<uint8_t>(c) >= 0x80) {
  ------------------
  |  Branch (84:13): [True: 6, False: 1.71k]
  ------------------
   85|      6|            return {};
   86|      6|         }
   87|  1.72k|      }
   88|    488|      return EmailAddress(std::move(parsed->first), std::move(parsed->second));
   89|    494|   } else {
   90|    153|      return {};
   91|    153|   }
   92|    647|}
email.cpp:_ZN5Botan12_GLOBAL__N_119parse_email_addressENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   16|    647|std::optional<std::pair<std::string, DNSName>> parse_email_address(std::string_view addr) {
   17|       |   /*
   18|       |   * RFC 5322 atext: ALPHA / DIGIT plus "!#$%&'*+-/=?^_`{|}~" (plus ".")
   19|       |   *
   20|       |   * Anything outside this set in the local part requires quoting,
   21|       |   * which we deliberately don't accept.
   22|       |   */
   23|    647|   constexpr auto is_atext_or_dot = CharacterValidityTable::alpha_numeric_plus(".!#$%&'*+-/=?^_`{|}~");
   24|       |
   25|    647|   if(addr.empty() || !is_valid_utf8(addr)) {
  ------------------
  |  Branch (25:7): [True: 0, False: 647]
  |  Branch (25:23): [True: 56, False: 591]
  ------------------
   26|     56|      return {};
   27|     56|   }
   28|       |
   29|    591|   const auto at = addr.find('@');
   30|       |
   31|       |   // Must be one (and only one) @ sign
   32|    591|   if(at == std::string_view::npos || addr.find('@', at + 1) != std::string_view::npos) {
  ------------------
  |  Branch (32:7): [True: 10, False: 581]
  |  Branch (32:39): [True: 13, False: 568]
  ------------------
   33|     23|      return {};
   34|     23|   }
   35|       |
   36|       |   // Split at the @ sign and verify both halves are non-empty
   37|    568|   const std::string_view local = addr.substr(0, at);
   38|    568|   const std::string_view domain = addr.substr(at + 1);
   39|       |
   40|    568|   if(local.empty() || domain.empty()) {
  ------------------
  |  Branch (40:7): [True: 3, False: 565]
  |  Branch (40:24): [True: 5, False: 560]
  ------------------
   41|      8|      return {};
   42|      8|   }
   43|       |
   44|       |   // RFC 3696 section 3:
   45|       |   //
   46|       |   //  period (".") may also appear [in an email address local-part],
   47|       |   //  but may not be used to start or end the local part, nor may two
   48|       |   //  or more consecutive periods appear.
   49|       |
   50|       |   // TODO(C++23): use std::string::contains
   51|    560|   if(local.starts_with('.') || local.ends_with('.') || local.find("..") != std::string_view::npos) {
  ------------------
  |  Branch (51:7): [True: 3, False: 557]
  |  Branch (51:33): [True: 3, False: 554]
  |  Branch (51:57): [True: 8, False: 546]
  ------------------
   52|     14|      return {};
   53|     14|   }
   54|       |
   55|       |   // RFC 5322 dot-atom. This intentionally omits support for quoting
   56|  2.39k|   for(const char c : local) {
  ------------------
  |  Branch (56:21): [True: 2.39k, False: 526]
  ------------------
   57|       |      // Here we accept high bit for UTF-8 for SmtpUtf8Mailbox
   58|  2.39k|      if(!is_atext_or_dot(c) && static_cast<uint8_t>(c) < 0x80) {
  ------------------
  |  Branch (58:10): [True: 93, False: 2.29k]
  |  Branch (58:33): [True: 20, False: 73]
  ------------------
   59|     20|         return {};
   60|     20|      }
   61|  2.39k|   }
   62|       |
   63|    526|   auto parsed_domain = DNSName::from_string(domain);
   64|    526|   if(!parsed_domain.has_value()) {
  ------------------
  |  Branch (64:7): [True: 32, False: 494]
  ------------------
   65|     32|      return {};
   66|     32|   }
   67|       |
   68|    494|   return std::make_pair(std::string(local), parsed_domain.value());
   69|    526|}

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

_ZN5Botan11IPv4Address11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   92|    970|std::optional<IPv4Address> IPv4Address::from_string(std::string_view str) {
   93|    970|   if(auto ipv4 = string_to_ipv4(str)) {
  ------------------
  |  Branch (93:12): [True: 126, False: 844]
  ------------------
   94|    126|      return IPv4Address(*ipv4);
   95|    844|   } else {
   96|    844|      return {};
   97|    844|   }
   98|    970|}
ipv4_address.cpp:_ZN5Botan12_GLOBAL__N_114string_to_ipv4ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   21|    970|std::optional<uint32_t> string_to_ipv4(std::string_view str) {
   22|       |   // At least 3 dots + 4 1-digit integers
   23|       |   // At most 3 dots + 4 3-digit integers
   24|    970|   if(str.size() < 3 + 4 * 1 || str.size() > 3 + 4 * 3) {
  ------------------
  |  Branch (24:7): [True: 591, False: 379]
  |  Branch (24:33): [True: 79, False: 300]
  ------------------
   25|    670|      return {};
   26|    670|   }
   27|       |
   28|       |   // the final result
   29|    300|   uint32_t ip = 0;
   30|       |   // the number of '.' seen so far
   31|    300|   size_t dots = 0;
   32|       |   // accumulates one quad (range 0-255)
   33|    300|   uint32_t accum = 0;
   34|       |   // # of digits pushed to accum since last dot
   35|    300|   size_t cur_digits = 0;
   36|       |
   37|  1.88k|   for(const char c : str) {
  ------------------
  |  Branch (37:21): [True: 1.88k, False: 129]
  ------------------
   38|  1.88k|      if(c == '.') {
  ------------------
  |  Branch (38:10): [True: 547, False: 1.33k]
  ------------------
   39|       |         // . without preceding digit is invalid
   40|    547|         if(cur_digits == 0) {
  ------------------
  |  Branch (40:13): [True: 3, False: 544]
  ------------------
   41|      3|            return {};
   42|      3|         }
   43|    544|         dots += 1;
   44|       |         // too many dots
   45|    544|         if(dots > 3) {
  ------------------
  |  Branch (45:13): [True: 11, False: 533]
  ------------------
   46|     11|            return {};
   47|     11|         }
   48|       |
   49|    533|         cur_digits = 0;
   50|    533|         ip = (ip << 8) | accum;
   51|    533|         accum = 0;
   52|  1.33k|      } else if(c >= '0' && c <= '9') {
  ------------------
  |  Branch (52:17): [True: 1.31k, False: 25]
  |  Branch (52:29): [True: 1.22k, False: 88]
  ------------------
   53|  1.22k|         const auto d = static_cast<uint8_t>(c - '0');
   54|       |
   55|       |         // prohibit leading zero in quad (used for octal)
   56|  1.22k|         if(cur_digits > 0 && accum == 0) {
  ------------------
  |  Branch (56:13): [True: 453, False: 772]
  |  Branch (56:31): [True: 13, False: 440]
  ------------------
   57|     13|            return {};
   58|     13|         }
   59|  1.21k|         accum = (accum * 10) + d;
   60|       |
   61|  1.21k|         if(accum > 255) {
  ------------------
  |  Branch (61:13): [True: 31, False: 1.18k]
  ------------------
   62|     31|            return {};
   63|     31|         }
   64|       |
   65|  1.18k|         cur_digits++;
   66|  1.18k|         BOTAN_ASSERT_NOMSG(cur_digits <= 3);
  ------------------
  |  |   84|  1.18k|   do {                                                                     \
  |  |   85|  1.18k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  1.18k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 1.18k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  1.18k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 1.18k]
  |  |  ------------------
  ------------------
   67|  1.18k|      } else {
   68|    113|         return {};
   69|    113|      }
   70|  1.88k|   }
   71|       |
   72|       |   // no trailing digits?
   73|    129|   if(cur_digits == 0) {
  ------------------
  |  Branch (73:7): [True: 0, False: 129]
  ------------------
   74|      0|      return {};
   75|      0|   }
   76|       |
   77|       |   // insufficient # of dots
   78|    129|   if(dots != 3) {
  ------------------
  |  Branch (78:7): [True: 3, False: 126]
  ------------------
   79|      3|      return {};
   80|      3|   }
   81|       |
   82|    126|   ip = (ip << 8) | accum;
   83|       |
   84|    126|   return ip;
   85|    129|}

_ZN5Botan11IPv6AddressC2ENSt3__14spanIKhLm16EEE:
   17|    137|IPv6Address::IPv6Address(std::span<const uint8_t, 16> ip) : m_ip{} {
   18|  2.32k|   for(size_t i = 0; i != 16; ++i) {
  ------------------
  |  Branch (18:22): [True: 2.19k, False: 137]
  ------------------
   19|  2.19k|      m_ip[i] = ip[i];
   20|  2.19k|   }
   21|    137|}
_ZN5Botan11IPv6Address11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   24|    126|std::optional<IPv6Address> IPv6Address::from_string(std::string_view str) {
   25|    126|   if(str.empty()) {
  ------------------
  |  Branch (25:7): [True: 0, False: 126]
  ------------------
   26|      0|      return {};
   27|      0|   }
   28|       |
   29|       |   // Parsed hex groups, split by whether they appeared before or after a "::".
   30|       |   // If no "::" appears, only `pre` is populated and must reach exactly 8 groups.
   31|    126|   std::array<uint16_t, 8> pre{};
   32|    126|   std::array<uint16_t, 8> post{};
   33|    126|   size_t pre_count = 0;
   34|    126|   size_t post_count = 0;
   35|    126|   bool seen_double_colon = false;
   36|       |
   37|    126|   const auto hex_value = [](char c) -> std::optional<uint8_t> {
   38|    126|      if(c >= '0' && c <= '9') {
   39|    126|         return c - '0';
   40|    126|      } else if(c >= 'a' && c <= 'f') {
   41|    126|         return 10 + (c - 'a');
   42|    126|      } else if(c >= 'A' && c <= 'F') {
   43|    126|         return 10 + (c - 'A');
   44|    126|      } else {
   45|    126|         return {};
   46|    126|      }
   47|    126|   };
   48|       |
   49|    126|   size_t idx = 0;
   50|    126|   bool expect_group = true;  // set after any separator, cleared after a group
   51|       |
   52|  1.03k|   while(idx < str.size()) {
  ------------------
  |  Branch (52:10): [True: 1.00k, False: 37]
  ------------------
   53|  1.00k|      if(str[idx] == ':') {
  ------------------
  |  Branch (53:10): [True: 431, False: 569]
  ------------------
   54|    431|         if(idx + 1 < str.size() && str[idx + 1] == ':') {
  ------------------
  |  Branch (54:13): [True: 425, False: 6]
  |  Branch (54:37): [True: 61, False: 364]
  ------------------
   55|     61|            if(seen_double_colon) {
  ------------------
  |  Branch (55:16): [True: 5, False: 56]
  ------------------
   56|      5|               return {};  // at most one "::"
   57|      5|            }
   58|     56|            seen_double_colon = true;
   59|     56|            idx += 2;
   60|     56|            expect_group = (idx < str.size());
   61|     56|            continue;
   62|     61|         }
   63|       |         // single ':' separator between groups, only valid after a group
   64|    370|         if(expect_group) {
  ------------------
  |  Branch (64:13): [True: 3, False: 367]
  ------------------
   65|      3|            return {};
   66|      3|         }
   67|    367|         expect_group = true;
   68|    367|         idx += 1;
   69|    367|         continue;
   70|    370|      }
   71|       |
   72|       |      // Parse a hex group of 1..4 digits
   73|    569|      const size_t group_start = idx;
   74|    569|      uint32_t group = 0;
   75|    569|      size_t hex_chars = 0;
   76|  1.99k|      while(idx < str.size() && hex_chars < 4) {
  ------------------
  |  Branch (76:13): [True: 1.96k, False: 34]
  |  Branch (76:33): [True: 1.78k, False: 180]
  ------------------
   77|  1.78k|         const auto digit = hex_value(str[idx]);
   78|  1.78k|         if(digit.has_value() == false) {
  ------------------
  |  Branch (78:13): [True: 355, False: 1.43k]
  ------------------
   79|    355|            break;
   80|    355|         }
   81|  1.43k|         group = (group << 4) | static_cast<uint32_t>(digit.value());
   82|  1.43k|         idx += 1;
   83|  1.43k|         hex_chars += 1;
   84|  1.43k|      }
   85|    569|      if(hex_chars == 0) {
  ------------------
  |  Branch (85:10): [True: 46, False: 523]
  ------------------
   86|     46|         return {};
   87|     46|      }
   88|       |      // If a 5th hex digit follows, the group is oversized.
   89|    523|      if(hex_chars == 4 && idx < str.size() && hex_value(str[idx]).has_value()) {
  ------------------
  |  Branch (89:10): [True: 185, False: 338]
  |  Branch (89:10): [True: 20, False: 503]
  |  Branch (89:28): [True: 180, False: 5]
  |  Branch (89:48): [True: 20, False: 160]
  ------------------
   90|     20|         return {};
   91|     20|      }
   92|       |
   93|       |      /*
   94|       |      RFC 4291 2.2 allows the final 32 bits in dotted decimal, eg
   95|       |      "::ffff:1.2.3.4". The dotted quad must consume the remainder of the
   96|       |      input, and accounts for two 16-bit groups.
   97|       |      */
   98|    503|      if(idx < str.size() && str[idx] == '.') {
  ------------------
  |  Branch (98:10): [True: 469, False: 34]
  |  Branch (98:30): [True: 7, False: 462]
  ------------------
   99|      7|         const auto ipv4 = IPv4Address::from_string(str.substr(group_start));
  100|      7|         if(!ipv4.has_value()) {
  ------------------
  |  Branch (100:13): [True: 7, False: 0]
  ------------------
  101|      7|            return {};
  102|      7|         }
  103|      0|         const uint32_t v4 = ipv4->address();
  104|      0|         const std::array<uint16_t, 2> v4_groups{static_cast<uint16_t>(v4 >> 16), static_cast<uint16_t>(v4 & 0xFFFF)};
  105|      0|         for(const auto g : v4_groups) {
  ------------------
  |  Branch (105:27): [True: 0, False: 0]
  ------------------
  106|      0|            if(seen_double_colon) {
  ------------------
  |  Branch (106:16): [True: 0, False: 0]
  ------------------
  107|      0|               if(post_count >= 8) {
  ------------------
  |  Branch (107:19): [True: 0, False: 0]
  ------------------
  108|      0|                  return {};
  109|      0|               }
  110|      0|               post[post_count++] = g;
  111|      0|            } else {
  112|      0|               if(pre_count >= 8) {
  ------------------
  |  Branch (112:19): [True: 0, False: 0]
  ------------------
  113|      0|                  return {};
  114|      0|               }
  115|      0|               pre[pre_count++] = g;
  116|      0|            }
  117|      0|         }
  118|      0|         idx = str.size();
  119|      0|         expect_group = false;
  120|      0|         continue;
  121|      0|      }
  122|       |
  123|    496|      if(seen_double_colon) {
  ------------------
  |  Branch (123:10): [True: 176, False: 320]
  ------------------
  124|    176|         if(post_count >= 8) {
  ------------------
  |  Branch (124:13): [True: 4, False: 172]
  ------------------
  125|      4|            return {};
  126|      4|         }
  127|    172|         post[post_count++] = static_cast<uint16_t>(group);
  128|    320|      } else {
  129|    320|         if(pre_count >= 8) {
  ------------------
  |  Branch (129:13): [True: 4, False: 316]
  ------------------
  130|      4|            return {};
  131|      4|         }
  132|    316|         pre[pre_count++] = static_cast<uint16_t>(group);
  133|    316|      }
  134|    488|      expect_group = false;
  135|    488|   }
  136|       |
  137|       |   // Trailing single ':' is invalid
  138|     37|   if(expect_group) {
  ------------------
  |  Branch (138:7): [True: 4, False: 33]
  ------------------
  139|      4|      return {};
  140|      4|   }
  141|       |
  142|     33|   const size_t total_groups = pre_count + post_count;
  143|     33|   if(seen_double_colon) {
  ------------------
  |  Branch (143:7): [True: 25, False: 8]
  ------------------
  144|       |      // "::" has to cover at least one zero group
  145|     25|      if(total_groups > 7) {
  ------------------
  |  Branch (145:10): [True: 4, False: 21]
  ------------------
  146|      4|         return {};
  147|      4|      }
  148|     25|   } else {
  149|      8|      if(total_groups != 8) {
  ------------------
  |  Branch (149:10): [True: 3, False: 5]
  ------------------
  150|      3|         return {};
  151|      3|      }
  152|      8|   }
  153|       |
  154|     26|   std::array<uint8_t, 16> out{};
  155|    100|   for(size_t i = 0; i != pre_count; ++i) {
  ------------------
  |  Branch (155:22): [True: 74, False: 26]
  ------------------
  156|     74|      out[2 * i] = get_byte<0>(pre[i]);
  157|     74|      out[2 * i + 1] = get_byte<1>(pre[i]);
  158|     74|   }
  159|     26|   const size_t gap = 8 - total_groups;
  160|     81|   for(size_t i = 0; i != post_count; ++i) {
  ------------------
  |  Branch (160:22): [True: 55, False: 26]
  ------------------
  161|     55|      const size_t target = pre_count + gap + i;
  162|     55|      out[2 * target] = get_byte<0>(post[i]);
  163|     55|      out[2 * target + 1] = get_byte<1>(post[i]);
  164|     55|   }
  165|     26|   return IPv6Address(out);
  166|     33|}
ipv6_address.cpp:_ZZN5Botan11IPv6Address11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEENK3$_0clEc:
   37|  1.96k|   const auto hex_value = [](char c) -> std::optional<uint8_t> {
   38|  1.96k|      if(c >= '0' && c <= '9') {
  ------------------
  |  Branch (38:10): [True: 1.90k, False: 60]
  |  Branch (38:22): [True: 449, False: 1.45k]
  ------------------
   39|    449|         return c - '0';
   40|  1.51k|      } else if(c >= 'a' && c <= 'f') {
  ------------------
  |  Branch (40:17): [True: 581, False: 935]
  |  Branch (40:29): [True: 562, False: 19]
  ------------------
   41|    562|         return 10 + (c - 'a');
   42|    954|      } else if(c >= 'A' && c <= 'F') {
  ------------------
  |  Branch (42:17): [True: 475, False: 479]
  |  Branch (42:29): [True: 439, False: 36]
  ------------------
   43|    439|         return 10 + (c - 'A');
   44|    515|      } else {
   45|    515|         return {};
   46|    515|      }
   47|  1.96k|   };

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

_ZN5Botan2OS17read_env_variableERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
  471|      1|bool OS::read_env_variable(std::string& value_out, std::string_view name_view) {
  472|      1|   value_out = "";
  473|       |
  474|      1|   if(running_in_privileged_state()) {
  ------------------
  |  Branch (474:7): [True: 0, False: 1]
  ------------------
  475|      0|      return false;
  476|      0|   }
  477|       |
  478|       |#if defined(BOTAN_TARGET_OS_HAS_WIN32) && \
  479|       |   (defined(BOTAN_BUILD_COMPILER_IS_MSVC) || defined(BOTAN_BUILD_COMPILER_IS_CLANGCL))
  480|       |   const std::string name(name_view);
  481|       |
  482|       |   // First query the required buffer size; req_size is 0 if the variable is not set
  483|       |   size_t req_size = 0;
  484|       |   if(getenv_s(&req_size, nullptr, 0, name.c_str()) != 0 || req_size == 0) {
  485|       |      return false;
  486|       |   }
  487|       |
  488|       |   // The reported size includes the terminating \0
  489|       |   std::string val(req_size, '\0');
  490|       |   if(getenv_s(&req_size, val.data(), val.size(), name.c_str()) != 0) {
  491|       |      return false;
  492|       |   }
  493|       |
  494|       |   value_out = std::string(val.c_str());
  495|       |   return true;
  496|       |#else
  497|      1|   const std::string name(name_view);
  498|      1|   if(const char* val = std::getenv(name.c_str())) {
  ------------------
  |  Branch (498:19): [True: 0, False: 1]
  ------------------
  499|      0|      value_out = val;
  500|      0|      return true;
  501|      0|   }
  502|      1|#endif
  503|       |
  504|      1|   return false;
  505|      1|}
os_utils.cpp:_ZN5Botan12_GLOBAL__N_110get_auxvalENSt3__18optionalImEE:
  120|      1|std::optional<unsigned long> get_auxval(std::optional<unsigned long> id) {
  121|      1|   if(id) {
  ------------------
  |  Branch (121:7): [True: 1, False: 0]
  ------------------
  122|      1|#if defined(BOTAN_TARGET_OS_HAS_GETAUXVAL)
  123|      1|      return ::getauxval(*id);
  124|       |#elif defined(BOTAN_TARGET_OS_HAS_ELF_AUX_INFO)
  125|       |      unsigned long auxinfo = 0;
  126|       |      if(::elf_aux_info(static_cast<int>(*id), &auxinfo, sizeof(auxinfo)) == 0) {
  127|       |         return auxinfo;
  128|       |      }
  129|       |#endif
  130|      1|   }
  131|       |
  132|      0|   return {};
  133|      1|}
os_utils.cpp:_ZN5Botan12_GLOBAL__N_127running_in_privileged_stateEv:
  154|      1|bool running_in_privileged_state() {
  155|      1|#if defined(AT_SECURE)
  156|      1|   if(const auto at_secure = get_auxval(AT_SECURE)) {
  ------------------
  |  Branch (156:18): [True: 1, False: 0]
  ------------------
  157|      1|      return at_secure != 0;
  158|      1|   }
  159|      0|#endif
  160|       |
  161|      0|#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
  162|      0|   return (::getuid() != ::geteuid()) || (::getgid() != ::getegid());
  ------------------
  |  Branch (162:11): [True: 0, False: 0]
  |  Branch (162:42): [True: 0, False: 0]
  ------------------
  163|       |#else
  164|       |   return false;
  165|       |#endif
  166|      1|}

_ZN5Botan9parse_u16ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEb:
   59|    163|std::optional<uint16_t> parse_u16(std::string_view input, bool require_canonical) {
   60|    163|   return parse_decimal_integer<uint16_t>(input, require_canonical);
   61|    163|}
_ZN5Botan9parse_u32ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEb:
   63|  70.9k|std::optional<uint32_t> parse_u32(std::string_view input, bool require_canonical) {
   64|  70.9k|   return parse_decimal_integer<uint32_t>(input, require_canonical);
   65|  70.9k|}
_ZN5Botan9to_u32bitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   75|  70.9k|uint32_t to_u32bit(std::string_view input) {
   76|  70.9k|   if(const auto parsed = parse_u32(input)) {
  ------------------
  |  Branch (76:18): [True: 70.9k, False: 26]
  ------------------
   77|  70.9k|      return *parsed;
   78|  70.9k|   } else {
   79|     26|      throw Invalid_Argument(fmt("Failed to parse input '{}' as a 32-bit integer", input));
   80|     26|   }
   81|  70.9k|}
_ZN5Botan14tolower_stringENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  125|  2.21k|std::string tolower_string(std::string_view str) {
  126|       |   // Locale-independent ASCII fold; the only callers (DNS name canonicalization
  127|       |   // for SAN/name-constraints) work on ASCII strings per RFC 1035.
  128|  2.21k|   std::string lower(str);
  129|  6.11k|   for(char& c : lower) {
  ------------------
  |  Branch (129:16): [True: 6.11k, False: 2.21k]
  ------------------
  130|  6.11k|      if(c >= 'A' && c <= 'Z') {
  ------------------
  |  Branch (130:10): [True: 5.67k, False: 449]
  |  Branch (130:22): [True: 4.78k, False: 883]
  ------------------
  131|  4.78k|         c = static_cast<char>(c + ('a' - 'A'));
  132|  4.78k|      }
  133|  6.11k|   }
  134|  2.21k|   return lower;
  135|  2.21k|}
parsing.cpp:_ZN5Botan12_GLOBAL__N_121parse_decimal_integerITkNSt3__117unsigned_integralEtEENS2_8optionalIT_EENS2_17basic_string_viewIcNS2_11char_traitsIcEEEEb:
   31|    163|std::optional<T> parse_decimal_integer(std::string_view input, bool require_canonical) {
   32|    163|   if(input.empty() || input.size() > (std::numeric_limits<T>::digits10 + 1)) {
  ------------------
  |  Branch (32:7): [True: 0, False: 163]
  |  Branch (32:24): [True: 7, False: 156]
  ------------------
   33|      7|      return {};
   34|      7|   }
   35|       |
   36|       |   // The canonical encoding of zero is "0"; no other value starts with a zero
   37|    156|   if(require_canonical && input.size() > 1 && input.front() == '0') {
  ------------------
  |  Branch (37:7): [True: 156, False: 0]
  |  Branch (37:28): [True: 70, False: 86]
  |  Branch (37:48): [True: 4, False: 66]
  ------------------
   38|      4|      return {};
   39|      4|   }
   40|       |
   41|    152|   T accum = 0;
   42|       |
   43|    285|   for(const char c : input) {
  ------------------
  |  Branch (43:21): [True: 285, False: 123]
  ------------------
   44|    285|      if(const auto digit = digit_from_ascii(c)) {
  ------------------
  |  Branch (44:21): [True: 259, False: 26]
  ------------------
   45|    259|         if(accum > (std::numeric_limits<T>::max() - static_cast<T>(*digit)) / 10) {
  ------------------
  |  Branch (45:13): [True: 3, False: 256]
  ------------------
   46|      3|            return {};
   47|      3|         }
   48|    256|         accum = accum * 10 + static_cast<T>(*digit);
   49|    256|      } else {
   50|     26|         return {};
   51|     26|      }
   52|    285|   }
   53|       |
   54|    123|   return accum;
   55|    152|}
parsing.cpp:_ZN5Botan12_GLOBAL__N_116digit_from_asciiEc:
   22|   143k|std::optional<size_t> digit_from_ascii(char c) {
   23|   143k|   if(c >= '0' && c <= '9') {
  ------------------
  |  Branch (23:7): [True: 143k, False: 35]
  |  Branch (23:19): [True: 143k, False: 17]
  ------------------
   24|   143k|      return c - '0';
   25|   143k|   } else {
   26|     52|      return {};
   27|     52|   }
   28|   143k|}
parsing.cpp:_ZN5Botan12_GLOBAL__N_121parse_decimal_integerITkNSt3__117unsigned_integralEjEENS2_8optionalIT_EENS2_17basic_string_viewIcNS2_11char_traitsIcEEEEb:
   31|  70.9k|std::optional<T> parse_decimal_integer(std::string_view input, bool require_canonical) {
   32|  70.9k|   if(input.empty() || input.size() > (std::numeric_limits<T>::digits10 + 1)) {
  ------------------
  |  Branch (32:7): [True: 0, False: 70.9k]
  |  Branch (32:24): [True: 0, False: 70.9k]
  ------------------
   33|      0|      return {};
   34|      0|   }
   35|       |
   36|       |   // The canonical encoding of zero is "0"; no other value starts with a zero
   37|  70.9k|   if(require_canonical && input.size() > 1 && input.front() == '0') {
  ------------------
  |  Branch (37:7): [True: 0, False: 70.9k]
  |  Branch (37:28): [True: 0, False: 0]
  |  Branch (37:48): [True: 0, False: 0]
  ------------------
   38|      0|      return {};
   39|      0|   }
   40|       |
   41|  70.9k|   T accum = 0;
   42|       |
   43|   143k|   for(const char c : input) {
  ------------------
  |  Branch (43:21): [True: 143k, False: 70.9k]
  ------------------
   44|   143k|      if(const auto digit = digit_from_ascii(c)) {
  ------------------
  |  Branch (44:21): [True: 143k, False: 26]
  ------------------
   45|   143k|         if(accum > (std::numeric_limits<T>::max() - static_cast<T>(*digit)) / 10) {
  ------------------
  |  Branch (45:13): [True: 0, False: 143k]
  ------------------
   46|      0|            return {};
   47|      0|         }
   48|   143k|         accum = accum * 10 + static_cast<T>(*digit);
   49|   143k|      } else {
   50|     26|         return {};
   51|     26|      }
   52|   143k|   }
   53|       |
   54|  70.9k|   return accum;
   55|  70.9k|}

_ZNK5Botan3URIssERKS0_:
  114|  2.61k|std::strong_ordering URI::operator<=>(const URI& other) const {
  115|  2.61k|   const bool has_authority = raw_authority().has_value();
  116|  2.61k|   const bool other_has_authority = other.raw_authority().has_value();
  117|       |
  118|  2.61k|   return std::tie(m_scheme, has_authority, m_authority, m_path, m_query, m_fragment) <=>
  119|  2.61k|          std::tie(
  120|  2.61k|             other.m_scheme, other_has_authority, other.m_authority, other.m_path, other.m_query, other.m_fragment);
  121|  2.61k|}
_ZNK5Botan3URI13raw_authorityEv:
  129|  5.22k|std::optional<std::string_view> URI::raw_authority() const {
  130|  5.22k|   const auto colon = m_raw.find(':');
  131|  5.22k|   BOTAN_ASSERT_NOMSG(colon != std::string::npos);
  ------------------
  |  |   84|  5.22k|   do {                                                                     \
  |  |   85|  5.22k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|  5.22k|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 5.22k]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|  5.22k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 5.22k]
  |  |  ------------------
  ------------------
  132|       |
  133|  5.22k|   const size_t rest_offset = colon + 1;
  134|  5.22k|   if(m_raw.size() < rest_offset + 2 || m_raw[rest_offset] != '/' || m_raw[rest_offset + 1] != '/') {
  ------------------
  |  Branch (134:7): [True: 436, False: 4.79k]
  |  Branch (134:41): [True: 1.60k, False: 3.18k]
  |  Branch (134:70): [True: 775, False: 2.40k]
  ------------------
  135|  2.81k|      return std::nullopt;
  136|  2.81k|   }
  137|       |
  138|  2.40k|   const size_t authority_start = rest_offset + 2;
  139|  2.40k|   const auto authority_end = m_raw.find_first_of("/?#", authority_start);
  140|  2.40k|   const size_t authority_len =
  141|  2.40k|      (authority_end == std::string::npos) ? std::string::npos : authority_end - authority_start;
  ------------------
  |  Branch (141:7): [True: 880, False: 1.52k]
  ------------------
  142|  2.40k|   return std::string_view(m_raw).substr(authority_start, authority_len);
  143|  5.22k|}
_ZNK5Botan3URI9AuthorityssERKS1_:
  145|    907|std::strong_ordering URI::Authority::operator<=>(const URI::Authority& other) const {
  146|       |   /*
  147|       |   Userinfo is compared without normalization; RFC 3986 6.2.2.1:
  148|       |      When a URI uses components of the generic syntax, the component
  149|       |      syntax equivalence rules always apply; namely, that the scheme
  150|       |      and host are case-insensitive and therefore should be normalized
  151|       |      to lowercase. ... The other generic syntax components are assumed
  152|       |      to be case-sensitive unless specifically defined otherwise by the
  153|       |      scheme.
  154|       |   */
  155|    907|   return std::tie(m_userinfo, m_host, m_port) <=> std::tie(other.m_userinfo, other.m_host, other.m_port);
  156|    907|}
_ZN5Botan3URI11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  163|  2.30k|std::optional<URI> URI::from_string(std::string_view raw) {
  164|       |   // Empty string is not a valid URI
  165|  2.30k|   if(raw.empty()) {
  ------------------
  |  Branch (165:7): [True: 0, False: 2.30k]
  ------------------
  166|      0|      return {};
  167|      0|   }
  168|       |
  169|       |   // RFC 3986:
  170|       |   // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
  171|  2.30k|   constexpr auto is_scheme_cont_char = CharacterValidityTable::alpha_numeric_plus("+-.");
  172|       |
  173|  2.30k|   const auto is_ascii_alpha = [](char c) -> bool { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); };
  174|       |
  175|       |   // Check the first scheme character
  176|  2.30k|   if(!is_ascii_alpha(raw.front())) {
  ------------------
  |  Branch (176:7): [True: 37, False: 2.26k]
  ------------------
  177|     37|      return {};
  178|     37|   }
  179|       |
  180|       |   // Scan the rest of the scheme
  181|  2.26k|   size_t i = 1;
  182|  6.37k|   while(i < raw.size() && is_scheme_cont_char(raw[i])) {
  ------------------
  |  Branch (182:10): [True: 6.36k, False: 4]
  |  Branch (182:28): [True: 4.10k, False: 2.26k]
  ------------------
  183|  4.10k|      ++i;
  184|  4.10k|   }
  185|       |   // Scheme wasn't followed by ':' -> invalid
  186|  2.26k|   if(i >= raw.size() || raw[i] != ':') {
  ------------------
  |  Branch (186:7): [True: 4, False: 2.26k]
  |  Branch (186:26): [True: 50, False: 2.21k]
  ------------------
  187|     54|      return {};
  188|     54|   }
  189|       |
  190|       |   // Canonicalize the scheme
  191|  2.21k|   const std::string scheme = tolower_string(raw.substr(0, i));
  192|       |
  193|  2.21k|   auto rest = raw.substr(i + 1);
  194|       |
  195|  2.21k|   std::optional<Authority> parsed_authority;
  196|  2.21k|   std::string_view path_query_fragment;
  197|       |
  198|  2.21k|   if(rest.starts_with("//")) {
  ------------------
  |  Branch (198:7): [True: 1.27k, False: 931]
  ------------------
  199|  1.27k|      rest.remove_prefix(2);  // Strip off the '//'
  200|       |
  201|       |      // Authority runs to the first '/', '?' or '#'. The remaining is `path ? query # fragment`,
  202|       |      // which is validated against the RFC 3986 character set.
  203|  1.27k|      const auto end = rest.find_first_of("/?#");
  204|  1.27k|      const auto authority = (end == std::string_view::npos) ? rest : rest.substr(0, end);
  ------------------
  |  Branch (204:30): [True: 416, False: 863]
  ------------------
  205|  1.27k|      path_query_fragment = (end == std::string_view::npos) ? std::string_view{} : rest.substr(end);
  ------------------
  |  Branch (205:29): [True: 416, False: 863]
  ------------------
  206|       |
  207|       |      // Parse and validate non-empty authority strings (hostname, IPv4, or IPv6 address)
  208|  1.27k|      if(!authority.empty()) {
  ------------------
  |  Branch (208:10): [True: 1.22k, False: 57]
  ------------------
  209|  1.22k|         parsed_authority = Authority::from_string(authority);
  210|  1.22k|         if(!parsed_authority.has_value()) {
  ------------------
  |  Branch (210:13): [True: 393, False: 829]
  ------------------
  211|    393|            return {};
  212|    393|         }
  213|  1.22k|      }
  214|  1.27k|   } else {
  215|    931|      path_query_fragment = rest;
  216|    931|   }
  217|       |
  218|       |   // Validate any `path ? query # fragment` portions of the URL
  219|  1.81k|   if(!validate_path_query_fragment(path_query_fragment)) {
  ------------------
  |  Branch (219:7): [True: 180, False: 1.63k]
  ------------------
  220|    180|      return {};
  221|    180|   }
  222|       |
  223|       |   // Split into path / query / fragment. Validation above guarantees at most
  224|       |   // one '#', so the first '#' is the fragment delimiter, and within the
  225|       |   // pre-fragment portion the first '?' (if any) is the query delimiter.
  226|  1.63k|   const auto hash = path_query_fragment.find('#');
  227|  1.63k|   const auto pre_fragment =
  228|  1.63k|      (hash == std::string_view::npos) ? path_query_fragment : path_query_fragment.substr(0, hash);
  ------------------
  |  Branch (228:7): [True: 1.08k, False: 555]
  ------------------
  229|  1.63k|   std::optional<std::string> fragment;
  230|  1.63k|   if(hash != std::string_view::npos) {
  ------------------
  |  Branch (230:7): [True: 555, False: 1.08k]
  ------------------
  231|    555|      fragment = std::string(path_query_fragment.substr(hash + 1));
  232|    555|   }
  233|       |
  234|  1.63k|   const auto qmark = pre_fragment.find('?');
  235|  1.63k|   const auto path = (qmark == std::string_view::npos) ? pre_fragment : pre_fragment.substr(0, qmark);
  ------------------
  |  Branch (235:22): [True: 1.16k, False: 470]
  ------------------
  236|  1.63k|   std::optional<std::string> query;
  237|  1.63k|   if(qmark != std::string_view::npos) {
  ------------------
  |  Branch (237:7): [True: 470, False: 1.16k]
  ------------------
  238|    470|      query = std::string(pre_fragment.substr(qmark + 1));
  239|    470|   }
  240|       |
  241|       |   // Accept
  242|  1.63k|   return URI(
  243|  1.63k|      std::string(raw), scheme, std::move(parsed_authority), std::string(path), std::move(query), std::move(fragment));
  244|  1.81k|}
_ZN5Botan3URI9Authority11from_stringENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  247|  1.22k|std::optional<URI::Authority> URI::Authority::from_string(std::string_view raw) {
  248|  1.22k|   if(raw.empty()) {
  ------------------
  |  Branch (248:7): [True: 0, False: 1.22k]
  ------------------
  249|      0|      return {};
  250|      0|   }
  251|       |
  252|       |   // Capture the full input now; the userinfo prefix is stripped from
  253|       |   // `raw` below, and m_raw must reflect the original
  254|  1.22k|   const std::string original_input(raw);
  255|       |
  256|       |   /*
  257|       |   RFC 3986
  258|       |     userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
  259|       |
  260|       |   Thus a unencoded '@' is not allowed inside userinfo, and the single '@' splits the
  261|       |   username from the authority. The @ being present at all is significant; an empty
  262|       |   userinfo ("https://@example.com/") is distinct from no userinfo at all.
  263|       |   */
  264|  1.22k|   std::optional<std::string> userinfo;
  265|  1.22k|   const auto first_at = raw.find('@');
  266|  1.22k|   if(first_at != std::string_view::npos) {
  ------------------
  |  Branch (266:7): [True: 685, False: 537]
  ------------------
  267|    685|      if(raw.find('@', first_at + 1) != std::string_view::npos) {
  ------------------
  |  Branch (267:10): [True: 12, False: 673]
  ------------------
  268|     12|         return {};
  269|     12|      }
  270|    673|      const auto userinfo_view = raw.substr(0, first_at);
  271|    673|      if(!validate_userinfo(userinfo_view)) {
  ------------------
  |  Branch (271:10): [True: 87, False: 586]
  ------------------
  272|     87|         return {};
  273|     87|      }
  274|    586|      userinfo = std::string(userinfo_view);
  275|    586|      raw.remove_prefix(first_at + 1);
  276|    586|   }
  277|       |
  278|  1.12k|   std::string_view host_view;
  279|  1.12k|   std::string_view port_str;
  280|  1.12k|   std::optional<Host> host;
  281|       |
  282|  1.12k|   if(!raw.empty() && raw.front() == '[') {
  ------------------
  |  Branch (282:7): [True: 1.11k, False: 5]
  |  Branch (282:23): [True: 141, False: 977]
  ------------------
  283|       |      // Bracketed IPv6 literal.
  284|    141|      const auto close = raw.find(']');
  285|    141|      if(close == std::string_view::npos) {
  ------------------
  |  Branch (285:10): [True: 6, False: 135]
  ------------------
  286|      6|         return {};
  287|      6|      }
  288|    135|      host_view = raw.substr(1, close - 1);
  289|    135|      if(host_view.empty()) {
  ------------------
  |  Branch (289:10): [True: 3, False: 132]
  ------------------
  290|      3|         return {};
  291|      3|      }
  292|    132|      const auto after = raw.substr(close + 1);
  293|    132|      if(!after.empty()) {
  ------------------
  |  Branch (293:10): [True: 22, False: 110]
  ------------------
  294|     22|         if(after.front() != ':') {
  ------------------
  |  Branch (294:13): [True: 6, False: 16]
  ------------------
  295|      6|            return {};
  296|      6|         }
  297|     16|         port_str = after.substr(1);
  298|     16|      }
  299|    126|      auto ipv6 = IPv6Address::from_string(host_view);
  300|    126|      if(!ipv6.has_value()) {
  ------------------
  |  Branch (300:10): [True: 100, False: 26]
  ------------------
  301|    100|         return {};
  302|    100|      }
  303|     26|      host = *ipv6;
  304|    982|   } else {
  305|       |      // host[:port] with no brackets. Only one ':' is allowed (port).
  306|    982|      const auto colon = raw.find(':');
  307|    982|      if(colon == std::string_view::npos) {
  ------------------
  |  Branch (307:10): [True: 770, False: 212]
  ------------------
  308|    770|         host_view = raw;
  309|    770|      } else {
  310|    212|         host_view = raw.substr(0, colon);
  311|    212|         port_str = raw.substr(colon + 1);
  312|       |
  313|       |         // Verify the `:` char is the only one that appears
  314|    212|         if(port_str.find(':') != std::string::npos) {
  ------------------
  |  Branch (314:13): [True: 10, False: 202]
  ------------------
  315|     10|            return {};
  316|     10|         }
  317|    212|      }
  318|       |
  319|    972|      if(host_view.empty()) {
  ------------------
  |  Branch (319:10): [True: 6, False: 966]
  ------------------
  320|      6|         return {};
  321|      6|      }
  322|       |
  323|       |      // Technically valid per RFC 3986 but likely not something we want to support
  324|    966|      if(host_view.ends_with('.')) {
  ------------------
  |  Branch (324:10): [True: 3, False: 963]
  ------------------
  325|      3|         return {};
  326|      3|      }
  327|       |
  328|    963|      if(auto ipv4 = IPv4Address::from_string(host_view)) {
  ------------------
  |  Branch (328:15): [True: 126, False: 837]
  ------------------
  329|    126|         host = *ipv4;
  330|    837|      } else if(auto dns = DNSName::from_string(host_view)) {
  ------------------
  |  Branch (330:22): [True: 721, False: 116]
  ------------------
  331|    721|         host = std::move(*dns);
  332|    721|      } else {
  333|    116|         return {};
  334|    116|      }
  335|    963|   }
  336|       |
  337|    873|   std::optional<uint16_t> port;
  338|       |
  339|    873|   if(!port_str.empty()) {
  ------------------
  |  Branch (339:7): [True: 163, False: 710]
  ------------------
  340|    163|      port = parse_port(port_str);
  341|    163|      if(!port.has_value()) {
  ------------------
  |  Branch (341:10): [True: 44, False: 119]
  ------------------
  342|     44|         return {};
  343|     44|      }
  344|    163|   }
  345|       |
  346|    829|   return Authority(original_input, std::move(userinfo), std::move(*host), port);
  347|    873|}
uri.cpp:_ZZN5Botan3URI11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEENK3$_0clEc:
  173|  2.30k|   const auto is_ascii_alpha = [](char c) -> bool { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); };
  ------------------
  |  Branch (173:61): [True: 169, False: 2.13k]
  |  Branch (173:73): [True: 166, False: 3]
  |  Branch (173:87): [True: 2.10k, False: 34]
  |  Branch (173:99): [True: 2.09k, False: 3]
  ------------------
uri.cpp:_ZN5Botan12_GLOBAL__N_128validate_path_query_fragmentENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   45|  1.81k|bool validate_path_query_fragment(std::string_view tail) {
   46|       |   /*
   47|       |   * RFC 3986 syntax for the path/query/fragment of a URI:
   48|       |   *
   49|       |   *   URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
   50|       |   *   pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
   51|       |   *   segment       = *pchar
   52|       |   *   path-abempty  = *( "/" segment )
   53|       |   *   query         = *( pchar / "/" / "?" )
   54|       |   *   fragment     =  *( pchar / "/" / "?" )
   55|       |   */
   56|       |
   57|  1.81k|   constexpr auto is_pchar_or_slash = CharacterValidityTable::alpha_numeric_plus("-._~!$&'()*+,;=:@/");
   58|       |
   59|  1.81k|   enum class State : uint8_t { Path, Query, Fragment };
   60|  1.81k|   State state = State::Path;
   61|       |
   62|  22.4k|   for(size_t i = 0; i < tail.size(); ++i) {
  ------------------
  |  Branch (62:22): [True: 20.8k, False: 1.63k]
  ------------------
   63|  20.8k|      const char c = tail[i];
   64|  20.8k|      if(c == '%') {
  ------------------
  |  Branch (64:10): [True: 565, False: 20.2k]
  ------------------
   65|    565|         if(i + 2 >= tail.size() || !is_valid_percent_escape(tail[i + 1], tail[i + 2])) {
  ------------------
  |  Branch (65:13): [True: 10, False: 555]
  |  Branch (65:37): [True: 58, False: 497]
  ------------------
   66|     68|            return false;
   67|     68|         }
   68|    497|         i += 2;
   69|    497|         continue;
   70|    565|      }
   71|  20.2k|      if(c == '?') {
  ------------------
  |  Branch (71:10): [True: 955, False: 19.2k]
  ------------------
   72|       |         // First '?' transitions from path to query, any further '?' are literal
   73|    955|         if(state == State::Path) {
  ------------------
  |  Branch (73:13): [True: 497, False: 458]
  ------------------
   74|    497|            state = State::Query;
   75|    497|         }
   76|    955|         continue;
   77|    955|      }
   78|  19.2k|      if(c == '#') {
  ------------------
  |  Branch (78:10): [True: 601, False: 18.6k]
  ------------------
   79|       |         // There is only one '#' fragment delimiter, second '#' is invalid
   80|    601|         if(state == State::Fragment) {
  ------------------
  |  Branch (80:13): [True: 6, False: 595]
  ------------------
   81|      6|            return false;
   82|      6|         }
   83|    595|         state = State::Fragment;
   84|    595|         continue;
   85|    601|      }
   86|  18.6k|      if(!is_pchar_or_slash(c)) {
  ------------------
  |  Branch (86:10): [True: 106, False: 18.5k]
  ------------------
   87|    106|         return false;
   88|    106|      }
   89|  18.6k|   }
   90|  1.63k|   return true;
   91|  1.81k|}
uri.cpp:_ZN5Botan12_GLOBAL__N_123is_valid_percent_escapeEcc:
   28|  1.17k|bool is_valid_percent_escape(char c1, char c2) {
   29|  1.17k|   const auto is_hex_digit = [](char c) {
   30|  1.17k|      return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
   31|  1.17k|   };
   32|       |
   33|  1.17k|   if(!is_hex_digit(c1) || !is_hex_digit(c2)) {
  ------------------
  |  Branch (33:7): [True: 63, False: 1.10k]
  |  Branch (33:28): [True: 55, False: 1.05k]
  ------------------
   34|    118|      return false;
   35|    118|   }
   36|       |
   37|       |   // Proactively reject embedded null (%00)
   38|  1.05k|   if(c1 == '0' && c2 == '0') {
  ------------------
  |  Branch (38:7): [True: 137, False: 916]
  |  Branch (38:20): [True: 6, False: 131]
  ------------------
   39|      6|      return false;
   40|      6|   }
   41|       |
   42|  1.04k|   return true;
   43|  1.05k|}
uri.cpp:_ZZN5Botan12_GLOBAL__N_123is_valid_percent_escapeEccENK3$_0clEc:
   29|  2.27k|   const auto is_hex_digit = [](char c) {
   30|  2.27k|      return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
  ------------------
  |  Branch (30:15): [True: 2.21k, False: 61]
  |  Branch (30:27): [True: 511, False: 1.70k]
  |  Branch (30:41): [True: 698, False: 1.07k]
  |  Branch (30:53): [True: 672, False: 26]
  |  Branch (30:67): [True: 1.02k, False: 73]
  |  Branch (30:79): [True: 978, False: 45]
  ------------------
   31|  2.27k|   };
uri.cpp:_ZN5Botan12_GLOBAL__N_117validate_userinfoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   93|    673|bool validate_userinfo(std::string_view userinfo) {
   94|    673|   constexpr auto is_valid_userinfo_char = CharacterValidityTable::alpha_numeric_plus("-._~!$&'()*+,;=:");
   95|       |
   96|  5.22k|   for(size_t i = 0; i < userinfo.size(); ++i) {
  ------------------
  |  Branch (96:22): [True: 4.63k, False: 586]
  ------------------
   97|  4.63k|      const char c = userinfo[i];
   98|  4.63k|      if(c == '%') {
  ------------------
  |  Branch (98:10): [True: 620, False: 4.01k]
  ------------------
   99|    620|         if(i + 2 >= userinfo.size() || !is_valid_percent_escape(userinfo[i + 1], userinfo[i + 2])) {
  ------------------
  |  Branch (99:13): [True: 4, False: 616]
  |  Branch (99:41): [True: 66, False: 550]
  ------------------
  100|     70|            return false;
  101|     70|         }
  102|    550|         i += 2;
  103|    550|         continue;
  104|    620|      }
  105|  4.01k|      if(!is_valid_userinfo_char(c)) {
  ------------------
  |  Branch (105:10): [True: 17, False: 4.00k]
  ------------------
  106|     17|         return false;
  107|     17|      }
  108|  4.01k|   }
  109|    586|   return true;
  110|    673|}
uri.cpp:_ZN5Botan12_GLOBAL__N_110parse_portENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   17|    163|std::optional<uint16_t> parse_port(std::string_view s) {
   18|       |   // RFC 3986 port is "*DIGIT" but we reject leading zeros ("host:0080")
   19|    163|   if(const auto port = parse_u16(s, /*require_canonical=*/true)) {
  ------------------
  |  Branch (19:18): [True: 123, False: 40]
  ------------------
   20|    123|      if(*port > 0) {
  ------------------
  |  Branch (20:10): [True: 119, False: 4]
  ------------------
   21|    119|         return port;
   22|    119|      }
   23|    123|   }
   24|       |
   25|     44|   return {};
   26|    163|}

_ZN5Botan15AlternativeName7add_uriENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   17|  2.46k|void AlternativeName::add_uri(std::string_view uri) {
   18|  2.46k|   if(uri.empty()) {
  ------------------
  |  Branch (18:7): [True: 210, False: 2.25k]
  ------------------
   19|    210|      return;
   20|    210|   }
   21|  2.25k|   if(auto parsed = URI::from_string(uri)) {
  ------------------
  |  Branch (21:12): [True: 1.59k, False: 664]
  ------------------
   22|  1.59k|      add_uri(std::move(*parsed));
   23|  1.59k|   } else {
   24|    664|      throw Decoding_Error("Invalid URI in SubjectAlternativeName");
   25|    664|   }
   26|  2.25k|}
_ZN5Botan15AlternativeName7add_uriENS_3URIE:
   28|  1.59k|void AlternativeName::add_uri(URI uri) {
   29|  1.59k|   m_uri.insert(std::move(uri));
   30|  1.59k|}
_ZN5Botan15AlternativeName9add_emailENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   40|    672|void AlternativeName::add_email(std::string_view addr) {
   41|    672|   if(addr.empty()) {
  ------------------
  |  Branch (41:7): [True: 25, False: 647]
  ------------------
   42|     25|      return;
   43|     25|   }
   44|    647|   if(auto parsed = EmailAddress::from_string(addr)) {
  ------------------
  |  Branch (44:12): [True: 488, False: 159]
  ------------------
   45|    488|      add_email(std::move(*parsed));
   46|    488|   } else {
   47|    159|      throw Decoding_Error("Invalid email address in SubjectAlternativeName");
   48|    159|   }
   49|    647|}
_ZN5Botan15AlternativeName9add_emailENS_12EmailAddressE:
   51|    488|void AlternativeName::add_email(EmailAddress addr) {
   52|    488|   m_email.insert(std::move(addr));
   53|    488|}
_ZN5Botan15AlternativeName7add_dnsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   63|    959|void AlternativeName::add_dns(std::string_view dns) {
   64|    959|   if(dns.empty()) {
  ------------------
  |  Branch (64:7): [True: 36, False: 923]
  ------------------
   65|     36|      return;
   66|     36|   }
   67|    923|   if(auto parsed = DNSName::from_san_string(dns)) {
  ------------------
  |  Branch (67:12): [True: 850, False: 73]
  ------------------
   68|    850|      add_dns(std::move(*parsed));
   69|    850|   } else {
   70|     73|      throw Decoding_Error("Invalid DNS name in SubjectAlternativeName");
   71|     73|   }
   72|    923|}
_ZN5Botan15AlternativeName7add_dnsENS_7DNSNameE:
   74|    850|void AlternativeName::add_dns(DNSName dns) {
   75|    850|   m_dns.insert(std::move(dns));
   76|    850|}
_ZN5Botan15AlternativeName17add_registered_idERKNS_3OIDE:
   97|    332|void AlternativeName::add_registered_id(const OID& oid) {
   98|    332|   m_registered_ids.insert(oid);
   99|    332|}
_ZN5Botan15AlternativeName6add_dnERKNS_7X509_DNE:
  101|    296|void AlternativeName::add_dn(const X509_DN& dn) {
  102|    296|   m_dn_names.insert(dn);
  103|    296|}
_ZN5Botan15AlternativeName16add_ipv4_addressERKNS_11IPv4AddressE:
  105|    734|void AlternativeName::add_ipv4_address(const IPv4Address& ip) {
  106|    734|   m_ipv4_addrs.insert(ip);
  107|    734|}
_ZN5Botan15AlternativeName16add_ipv6_addressERKNS_11IPv6AddressE:
  109|    137|void AlternativeName::add_ipv6_address(const IPv6Address& ip) {
  110|    137|   m_ipv6_addrs.insert(ip);
  111|    137|}
_ZNK5Botan15AlternativeName5countEv:
  113|    176|size_t AlternativeName::count() const {
  114|    176|   const auto sum = checked_add(m_dns.size(),
  115|    176|                                m_uri.size(),
  116|    176|                                m_email.size(),
  117|    176|                                m_ipv4_addrs.size(),
  118|    176|                                m_ipv6_addrs.size(),
  119|    176|                                m_dn_names.size(),
  120|    176|                                m_other_name_values.size(),
  121|    176|                                m_registered_ids.size());
  122|       |
  123|    176|   BOTAN_ASSERT_NOMSG(sum.has_value());
  ------------------
  |  |   84|    176|   do {                                                                     \
  |  |   85|    176|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|    176|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 176]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|    176|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 176]
  |  |  ------------------
  ------------------
  124|    176|   return sum.value();
  125|    176|}
_ZNK5Botan15AlternativeName9has_itemsEv:
  127|    176|bool AlternativeName::has_items() const {
  128|    176|   return this->count() > 0;
  129|    176|}
_ZN5Botan15AlternativeName11decode_fromERNS_11BER_DecoderE:
  198|  2.34k|void AlternativeName::decode_from(BER_Decoder& source) {
  199|  2.34k|   BER_Decoder names = source.start_sequence();
  200|       |
  201|  9.08k|   while(names.more_items()) {
  ------------------
  |  Branch (201:10): [True: 7.57k, False: 1.50k]
  ------------------
  202|  7.57k|      const BER_Object obj = names.get_next_object();
  203|       |
  204|  7.57k|      if(obj.is_a(0, ASN1_Class::ExplicitContextSpecific)) {
  ------------------
  |  Branch (204:10): [True: 850, False: 6.72k]
  ------------------
  205|    850|         BER_Decoder othername(obj, names.limits());
  206|       |
  207|    850|         OID oid;
  208|    850|         othername.decode(oid);
  209|    850|         const BER_Object othername_value_outer = othername.get_next_object();
  210|    850|         othername.verify_end();
  211|       |
  212|    850|         if(!othername_value_outer.is_a(0, ASN1_Class::ExplicitContextSpecific)) {
  ------------------
  |  Branch (212:13): [True: 4, False: 846]
  ------------------
  213|      4|            throw Decoding_Error("Invalid tags on otherName value");
  214|      4|         }
  215|       |
  216|    846|         BER_Decoder othername_value_inner(othername_value_outer, names.limits());
  217|       |
  218|    846|         const BER_Object value = othername_value_inner.get_next_object();
  219|    846|         othername_value_inner.verify_end();
  220|       |
  221|       |         // Capture the inner ANY value verbatim so applications can retrieve
  222|       |         // it regardless of its ASN.1 form.
  223|    846|         std::vector<uint8_t> raw_value;
  224|    846|         DER_Encoder(raw_value).add_object(value.type_tag(), value.class_tag(), value.data());
  225|    846|         m_other_name_values.insert(OtherNameValue{oid, std::move(raw_value)});
  226|       |
  227|       |         // Populate old string view for compatibility
  228|    846|         if(ASN1_String::is_string_type(value.type()) && value.get_class() == ASN1_Class::Universal) {
  ------------------
  |  Branch (228:13): [True: 535, False: 311]
  |  Branch (228:58): [True: 456, False: 79]
  ------------------
  229|    456|            try {
  230|    456|               m_othernames.insert(std::make_pair(oid, ASN1_String(ASN1::to_string(value), value.type())));
  231|    456|            } catch(const Invalid_Argument&) {  // NOLINT(*-empty-catch)
  232|    234|            }
  233|    456|         }
  234|       |
  235|    846|         if(oid == OID::from_string("PKIX.SmtpUTF8Mailbox")) {
  ------------------
  |  Branch (235:13): [True: 0, False: 846]
  ------------------
  236|      0|            if(!value.is_a(ASN1_Type::Utf8String, ASN1_Class::Universal)) {
  ------------------
  |  Branch (236:16): [True: 0, False: 0]
  ------------------
  237|      0|               throw Decoding_Error("SmtpUTF8Mailbox otherName must contain a UTF8String");
  238|      0|            }
  239|      0|            auto parsed_mailbox = SmtpUtf8Mailbox::from_string(ASN1::to_string(value));
  240|      0|            if(!parsed_mailbox.has_value()) {
  ------------------
  |  Branch (240:16): [True: 0, False: 0]
  ------------------
  241|      0|               throw Decoding_Error("Invalid SmtpUTF8Mailbox encoding");
  242|      0|            }
  243|      0|            m_smtp_utf8_mailboxes.insert(std::move(*parsed_mailbox));
  244|      0|         }
  245|  6.72k|      } else if(obj.is_a(1, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (245:17): [True: 672, False: 6.05k]
  ------------------
  246|    672|         add_email(ASN1::to_string(obj));
  247|  6.05k|      } else if(obj.is_a(2, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (247:17): [True: 959, False: 5.09k]
  ------------------
  248|    959|         add_dns(ASN1::to_string(obj));
  249|  5.09k|      } else if(obj.is_a(3, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (249:17): [True: 78, False: 5.01k]
  ------------------
  250|       |         // x400Address not supported but it is a SEQUENCE so we know it cannot be empty
  251|     78|         if(obj.length() == 0) {
  ------------------
  |  Branch (251:13): [True: 4, False: 74]
  ------------------
  252|      4|            throw Decoding_Error("Invalid x400Address field");
  253|      4|         }
  254|  5.01k|      } else if(obj.is_a(4, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (254:17): [True: 416, False: 4.60k]
  ------------------
  255|    416|         BER_Decoder dec(obj, names.limits());
  256|    416|         X509_DN dn;
  257|    416|         dec.decode(dn).verify_end();
  258|    416|         this->add_dn(dn);
  259|  4.60k|      } else if(obj.is_a(5, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (259:17): [True: 95, False: 4.50k]
  ------------------
  260|       |         // ediPartyName not supported but it is a SEQUENCE so we know it cannot be empty
  261|     95|         if(obj.length() == 0) {
  ------------------
  |  Branch (261:13): [True: 5, False: 90]
  ------------------
  262|      5|            throw Decoding_Error("Invalid ediPartyName field");
  263|      5|         }
  264|  4.50k|      } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (264:17): [True: 2.46k, False: 2.04k]
  ------------------
  265|  2.46k|         this->add_uri(ASN1::to_string(obj));
  266|  2.46k|      } else if(obj.is_a(7, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (266:17): [True: 885, False: 1.15k]
  ------------------
  267|    885|         if(obj.length() == 4) {
  ------------------
  |  Branch (267:13): [True: 734, False: 151]
  ------------------
  268|    734|            const uint32_t ip = load_be<uint32_t>(obj.bits(), 0);
  269|    734|            this->add_ipv4_address(ip);
  270|    734|         } else if(obj.length() == 16) {
  ------------------
  |  Branch (270:20): [True: 137, False: 14]
  ------------------
  271|    137|            const IPv6Address ip(std::span<const uint8_t, 16>{obj.bits(), 16});
  272|    137|            this->add_ipv6_address(ip);
  273|    137|         } else {
  274|     14|            throw Decoding_Error("Invalid IP constraint neither IPv4 or IPv6");
  275|     14|         }
  276|  1.15k|      } else if(obj.is_a(8, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (276:17): [True: 345, False: 810]
  ------------------
  277|       |         // [8] registeredID is IMPLICIT OBJECT IDENTIFIER.
  278|    345|         OID oid;
  279|    345|         names.decode_implicit(obj, oid, ASN1_Type::ObjectId, ASN1_Class::Universal);
  280|    345|         this->add_registered_id(oid);
  281|    810|      } else {
  282|    810|         throw Decoding_Error(fmt("Unknown GeneralName tag {}/class {}",
  283|    810|                                  static_cast<uint32_t>(obj.type_tag()),
  284|    810|                                  static_cast<uint32_t>(obj.class_tag())));
  285|    810|      }
  286|  7.57k|   }
  287|  2.34k|}

_ZN5Botan9CRL_Entry11decode_fromERNS_11BER_DecoderE:
   88|  8.80k|void CRL_Entry::decode_from(BER_Decoder& source) {
   89|  8.80k|   auto data = std::make_unique<CRL_Entry_Data>();
   90|       |
   91|  8.80k|   BER_Decoder entry = source.start_sequence();
   92|       |
   93|  8.80k|   entry.decode(data->m_serial);
   94|  8.80k|   entry.decode(data->m_time);
   95|       |
   96|  8.80k|   data->m_serial_bits = data->m_serial.magnitude();
   97|       |
   98|  8.80k|   if(entry.more_items()) {
  ------------------
  |  Branch (98:7): [True: 6.48k, False: 2.31k]
  ------------------
   99|  6.48k|      data->m_extensions.decode_from(entry, Extension_Context::CRL_Entry);
  100|       |
  101|       |      // TODO(Botan4) start checking that CRLEntry extensions is not empty
  102|       |      // Extensions  ::=  SEQUENCE SIZE (1..MAX) OF Extension
  103|       |
  104|  6.48k|      if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_ReasonCode>()) {
  ------------------
  |  Branch (104:22): [True: 1.14k, False: 5.34k]
  ------------------
  105|  1.14k|         const auto reason = ext->get_reason();
  106|       |
  107|       |         /*
  108|       |         * This reason code only makes sense in the context of delta CRL processing, which
  109|       |         * we do not currently support. Seeing it in a regular CRL suggests that something
  110|       |         * has gone very wrong (eg we are somehow processing a delta CRL, though that
  111|       |         * shouldn't happen since the delta CRL indicator extension should be a critical
  112|       |         * extension which we will reject.)
  113|       |         */
  114|  1.14k|         if(reason == CRL_Code::RemoveFromCrl) {
  ------------------
  |  Branch (114:13): [True: 2, False: 1.14k]
  ------------------
  115|      2|            throw Decoding_Error("CRL entry ReasonCode extension included invalid RemoveFromCrl");
  116|      2|         }
  117|  1.14k|         data->m_reason = reason;
  118|  5.34k|      } else {
  119|  5.34k|         data->m_reason = CRL_Code::Unspecified;
  120|  5.34k|      }
  121|  6.48k|   }
  122|       |
  123|  8.80k|   entry.end_cons();
  124|       |
  125|  8.80k|   m_data = std::move(data);
  126|  8.80k|}
_ZNK5Botan9CRL_Entry4dataEv:
  128|  12.0k|const CRL_Entry_Data& CRL_Entry::data() const {
  129|  12.0k|   if(!m_data) {
  ------------------
  |  Branch (129:7): [True: 0, False: 12.0k]
  ------------------
  130|      0|      throw Invalid_State("CRL_Entry_Data uninitialized");
  131|      0|   }
  132|       |
  133|  12.0k|   return *m_data;
  134|  12.0k|}
_ZNK5Botan9CRL_Entry6serialEv:
  140|  3.01k|const X509_Serial_Number& CRL_Entry::serial() const {
  141|  3.01k|   return data().m_serial;
  142|  3.01k|}
_ZNK5Botan9CRL_Entry10extensionsEv:
  152|  9.01k|const Extensions& CRL_Entry::extensions() const {
  153|  9.01k|   return data().m_extensions;
  154|  9.01k|}
_ZN5Botan14CRL_Entry_DataC2Ev:
   31|  8.80k|      CRL_Entry_Data() = default;

_ZNK5Botan8X509_CRL9PEM_labelEv:
   62|  4.22k|std::string X509_CRL::PEM_label() const {
   63|  4.22k|   return "X509 CRL";
   64|  4.22k|}
_ZNK5Botan8X509_CRL20alternate_PEM_labelsEv:
   66|     82|std::vector<std::string> X509_CRL::alternate_PEM_labels() const {
   67|     82|   return {"CRL"};
   68|     82|}
_ZN5Botan8X509_CRLC2ERNS_10DataSourceE:
   70|  4.20k|X509_CRL::X509_CRL(DataSource& src) {
   71|  4.20k|   load_data(src);
   72|  4.20k|}
_ZN5Botan8X509_CRL12force_decodeEv:
  242|  2.94k|void X509_CRL::force_decode() {
  243|  2.94k|   m_data.reset(decode_crl_body(signed_body(), signature_algorithm()).release());
  244|  2.94k|}
x509_crl.cpp:_ZN5Botan12_GLOBAL__N_115decode_crl_bodyERKNSt3__16vectorIhNS1_9allocatorIhEEEERKNS_19AlgorithmIdentifierE:
  130|  2.94k|std::unique_ptr<CRL_Data> decode_crl_body(const std::vector<uint8_t>& body, const AlgorithmIdentifier& sig_algo) {
  131|  2.94k|   auto data = std::make_unique<CRL_Data>();
  132|       |
  133|  2.94k|   BER_Decoder tbs_crl(body, BER_Decoder::Limits::DER());
  134|       |
  135|  2.94k|   tbs_crl.decode_optional(data->m_version, ASN1_Type::Integer, ASN1_Class::Universal);
  136|  2.94k|   data->m_version += 1;  // wire-format is 0-based
  137|       |
  138|  2.94k|   if(data->m_version != 1 && data->m_version != 2) {
  ------------------
  |  Branch (138:7): [True: 2.61k, False: 334]
  |  Branch (138:31): [True: 42, False: 2.56k]
  ------------------
  139|     42|      throw Decoding_Error("Unknown X.509 CRL version " + std::to_string(data->m_version));
  140|     42|   }
  141|       |
  142|       |   // Extensions are only defined for v2 CRLs
  143|  2.90k|   const bool supports_extensions = data->m_version > 1;
  144|       |
  145|  2.90k|   AlgorithmIdentifier sig_algo_inner;
  146|  2.90k|   tbs_crl.decode(sig_algo_inner);
  147|       |
  148|  2.90k|   if(sig_algo != sig_algo_inner) {
  ------------------
  |  Branch (148:7): [True: 89, False: 2.81k]
  ------------------
  149|     89|      throw Decoding_Error("Algorithm identifier mismatch in CRL");
  150|     89|   }
  151|       |
  152|  2.81k|   tbs_crl.decode(data->m_issuer).decode(data->m_this_update);
  153|       |
  154|       |   // According to RFC 5280 Section 5.1, nextUpdate is OPTIONAL and may be
  155|       |   // encoded as either a UTCTime or a GeneralizedTime. Section 5.1.2.5
  156|       |   // further states that "[c]onforming CRL issuers MUST include the nextUpdate
  157|       |   // field in all CRLs". Obviously, not everyone complies...
  158|       |   //
  159|       |   // See https://github.com/randombit/botan/issues/4722 for more details.
  160|  2.81k|   {
  161|  2.81k|      const auto& next_update = tbs_crl.peek_next_object();
  162|  2.81k|      if(next_update.is_a(ASN1_Type::UtcTime, ASN1_Class::Universal) ||
  ------------------
  |  Branch (162:10): [True: 1.91k, False: 897]
  ------------------
  163|  1.15k|         next_update.is_a(ASN1_Type::GeneralizedTime, ASN1_Class::Universal)) {
  ------------------
  |  Branch (163:10): [True: 6, False: 891]
  ------------------
  164|  1.15k|         tbs_crl.decode(data->m_next_update);
  165|  1.15k|      }
  166|  2.81k|   }
  167|       |
  168|  2.81k|   BER_Object next = tbs_crl.get_next_object();
  169|       |
  170|  2.81k|   if(next.is_a(ASN1_Type::Sequence, ASN1_Class::Constructed)) {
  ------------------
  |  Branch (170:7): [True: 305, False: 2.50k]
  ------------------
  171|    305|      BER_Decoder cert_list(next, tbs_crl.limits());
  172|       |
  173|  9.10k|      while(cert_list.more_items()) {
  ------------------
  |  Branch (173:13): [True: 8.80k, False: 302]
  ------------------
  174|  8.80k|         CRL_Entry entry;
  175|  8.80k|         cert_list.decode(entry);
  176|       |
  177|  8.80k|         if(entry.extensions().has_unknown_critical_extension()) {
  ------------------
  |  Branch (177:13): [True: 1, False: 8.80k]
  ------------------
  178|      1|            data->m_has_unknown_critical_extension = true;
  179|      1|         }
  180|       |
  181|  8.80k|         if(!supports_extensions && entry.extensions().count() > 0) {
  ------------------
  |  Branch (181:13): [True: 471, False: 8.33k]
  |  Branch (181:37): [True: 3, False: 468]
  ------------------
  182|      3|            throw Decoding_Error("X509 CRL included extensions in a version that doesn't support them");
  183|      3|         }
  184|       |
  185|  8.79k|         data->m_entries.push_back(std::move(entry));
  186|  8.79k|      }
  187|       |
  188|       |      /*
  189|       |      RFC 5280 Section 5.1.2.6
  190|       |         When there are no revoked certificates, the revoked certificates list MUST be absent.
  191|       |
  192|       |      So strictly speaking we should be checking that m_entries is not empty. But practically,
  193|       |      it seems nearly all implementations accept a present-but-empty SEQUENCE as equivalent
  194|       |      to an absent one, and several major ones (including GnuTLS) will emit it. Considering
  195|       |      this situation, and the benign nature of the deviation, accept the non-conforming encoding.
  196|       |      */
  197|       |
  198|    302|      next = tbs_crl.get_next_object();
  199|    302|   }
  200|       |
  201|  2.81k|   if(next.is_a(0, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (201:7): [True: 1.72k, False: 1.08k]
  ------------------
  202|  1.72k|      if(!supports_extensions) {
  ------------------
  |  Branch (202:10): [True: 1, False: 1.72k]
  ------------------
  203|      1|         throw Decoding_Error("X509 CRL included extensions in a version that doesn't support them");
  204|      1|      }
  205|  1.72k|      BER_Decoder crl_options(next, tbs_crl.limits());
  206|  1.72k|      data->m_extensions.decode_from(crl_options, Extension_Context::CRL);
  207|  1.72k|      crl_options.verify_end();
  208|  1.72k|      if(data->m_extensions.has_unknown_critical_extension()) {
  ------------------
  |  Branch (208:10): [True: 0, False: 1.72k]
  ------------------
  209|      0|         data->m_has_unknown_critical_extension = true;
  210|      0|      }
  211|       |
  212|  1.72k|      if(tbs_crl.get_next_object().is_set()) {
  ------------------
  |  Branch (212:10): [True: 33, False: 1.69k]
  ------------------
  213|     33|         throw Decoding_Error("Unknown tag following extensions in CRL");
  214|     33|      }
  215|  1.72k|   }
  216|       |
  217|  2.77k|   tbs_crl.verify_end("Unexpected trailing data after CRL");
  218|       |
  219|       |   // Now cache some fields from the extensions
  220|  2.77k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Number>()) {
  ------------------
  |  Branch (220:19): [True: 13, False: 2.76k]
  ------------------
  221|     13|      data->m_crl_number = ext->crl_number();
  222|     13|   }
  223|  2.77k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
  ------------------
  |  Branch (223:19): [True: 4, False: 2.77k]
  ------------------
  224|      4|      data->m_auth_key_id = ext->get_key_id();
  225|      4|   }
  226|  2.77k|   if(const auto* ext = data->m_extensions.get_extension_object_as<Cert_Extension::CRL_Issuing_Distribution_Point>()) {
  ------------------
  |  Branch (226:19): [True: 0, False: 2.77k]
  ------------------
  227|      0|      const auto& dpn = ext->distribution_point_name();
  228|      0|      if(dpn.has_value() && dpn->full_name().has_value()) {
  ------------------
  |  Branch (228:10): [True: 0, False: 0]
  |  Branch (228:29): [True: 0, False: 0]
  ------------------
  229|      0|         for(const auto& uri : dpn->full_name()->uri_names()) {
  ------------------
  |  Branch (229:30): [True: 0, False: 0]
  ------------------
  230|      0|            data->m_idp_urls.push_back(uri);
  231|      0|         }
  232|      0|      }
  233|      0|   }
  234|       |
  235|  2.77k|   data->update_index();
  236|       |
  237|  2.77k|   return data;
  238|  2.81k|}
_ZN5Botan8CRL_DataC2Ev:
   34|  2.94k|      CRL_Data() = default;
_ZN5Botan8CRL_Data12update_indexEv:
   36|     47|      void update_index() {
   37|     47|         m_revoked_serials.clear();
   38|  3.01k|         for(const auto& entry : m_entries) {
  ------------------
  |  Branch (38:32): [True: 3.01k, False: 47]
  ------------------
   39|  3.01k|            m_revoked_serials.insert(entry.serial());
   40|  3.01k|         }
   41|     47|      }

_ZN5BotanltERKNS_7X509_DNES2_:
  355|    391|bool operator<(const X509_DN& dn1, const X509_DN& dn2) {
  356|    391|   return dn1._canonical_bytes() < dn2._canonical_bytes();
  357|    391|}
_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  405|  3.00k|void X509_DN::decode_from(BER_Decoder& source) {
  406|  3.00k|   std::vector<uint8_t> bits;
  407|       |
  408|  3.00k|   source.start_sequence().raw_bytes(bits).end_cons();
  409|       |
  410|  3.00k|   BER_Decoder sequence(bits, source.limits());
  411|       |
  412|  3.00k|   std::vector<std::vector<std::pair<OID, ASN1_String>>> rdns;
  413|       |
  414|       |   // Cap AVAs per RDN to bound work for downstream set-based matching.
  415|       |   // No legitimate cert has anywhere near this many AVAs in a single RDN.
  416|  3.00k|   constexpr size_t MAX_AVAS_PER_RDN = 32;
  417|       |
  418|  6.99k|   while(sequence.more_items()) {
  ------------------
  |  Branch (418:10): [True: 3.99k, False: 2.99k]
  ------------------
  419|  3.99k|      BER_Decoder rdn_decoder = sequence.start_set();
  420|       |
  421|  3.99k|      std::vector<std::pair<OID, ASN1_String>> rdn;
  422|  7.76k|      while(rdn_decoder.more_items()) {
  ------------------
  |  Branch (422:13): [True: 3.76k, False: 3.99k]
  ------------------
  423|  3.76k|         OID oid;
  424|  3.76k|         ASN1_String str;
  425|       |
  426|  3.76k|         rdn_decoder.start_sequence()
  427|  3.76k|            .decode(oid)
  428|  3.76k|            .decode(str)  // TODO support Any
  429|  3.76k|            .end_cons();
  430|       |
  431|  3.76k|         rdn.emplace_back(std::move(oid), std::move(str));
  432|       |
  433|  3.76k|         if(rdn.size() > MAX_AVAS_PER_RDN) {
  ------------------
  |  Branch (433:13): [True: 0, False: 3.76k]
  ------------------
  434|      0|            throw Decoding_Error("X.500 RDN has too many attribute-value assertions");
  435|      0|         }
  436|  3.76k|      }
  437|       |
  438|       |      /*
  439|       |      RFC 5280 4.1.2.4:
  440|       |         RelativeDistinguishedName ::=
  441|       |           SET SIZE (1..MAX) OF AttributeTypeAndValue
  442|       |      */
  443|  3.99k|      if(rdn.empty()) {
  ------------------
  |  Branch (443:10): [True: 3, False: 3.99k]
  ------------------
  444|      3|         throw Decoding_Error("X.500 RDN must contain at least one attribute-value assertion");
  445|      3|      }
  446|  3.99k|      rdns.push_back(std::move(rdn));
  447|  3.99k|   }
  448|       |
  449|  2.99k|   auto canonical_bits = canonicalize_dn(rdns);
  450|       |
  451|  2.99k|   m_rdn = std::move(rdns);
  452|  2.99k|   m_dn_bits = std::move(bits);
  453|  2.99k|   m_canonical_dn_bits = std::move(canonical_bits);
  454|  2.99k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_120append_canonical_rdnERNSt3__16vectorIhNS1_9allocatorIhEEEERKNS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS3_ISA_EEEE:
  152|  3.42k|void append_canonical_rdn(std::vector<uint8_t>& canonical_bits, const std::vector<std::pair<OID, ASN1_String>>& rdn) {
  153|  3.42k|   const auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  154|  3.42k|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  155|  3.42k|      out.insert(out.end(), data_len.begin(), data_len.end());
  156|  3.42k|      out.insert(out.end(), data.begin(), data.end());
  157|  3.42k|   };
  158|       |
  159|  3.42k|   std::vector<uint8_t> rdn_bits;
  160|       |
  161|  3.42k|   for(const auto& [oid, value] : canonicalize_rdn(rdn)) {
  ------------------
  |  Branch (161:33): [True: 3.42k, False: 3.42k]
  ------------------
  162|  3.42k|      append_canonical_data(rdn_bits, oid.BER_encode());
  163|  3.42k|      append_canonical_data(rdn_bits, value);
  164|  3.42k|   }
  165|       |
  166|  3.42k|   append_canonical_data(canonical_bits, rdn_bits);
  167|  3.42k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_116canonicalize_rdnERKNSt3__16vectorINS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEE:
  136|  3.42k|std::vector<std::pair<OID, std::string>> canonicalize_rdn(const std::vector<std::pair<OID, ASN1_String>>& rdn) {
  137|  3.42k|   std::vector<std::pair<OID, std::string>> result;
  138|  3.42k|   result.reserve(rdn.size());
  139|  3.42k|   for(const auto& ava : rdn) {
  ------------------
  |  Branch (139:24): [True: 3.42k, False: 3.42k]
  ------------------
  140|  3.42k|      result.emplace_back(ava.first, X500_Char_Iterator::canonicalize(ava.second.value()));
  141|  3.42k|   }
  142|  3.42k|   if(result.size() != 1) {
  ------------------
  |  Branch (142:7): [True: 2, False: 3.42k]
  ------------------
  143|      2|      std::sort(result.begin(), result.end());
  144|      2|   }
  145|  3.42k|   return result;
  146|  3.42k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_Iterator12canonicalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  114|  3.42k|      static std::string canonicalize(std::string_view name) {
  115|  3.42k|         std::string result;
  116|  3.42k|         result.reserve(name.size());
  117|       |
  118|  3.42k|         X500_Char_Iterator it(name);
  119|  24.0k|         while(auto c = it.next()) {
  ------------------
  |  Branch (119:21): [True: 20.6k, False: 3.42k]
  ------------------
  120|  20.6k|            result += *c;
  121|  20.6k|         }
  122|       |
  123|  3.42k|         return result;
  124|  3.42k|      }
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_IteratorC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   81|  3.42k|      explicit X500_Char_Iterator(std::string_view s) : m_str(s), m_pos(0) {
   82|       |         // Skip leading whitespace
   83|  3.84k|         while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
  ------------------
  |  Branch (83:16): [True: 3.83k, False: 18]
  |  Branch (83:40): [True: 421, False: 3.40k]
  ------------------
   84|    421|            ++m_pos;
   85|    421|         }
   86|  3.42k|      }
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_118X500_Char_Iterator4nextEv:
   89|  24.0k|      std::optional<char> next() {
   90|  24.0k|         if(m_pos >= m_str.size()) {
  ------------------
  |  Branch (90:13): [True: 3.36k, False: 20.6k]
  ------------------
   91|  3.36k|            return std::nullopt;
   92|  3.36k|         }
   93|       |
   94|  20.6k|         if(is_space(m_str[m_pos])) {
  ------------------
  |  Branch (94:13): [True: 512, False: 20.1k]
  ------------------
   95|       |            // Skip the entire whitespace run
   96|  1.53k|            while(m_pos < m_str.size() && is_space(m_str[m_pos])) {
  ------------------
  |  Branch (96:19): [True: 1.47k, False: 61]
  |  Branch (96:43): [True: 1.01k, False: 451]
  ------------------
   97|  1.01k|               ++m_pos;
   98|  1.01k|            }
   99|       |            // Emit a single space only if more content follows (strip trailing ws)
  100|    512|            if(m_pos < m_str.size()) {
  ------------------
  |  Branch (100:16): [True: 451, False: 61]
  ------------------
  101|    451|               return ' ';
  102|    451|            }
  103|     61|            return std::nullopt;
  104|    512|         }
  105|       |
  106|  20.1k|         const char c = m_str[m_pos++];
  107|       |         // Locale-independent ASCII fold; RFC 5280 DN matching does not depend on libc locale
  108|  20.1k|         if(c >= 'A' && c <= 'Z') {
  ------------------
  |  Branch (108:13): [True: 10.7k, False: 9.45k]
  |  Branch (108:25): [True: 8.92k, False: 1.79k]
  ------------------
  109|  8.92k|            return static_cast<char>(c + ('a' - 'A'));
  110|  8.92k|         }
  111|  11.2k|         return c;
  112|  20.1k|      }
x509_dn.cpp:_ZZN5Botan12_GLOBAL__N_120append_canonical_rdnERNSt3__16vectorIhNS1_9allocatorIhEEEERKNS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS3_ISA_EEEEENK3$_0clIS5_EEDaS6_RKT_:
  153|  6.85k|   const auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  154|  6.85k|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  155|  6.85k|      out.insert(out.end(), data_len.begin(), data_len.end());
  156|  6.85k|      out.insert(out.end(), data.begin(), data.end());
  157|  6.85k|   };
x509_dn.cpp:_ZZN5Botan12_GLOBAL__N_120append_canonical_rdnERNSt3__16vectorIhNS1_9allocatorIhEEEERKNS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS3_ISA_EEEEENK3$_0clINS1_12basic_stringIcNS1_11char_traitsIcEENS3_IcEEEEEEDaS6_RKT_:
  153|  3.42k|   const auto append_canonical_data = []<typename T>(std::vector<uint8_t>& out, const T& data) {
  154|  3.42k|      const std::array<uint8_t, 8> data_len = store_le(static_cast<uint64_t>(data.size()));
  155|  3.42k|      out.insert(out.end(), data_len.begin(), data_len.end());
  156|  3.42k|      out.insert(out.end(), data.begin(), data.end());
  157|  3.42k|   };
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_115canonicalize_dnERKNSt3__16vectorINS2_INS1_4pairINS_3OIDENS_11ASN1_StringEEENS1_9allocatorIS6_EEEENS7_IS9_EEEE:
  169|  2.52k|std::vector<uint8_t> canonicalize_dn(const std::vector<std::vector<std::pair<OID, ASN1_String>>>& rdns) {
  170|  2.52k|   std::vector<uint8_t> canonical_bits;
  171|       |
  172|  3.42k|   for(const auto& rdn : rdns) {
  ------------------
  |  Branch (172:24): [True: 3.42k, False: 2.52k]
  ------------------
  173|  3.42k|      append_canonical_rdn(canonical_bits, rdn);
  174|  3.42k|   }
  175|       |
  176|  2.52k|   return canonical_bits;
  177|  2.52k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_18is_spaceEc:
   26|  25.9k|bool is_space(char c) {
   27|  25.9k|   return c == ' ' || c == '\t';
  ------------------
  |  Branch (27:11): [True: 1.55k, False: 24.4k]
  |  Branch (27:23): [True: 402, False: 24.0k]
  ------------------
   28|  25.9k|}

_ZN5Botan10Extensions15create_extn_objERKNS_3OIDEbRKNSt3__16vectorIhNS4_9allocatorIhEEEENS4_8optionalINS_17Extension_ContextEEE:
  138|  13.8k|                                                                   std::optional<Extension_Context> context) {
  139|  13.8k|   auto extn = extension_from_oid(oid);
  140|       |
  141|  13.8k|   if(!extn) {
  ------------------
  |  Branch (141:7): [True: 7.61k, False: 6.25k]
  ------------------
  142|       |      // some other unknown extension type
  143|  7.61k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  144|  7.61k|   } else {
  145|  6.25k|      if(context.has_value() && !extn->is_appropriate_context(*context)) {
  ------------------
  |  Branch (145:10): [True: 6.25k, False: 0]
  |  Branch (145:33): [True: 23, False: 6.22k]
  ------------------
  146|     23|         throw Decoding_Error(fmt("Extension {} is not allowed in this context", extn->oid_name()));
  147|     23|      }
  148|       |
  149|  6.22k|      try {
  150|  6.22k|         extn->decode_inner(body);
  151|  6.22k|         return extn;
  152|  6.22k|      } catch(const Exception&) {
  153|       |         // OID was recognized but contents failed to decode
  154|  4.90k|         extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical, /*failed_to_decode=*/true);
  155|  4.90k|      }
  156|  6.22k|   }
  157|       |
  158|       |   // This is always Unknown_Extension:
  159|  12.5k|   extn->decode_inner(body);
  160|  12.5k|   return extn;
  161|  13.8k|}
_ZNK5Botan10Extensions15Extensions_Info3objEv:
  163|  3.57k|const Certificate_Extension& Extensions::Extensions_Info::obj() const {
  164|  3.57k|   BOTAN_ASSERT_NONNULL(m_obj.get());
  ------------------
  |  |  123|  3.57k|   do {                                                                                   \
  |  |  124|  3.57k|      if((ptr) == nullptr) {                                                              \
  |  |  ------------------
  |  |  |  Branch (124:10): [True: 0, False: 3.57k]
  |  |  ------------------
  |  |  125|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                              \
  |  |  126|      0|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |  127|      0|      }                                                                                   \
  |  |  128|  3.57k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (128:12): [Folded, False: 3.57k]
  |  |  ------------------
  ------------------
  165|  3.57k|   return *m_obj;
  166|  3.57k|}
_ZNK5Botan10Extensions20get_extension_objectERKNS_3OIDE:
  246|  6.58k|const Certificate_Extension* Extensions::get_extension_object(const OID& oid) const {
  247|  6.58k|   const auto extn = m_extension_info.find(oid);
  248|  6.58k|   if(extn == m_extension_info.end()) {
  ------------------
  |  Branch (248:7): [True: 3.01k, False: 3.57k]
  ------------------
  249|  3.01k|      return nullptr;
  250|  3.01k|   }
  251|       |
  252|  3.57k|   return &extn->second.obj();
  253|  6.58k|}
_ZN5Botan10Extensions11decode_fromERNS_11BER_DecoderENSt3__18optionalINS_17Extension_ContextEEE:
  316|  8.21k|void Extensions::decode_from(BER_Decoder& from_source, std::optional<Extension_Context> context) {
  317|  8.21k|   m_extension_oids.clear();
  318|  8.21k|   m_extension_info.clear();
  319|  8.21k|   m_has_unknown_critical_extension = false;
  320|       |
  321|  8.21k|   BER_Decoder sequence = from_source.start_sequence();
  322|       |
  323|  22.1k|   while(sequence.more_items()) {
  ------------------
  |  Branch (323:10): [True: 14.7k, False: 7.39k]
  ------------------
  324|  14.7k|      OID oid;
  325|  14.7k|      bool critical = false;
  326|  14.7k|      std::vector<uint8_t> bits;
  327|       |
  328|  14.7k|      sequence.start_sequence()
  329|  14.7k|         .decode(oid)
  330|  14.7k|         .decode_optional(critical, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  331|  14.7k|         .decode(bits, ASN1_Type::OctetString)
  332|  14.7k|         .end_cons();
  333|       |
  334|  14.7k|      auto obj = create_extn_obj(oid, critical, bits, context);
  335|       |      // Unknown_Extension is the only Certificate_Extension with an empty oid_name
  336|  14.7k|      if(critical && obj->oid_name().empty()) {
  ------------------
  |  Branch (336:10): [True: 2, False: 14.7k]
  |  Branch (336:10): [True: 2, False: 14.7k]
  |  Branch (336:22): [True: 2, False: 0]
  ------------------
  337|      2|         m_has_unknown_critical_extension = true;
  338|      2|      }
  339|  14.7k|      Extensions_Info info(critical, std::move(bits), std::move(obj));
  340|       |
  341|  14.7k|      m_extension_oids.push_back(oid);
  342|       |
  343|       |      // RFC 5280 4.2: "A certificate MUST NOT include more than one
  344|       |      // instance of a particular extension."
  345|  14.7k|      if(!m_extension_info.emplace(std::move(oid), std::move(info)).second) {
  ------------------
  |  Branch (345:10): [True: 816, False: 13.8k]
  ------------------
  346|    816|         throw Decoding_Error("Duplicate certificate extension encountered");
  347|    816|      }
  348|  14.7k|   }
  349|  7.39k|   sequence.verify_end();
  350|  7.39k|}
_ZNK5Botan14Cert_Extension17Basic_Constraints22is_appropriate_contextENS_17Extension_ContextE:
  354|      1|bool Basic_Constraints::is_appropriate_context(Extension_Context context) const {
  355|      1|   return context == Extension_Context::Certificate;
  356|      1|}
_ZNK5Botan14Cert_Extension9Key_Usage22is_appropriate_contextENS_17Extension_ContextE:
  358|      1|bool Key_Usage::is_appropriate_context(Extension_Context context) const {
  359|      1|   return context == Extension_Context::Certificate;
  360|      1|}
_ZNK5Botan14Cert_Extension14Subject_Key_ID22is_appropriate_contextENS_17Extension_ContextE:
  362|      2|bool Subject_Key_ID::is_appropriate_context(Extension_Context context) const {
  363|      2|   return context == Extension_Context::Certificate;
  364|      2|}
_ZNK5Botan14Cert_Extension16Authority_Key_ID22is_appropriate_contextENS_17Extension_ContextE:
  366|    248|bool Authority_Key_ID::is_appropriate_context(Extension_Context context) const {
  367|    248|   return context == Extension_Context::Certificate || context == Extension_Context::CRL;
  ------------------
  |  Branch (367:11): [True: 0, False: 248]
  |  Branch (367:56): [True: 247, False: 1]
  ------------------
  368|    248|}
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name22is_appropriate_contextENS_17Extension_ContextE:
  370|      1|bool Subject_Alternative_Name::is_appropriate_context(Extension_Context context) const {
  371|      1|   return context == Extension_Context::Certificate;
  372|      1|}
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name22is_appropriate_contextENS_17Extension_ContextE:
  374|  2.06k|bool Issuer_Alternative_Name::is_appropriate_context(Extension_Context context) const {
  375|  2.06k|   return context == Extension_Context::Certificate || context == Extension_Context::CRL;
  ------------------
  |  Branch (375:11): [True: 0, False: 2.06k]
  |  Branch (375:56): [True: 2.06k, False: 1]
  ------------------
  376|  2.06k|}
_ZNK5Botan14Cert_Extension18Extended_Key_Usage22is_appropriate_contextENS_17Extension_ContextE:
  378|      1|bool Extended_Key_Usage::is_appropriate_context(Extension_Context context) const {
  379|      1|   return context == Extension_Context::Certificate;
  380|      1|}
_ZNK5Botan14Cert_Extension16Name_Constraints22is_appropriate_contextENS_17Extension_ContextE:
  382|      1|bool Name_Constraints::is_appropriate_context(Extension_Context context) const {
  383|      1|   return context == Extension_Context::Certificate;
  384|      1|}
_ZNK5Botan14Cert_Extension20Certificate_Policies22is_appropriate_contextENS_17Extension_ContextE:
  386|      3|bool Certificate_Policies::is_appropriate_context(Extension_Context context) const {
  387|      3|   return context == Extension_Context::Certificate;
  388|      3|}
_ZNK5Botan14Cert_Extension28Authority_Information_Access22is_appropriate_contextENS_17Extension_ContextE:
  390|     92|bool Authority_Information_Access::is_appropriate_context(Extension_Context context) const {
  391|     92|   return context == Extension_Context::Certificate || context == Extension_Context::CRL;
  ------------------
  |  Branch (391:11): [True: 0, False: 92]
  |  Branch (391:56): [True: 92, False: 0]
  ------------------
  392|     92|}
_ZNK5Botan14Cert_Extension10CRL_Number22is_appropriate_contextENS_17Extension_ContextE:
  394|     52|bool CRL_Number::is_appropriate_context(Extension_Context context) const {
  395|     52|   return context == Extension_Context::CRL;
  396|     52|}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode22is_appropriate_contextENS_17Extension_ContextE:
  398|  3.54k|bool CRL_ReasonCode::is_appropriate_context(Extension_Context context) const {
  399|       |   // RFC 6960 4.4.5: "All the extensions specified as CRL entry extensions
  400|       |   // -- in Section 5.3 of [RFC5280] -- are also supported as singleExtensions."
  401|  3.54k|   return context == Extension_Context::CRL_Entry || context == Extension_Context::OCSP_Response;
  ------------------
  |  Branch (401:11): [True: 3.54k, False: 3]
  |  Branch (401:54): [True: 0, False: 3]
  ------------------
  402|  3.54k|}
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points22is_appropriate_contextENS_17Extension_ContextE:
  404|      2|bool CRL_Distribution_Points::is_appropriate_context(Extension_Context context) const {
  405|      2|   return context == Extension_Context::Certificate;
  406|      2|}
_ZNK5Botan14Cert_Extension30CRL_Issuing_Distribution_Point22is_appropriate_contextENS_17Extension_ContextE:
  408|    237|bool CRL_Issuing_Distribution_Point::is_appropriate_context(Extension_Context context) const {
  409|    237|   return context == Extension_Context::CRL;
  410|    237|}
_ZNK5Botan14Cert_Extension21NoRevocationAvailable22is_appropriate_contextENS_17Extension_ContextE:
  416|      1|bool NoRevocationAvailable::is_appropriate_context(Extension_Context context) const {
  417|      1|   return context == Extension_Context::Certificate;
  418|      1|}
_ZNK5Botan14Cert_Extension10TNAuthList22is_appropriate_contextENS_17Extension_ContextE:
  420|      1|bool TNAuthList::is_appropriate_context(Extension_Context context) const {
  421|      1|   return context == Extension_Context::Certificate;
  422|      1|}
_ZNK5Botan14Cert_Extension15IPAddressBlocks22is_appropriate_contextENS_17Extension_ContextE:
  424|      1|bool IPAddressBlocks::is_appropriate_context(Extension_Context context) const {
  425|      1|   return context == Extension_Context::Certificate;
  426|      1|}
_ZNK5Botan14Cert_Extension8ASBlocks22is_appropriate_contextENS_17Extension_ContextE:
  428|      1|bool ASBlocks::is_appropriate_context(Extension_Context context) const {
  429|      1|   return context == Extension_Context::Certificate;
  430|      1|}
_ZN5Botan14Cert_Extension17Basic_ConstraintsC2Ebm:
  437|      1|      Basic_Constraints(is_ca, is_ca ? std::optional<size_t>(path_length_constraint) : std::nullopt) {}
  ------------------
  |  Branch (437:32): [True: 0, False: 1]
  ------------------
_ZN5Botan14Cert_Extension17Basic_ConstraintsC2EbNSt3__18optionalImEE:
  440|      1|      m_is_ca(is_ca), m_path_length_constraint(path_length_constraint) {
  441|      1|   if(!m_is_ca && m_path_length_constraint.has_value()) {
  ------------------
  |  Branch (441:7): [True: 1, False: 0]
  |  Branch (441:19): [True: 0, False: 1]
  ------------------
  442|       |      // RFC 5280 Sec 4.2.1.9 "CAs MUST NOT include the pathLenConstraint field unless the cA boolean is asserted"
  443|      0|      throw Invalid_Argument(
  444|      0|         "Basic_Constraints nonsensical to set a path length constraint for a non-CA basicConstraints");
  445|      0|   }
  446|      1|}
_ZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  615|    247|void Authority_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  616|       |   /*
  617|       |   * RFC 5280 Section 4.2.1.1
  618|       |   *
  619|       |   * AuthorityKeyIdentifier ::= SEQUENCE {
  620|       |   *    keyIdentifier             [0] KeyIdentifier           OPTIONAL,
  621|       |   *    authorityCertIssuer       [1] GeneralNames            OPTIONAL,
  622|       |   *    authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
  623|       |   */
  624|    247|   BER_Decoder ber(in, BER_Decoder::Limits::DER());
  625|    247|   BER_Decoder seq = ber.start_sequence();
  626|       |
  627|    247|   m_key_id.clear();
  628|    247|   m_authority_cert.reset();
  629|       |
  630|    247|   bool key_id_present = false;
  631|    247|   std::optional<AlternativeName> authority_cert_issuer;
  632|    247|   std::optional<X509_Serial_Number> authority_cert_serial;
  633|       |
  634|    247|   seq.decode_optional_field(0,
  635|    247|                             ASN1_Class::ContextSpecific,
  636|    247|                             [&](BER_Decoder& d) {
  637|    247|                                d.decode(m_key_id, ASN1_Type::OctetString, ASN1_Type(0), ASN1_Class::ContextSpecific);
  638|    247|                                key_id_present = true;
  639|    247|                             })
  640|    247|      .decode_optional_field(1,
  641|    247|                             ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
  642|    247|                             [&](BER_Decoder& d) {
  643|    247|                                AlternativeName names;
  644|    247|                                d.decode_implicit(names,
  645|    247|                                                  ASN1_Type(1),
  646|    247|                                                  ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
  647|    247|                                                  ASN1_Type::Sequence,
  648|    247|                                                  ASN1_Class::Constructed);
  649|    247|                                authority_cert_issuer = std::move(names);
  650|    247|                             })
  651|    247|      .decode_optional_field(2, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) {
  652|    247|         X509_Serial_Number serial;
  653|    247|         d.decode_implicit(
  654|    247|            serial, ASN1_Type(2), ASN1_Class::ContextSpecific, ASN1_Type::Integer, ASN1_Class::Universal);
  655|    247|         authority_cert_serial = std::move(serial);
  656|    247|      });
  657|       |
  658|    247|   seq.end_cons();
  659|    247|   ber.verify_end();
  660|       |
  661|    247|   if(key_id_present) {
  ------------------
  |  Branch (661:7): [True: 11, False: 236]
  ------------------
  662|     11|      if(m_key_id.empty()) {
  ------------------
  |  Branch (662:10): [True: 0, False: 11]
  ------------------
  663|      0|         throw Decoding_Error("AuthorityKeyIdentifier keyIdentifier must not be empty");
  664|      0|      }
  665|     11|      if(m_key_id.size() > MaximumKeyIdentifierLength) {
  ------------------
  |  Branch (665:10): [True: 3, False: 8]
  ------------------
  666|      3|         throw Decoding_Error(fmt("AuthorityKeyIdentifier keyIdentifier length {} exceeds limit of {} bytes",
  667|      3|                                  m_key_id.size(),
  668|      3|                                  MaximumKeyIdentifierLength));
  669|      3|      }
  670|     11|   }
  671|       |
  672|       |   // RFC 5280 4.2.1.6: GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
  673|    244|   if(authority_cert_issuer.has_value() && authority_cert_issuer->is_empty()) {
  ------------------
  |  Branch (673:7): [True: 0, False: 244]
  |  Branch (673:44): [True: 0, False: 0]
  ------------------
  674|      0|      throw Decoding_Error("AuthorityKeyIdentifier authorityCertIssuer must contain at least one GeneralName");
  675|      0|   }
  676|       |
  677|       |   /*
  678|       |   * RFC 5280 Appendix A.2:
  679|       |   *
  680|       |   *    authorityCertIssuer and authorityCertSerialNumber MUST both be
  681|       |   *    present or both be absent
  682|       |   */
  683|    244|   if(authority_cert_issuer.has_value() != authority_cert_serial.has_value()) {
  ------------------
  |  Branch (683:7): [True: 5, False: 239]
  ------------------
  684|      5|      throw Decoding_Error(
  685|      5|         "AuthorityKeyIdentifier authorityCertIssuer and authorityCertSerialNumber must both be present or absent");
  686|      5|   }
  687|       |
  688|    239|   if(authority_cert_issuer.has_value()) {
  ------------------
  |  Branch (688:7): [True: 0, False: 239]
  ------------------
  689|      0|      m_authority_cert =
  690|      0|         Authority_Cert_Identifier{std::move(*authority_cert_issuer), std::move(*authority_cert_serial)};
  691|      0|   }
  692|    239|}
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  727|  2.06k|void Issuer_Alternative_Name::decode_inner(const std::vector<uint8_t>& in) {
  728|       |   /* RFC 5280 Section 4.2.1.7 - IssuerAltName ::= GeneralNames
  729|       |   *  GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName */
  730|  2.06k|   BER_Decoder(in, BER_Decoder::Limits::DER()).decode(m_alt_name).verify_end();
  731|  2.06k|   if(!m_alt_name.has_items()) {
  ------------------
  |  Branch (731:7): [True: 3, False: 2.05k]
  ------------------
  732|      3|      throw Decoding_Error("IssuerAlternativeName extension must contain at least one GeneralName");
  733|      3|   }
  734|  2.06k|}
_ZN5Botan14Cert_Extension28Authority_Information_Access12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1125|     92|void Authority_Information_Access::decode_inner(const std::vector<uint8_t>& in) {
 1126|       |   /*
 1127|       |   * RFC 5280 Section 4.2.2.1
 1128|       |   *
 1129|       |   * AuthorityInfoAccessSyntax ::= SEQUENCE SIZE (1..MAX) OF AccessDescription
 1130|       |   * AccessDescription ::= SEQUENCE {
 1131|       |   *    accessMethod          OBJECT IDENTIFIER,
 1132|       |   *    accessLocation        GeneralName }
 1133|       |   */
 1134|     92|   BER_Decoder outer(in, BER_Decoder::Limits::DER());
 1135|     92|   BER_Decoder ber = outer.start_sequence();
 1136|       |
 1137|     92|   const OID ocsp_responder = OID::from_string("PKIX.OCSP");
 1138|     92|   const OID ca_issuer = OID::from_string("PKIX.CertificateAuthorityIssuers");
 1139|       |
 1140|     92|   m_access_descriptions.clear();
 1141|     92|   m_ocsp_responders.clear();
 1142|     92|   m_ca_issuers.clear();
 1143|       |
 1144|    363|   while(ber.more_items()) {
  ------------------
  |  Branch (1144:10): [True: 272, False: 91]
  ------------------
 1145|    272|      OID oid;
 1146|       |
 1147|    272|      BER_Decoder info = ber.start_sequence();
 1148|       |
 1149|    272|      info.decode(oid);
 1150|    272|      const BER_Object name = info.get_next_object();
 1151|       |
 1152|       |      /* RFC 5280 4.2.2.1:
 1153|       |      *    AccessDescription  ::=  SEQUENCE {
 1154|       |      *         accessMethod          OBJECT IDENTIFIER,
 1155|       |      *         accessLocation        GeneralName  }
 1156|       |      */
 1157|    272|      if(!name.is_set()) {
  ------------------
  |  Branch (1157:10): [True: 1, False: 271]
  ------------------
 1158|      1|         throw Decoding_Error("AuthorityInformationAccess AccessDescription missing accessLocation");
 1159|      1|      }
 1160|    271|      validate_general_name_encoding(name.type_tag(), name.get_class(), name.data());
 1161|    271|      info.end_cons();
 1162|       |
 1163|    271|      m_access_descriptions.emplace_back(
 1164|    271|         oid, name.type_tag(), name.get_class(), std::vector<uint8_t>(name.data().begin(), name.data().end()));
 1165|       |
 1166|    271|      if(name.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (1166:10): [True: 83, False: 188]
  ------------------
 1167|     83|         if(oid == ocsp_responder) {
  ------------------
  |  Branch (1167:13): [True: 30, False: 53]
  ------------------
 1168|     30|            if(auto parsed = URI::from_string(ASN1::to_string(name))) {
  ------------------
  |  Branch (1168:21): [True: 30, False: 0]
  ------------------
 1169|     30|               m_ocsp_responders.push_back(std::move(*parsed));
 1170|     30|            } else {
 1171|      0|               throw Decoding_Error("Invalid URI in AuthorityInformationAccess OCSP responder");
 1172|      0|            }
 1173|     53|         } else if(oid == ca_issuer) {
  ------------------
  |  Branch (1173:20): [True: 14, False: 39]
  ------------------
 1174|     14|            if(auto parsed = URI::from_string(ASN1::to_string(name))) {
  ------------------
  |  Branch (1174:21): [True: 14, False: 0]
  ------------------
 1175|     14|               m_ca_issuers.push_back(std::move(*parsed));
 1176|     14|            } else {
 1177|      0|               throw Decoding_Error("Invalid URI in AuthorityInformationAccess CA issuers");
 1178|      0|            }
 1179|     14|         }
 1180|     83|      }
 1181|    271|   }
 1182|       |
 1183|     91|   ber.end_cons();
 1184|     91|   outer.verify_end();
 1185|       |
 1186|     91|   if(m_access_descriptions.empty()) {
  ------------------
  |  Branch (1186:7): [True: 0, False: 91]
  ------------------
 1187|      0|      throw Decoding_Error("AuthorityInformationAccess extension must contain at least one AccessDescription");
 1188|      0|   }
 1189|     91|}
_ZNK5Botan14Cert_Extension10CRL_Number10crl_numberEv:
 1195|     13|const BigInt& CRL_Number::crl_number() const {
 1196|       |   // This can only happen via a misuse of the CRL_Number default constructor
 1197|     13|   BOTAN_STATE_CHECK(m_has_value);
  ------------------
  |  |   51|     13|   do {                                                         \
  |  |   52|     13|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|     13|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 13]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|     13|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 1198|     13|   return m_crl_number;
 1199|     13|}
_ZN5Botan14Cert_Extension10CRL_Number12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1229|     51|void CRL_Number::decode_inner(const std::vector<uint8_t>& in) {
 1230|       |   /* RFC 5280 Section 5.2.3 - CRLNumber ::= INTEGER (0..MAX) */
 1231|     51|   BER_Decoder(in, BER_Decoder::Limits::DER()).decode(m_crl_number).verify_end();
 1232|     51|   if(m_crl_number.signum() < 0) {
  ------------------
  |  Branch (1232:7): [True: 9, False: 42]
  ------------------
 1233|      9|      throw Decoding_Error("CRL number cannot be negative");
 1234|      9|   }
 1235|     42|   m_has_value = true;
 1236|     42|}
_ZN5Botan14Cert_Extension14CRL_ReasonCode12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1250|  3.54k|void CRL_ReasonCode::decode_inner(const std::vector<uint8_t>& in) {
 1251|       |   /*
 1252|       |   * RFC 5280 Section 5.3.1
 1253|       |   *
 1254|       |   * CRLReason ::= ENUMERATED {
 1255|       |   *      unspecified             (0),
 1256|       |   *      keyCompromise           (1),
 1257|       |   *      cACompromise            (2),
 1258|       |   *      affiliationChanged      (3),
 1259|       |   *      superseded              (4),
 1260|       |   *      cessationOfOperation    (5),
 1261|       |   *      certificateHold         (6),
 1262|       |   *           -- value 7 is not used
 1263|       |   *      removeFromCRL           (8),
 1264|       |   *      privilegeWithdrawn      (9),
 1265|       |   *      aACompromise           (10) }
 1266|       |   */
 1267|  3.54k|   size_t reason_code = 0;
 1268|  3.54k|   BER_Decoder(in, BER_Decoder::Limits::DER())
 1269|  3.54k|      .decode(reason_code, ASN1_Type::Enumerated, ASN1_Class::Universal)
 1270|  3.54k|      .verify_end();
 1271|       |
 1272|  3.54k|   if(reason_code == 7 || reason_code > 10) {
  ------------------
  |  Branch (1272:7): [True: 2.02k, False: 1.51k]
  |  Branch (1272:27): [True: 373, False: 1.14k]
  ------------------
 1273|    406|      throw Decoding_Error(fmt("CRLReason has unknown enumeration value {}", reason_code));
 1274|    406|   }
 1275|       |
 1276|  3.13k|   m_reason = static_cast<CRL_Code>(reason_code);
 1277|  3.13k|}
_ZN5Botan14Cert_Extension21DistributionPointName11decode_fromERNS_11BER_DecoderE:
 1346|     41|void DistributionPointName::decode_from(BER_Decoder& ber) {
 1347|     41|   const BER_Object& obj = ber.peek_next_object();
 1348|     41|   if(obj.is_a(0, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (1348:7): [True: 33, False: 8]
  ------------------
 1349|     33|      AlternativeName full_name;
 1350|     33|      ber.decode_implicit(full_name,
 1351|     33|                          ASN1_Type(0),
 1352|     33|                          ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
 1353|     33|                          ASN1_Type::Sequence,
 1354|     33|                          ASN1_Class::Constructed);
 1355|       |      // RFC 5280 4.2.1.6: GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
 1356|     33|      if(!full_name.has_items()) {
  ------------------
  |  Branch (1356:10): [True: 4, False: 29]
  ------------------
 1357|      4|         throw Decoding_Error("DistributionPointName fullName must contain at least one GeneralName");
 1358|      4|      }
 1359|     29|      if(std::ranges::any_of(full_name.directory_names(), [](const X509_DN& dn) { return dn.empty(); })) {
  ------------------
  |  Branch (1359:10): [True: 3, False: 26]
  ------------------
 1360|      3|         throw Decoding_Error("DistributionPointName fullName must not contain an empty directoryName");
 1361|      3|      }
 1362|     26|      m_full_name = std::move(full_name);
 1363|     26|   } else if(obj.is_a(1, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (1363:14): [True: 4, False: 4]
  ------------------
 1364|      4|      throw Decoding_Error("nameRelativeToCrlIssuer not supported in DistributionPointName");
 1365|      4|   } else {
 1366|      4|      throw Decoding_Error("DistributionPointName CHOICE is neither fullName nor nameRelativeToCRLIssuer");
 1367|      4|   }
 1368|     41|}
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 1542|    236|void CRL_Issuing_Distribution_Point::decode_inner(const std::vector<uint8_t>& buf) {
 1543|       |   /*
 1544|       |   * RFC 5280 Section 5.2.5
 1545|       |   *
 1546|       |   * IssuingDistributionPoint ::= SEQUENCE {
 1547|       |   *      distributionPoint          [0] DistributionPointName OPTIONAL,
 1548|       |   *      onlyContainsUserCerts      [1] BOOLEAN DEFAULT FALSE,
 1549|       |   *      onlyContainsCACerts        [2] BOOLEAN DEFAULT FALSE,
 1550|       |   *      onlySomeReasons            [3] ReasonFlags OPTIONAL,
 1551|       |   *      indirectCRL                [4] BOOLEAN DEFAULT FALSE,
 1552|       |   *      onlyContainsAttributeCerts [5] BOOLEAN DEFAULT FALSE }
 1553|       |   */
 1554|    236|   BER_Decoder outer(buf, BER_Decoder::Limits::DER());
 1555|    236|   BER_Decoder seq = outer.start_sequence();
 1556|       |
 1557|    236|   m_dp_name.reset();
 1558|    236|   m_only_contains_user_certs = false;
 1559|    236|   m_only_contains_ca_certs = false;
 1560|    236|   m_only_some_reasons = {};
 1561|    236|   m_indirect_crl = false;
 1562|    236|   m_only_contains_attribute_certs = false;
 1563|       |
 1564|    236|   auto decode_implicit_bool = [&](BER_Decoder& dec, uint32_t tag) -> bool {
 1565|    236|      bool value = false;
 1566|    236|      dec.decode(value, ASN1_Type(tag), ASN1_Class::ContextSpecific);
 1567|    236|      return value;
 1568|    236|   };
 1569|       |
 1570|       |   // DER: these optional fields appear at most once and in increasing tag
 1571|       |   // order. Decoding them in tag order and then rejecting anything left over
 1572|       |   // (see end_cons below) catches out-of-order, duplicate, and unknown fields.
 1573|    236|   seq.decode_optional_field(0,
 1574|    236|                             ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
 1575|    236|                             [&](BER_Decoder& d) {
 1576|    236|                                DistributionPointName name;
 1577|    236|                                d.start_context_specific(0).decode(name).verify_end();
 1578|    236|                                m_dp_name = std::move(name);
 1579|    236|                             })
 1580|    236|      .decode_optional_field(1,
 1581|    236|                             ASN1_Class::ContextSpecific,
 1582|    236|                             [&](BER_Decoder& d) { m_only_contains_user_certs = decode_implicit_bool(d, 1); })
 1583|    236|      .decode_optional_field(
 1584|    236|         2, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) { m_only_contains_ca_certs = decode_implicit_bool(d, 2); })
 1585|    236|      .decode_optional_field(3,
 1586|    236|                             ASN1_Class::ContextSpecific,
 1587|    236|                             [&](BER_Decoder& d) { m_only_some_reasons = decode_reason_flags_implicit(d, 3); })
 1588|    236|      .decode_optional_field(
 1589|    236|         4, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) { m_indirect_crl = decode_implicit_bool(d, 4); })
 1590|    236|      .decode_optional_field(5, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) {
 1591|    236|         m_only_contains_attribute_certs = decode_implicit_bool(d, 5);
 1592|    236|      });
 1593|       |
 1594|    236|   seq.end_cons();
 1595|    236|   outer.verify_end();
 1596|       |
 1597|       |   /* RFC 5280 5.2.5: "Conforming CRLs issuers MUST NOT issue CRLs where the
 1598|       |   * DER encoding of the issuing distribution point extension is an empty
 1599|       |   * sequence." Empty here means none of the fields above were present. */
 1600|    236|   if(!m_dp_name.has_value() && !m_only_contains_user_certs && !m_only_contains_ca_certs &&
  ------------------
  |  Branch (1600:7): [True: 0, False: 236]
  |  Branch (1600:33): [True: 0, False: 0]
  |  Branch (1600:64): [True: 0, False: 0]
  ------------------
 1601|      0|      !m_only_some_reasons.has_value() && !m_indirect_crl && !m_only_contains_attribute_certs) {
  ------------------
  |  Branch (1601:7): [True: 0, False: 0]
  |  Branch (1601:43): [True: 0, False: 0]
  |  Branch (1601:62): [True: 0, False: 0]
  ------------------
 1602|      0|      throw Decoding_Error("IssuingDistributionPoint must contain at least one field");
 1603|      0|   }
 1604|       |
 1605|       |   /* RFC 5280 5.2.5: "at most one of onlyContainsUserCerts,
 1606|       |   * onlyContainsCACerts, and onlyContainsAttributeCerts may be set to TRUE." */
 1607|    236|   const size_t scope_set = static_cast<size_t>(m_only_contains_user_certs) +
 1608|    236|                            static_cast<size_t>(m_only_contains_ca_certs) +
 1609|    236|                            static_cast<size_t>(m_only_contains_attribute_certs);
 1610|    236|   if(scope_set > 1) {
  ------------------
  |  Branch (1610:7): [True: 0, False: 236]
  ------------------
 1611|      0|      throw Decoding_Error(
 1612|      0|         "IssuingDistributionPoint sets more than one of onlyContainsUserCerts/CACerts/AttributeCerts");
 1613|      0|   }
 1614|    236|}
_ZN5Botan14Cert_Extension17Unknown_Extension12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
 3008|  12.5k|void Unknown_Extension::decode_inner(const std::vector<uint8_t>& bytes) {
 3009|       |   // Just treat as an opaque blob at this level
 3010|  12.5k|   m_bytes = bytes;
 3011|  12.5k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_118extension_from_oidERKNS_3OIDE:
   60|  13.8k|std::unique_ptr<Certificate_Extension> extension_from_oid(const OID& oid) {
   61|  13.8k|   if(auto iso_ext = is_sub_element_of(oid, {2, 5, 29})) {
  ------------------
  |  Branch (61:12): [True: 10.0k, False: 3.78k]
  ------------------
   62|       |      // NOLINTNEXTLINE(*-switch-missing-default-case)
   63|  10.0k|      switch(*iso_ext) {
  ------------------
  |  Branch (63:14): [True: 6.15k, False: 3.92k]
  ------------------
   64|      2|         case 14:
  ------------------
  |  Branch (64:10): [True: 2, False: 10.0k]
  ------------------
   65|      2|            return make_extension<Cert_Extension::Subject_Key_ID>(oid);
   66|      1|         case 15:
  ------------------
  |  Branch (66:10): [True: 1, False: 10.0k]
  ------------------
   67|      1|            return make_extension<Cert_Extension::Key_Usage>(oid);
   68|      1|         case 17:
  ------------------
  |  Branch (68:10): [True: 1, False: 10.0k]
  ------------------
   69|      1|            return make_extension<Cert_Extension::Subject_Alternative_Name>(oid);
   70|  2.06k|         case 18:
  ------------------
  |  Branch (70:10): [True: 2.06k, False: 8.02k]
  ------------------
   71|  2.06k|            return make_extension<Cert_Extension::Issuer_Alternative_Name>(oid);
   72|      1|         case 19:
  ------------------
  |  Branch (72:10): [True: 1, False: 10.0k]
  ------------------
   73|      1|            return make_extension<Cert_Extension::Basic_Constraints>(oid);
   74|     52|         case 20:
  ------------------
  |  Branch (74:10): [True: 52, False: 10.0k]
  ------------------
   75|     52|            return make_extension<Cert_Extension::CRL_Number>(oid);
   76|  3.54k|         case 21:
  ------------------
  |  Branch (76:10): [True: 3.54k, False: 6.53k]
  ------------------
   77|  3.54k|            return make_extension<Cert_Extension::CRL_ReasonCode>(oid);
   78|    237|         case 28:
  ------------------
  |  Branch (78:10): [True: 237, False: 9.84k]
  ------------------
   79|    237|            return make_extension<Cert_Extension::CRL_Issuing_Distribution_Point>(oid);
   80|      1|         case 30:
  ------------------
  |  Branch (80:10): [True: 1, False: 10.0k]
  ------------------
   81|      1|            return make_extension<Cert_Extension::Name_Constraints>(oid);
   82|      2|         case 31:
  ------------------
  |  Branch (82:10): [True: 2, False: 10.0k]
  ------------------
   83|      2|            return make_extension<Cert_Extension::CRL_Distribution_Points>(oid);
   84|      3|         case 32:
  ------------------
  |  Branch (84:10): [True: 3, False: 10.0k]
  ------------------
   85|      3|            return make_extension<Cert_Extension::Certificate_Policies>(oid);
   86|    248|         case 35:
  ------------------
  |  Branch (86:10): [True: 248, False: 9.83k]
  ------------------
   87|    248|            return make_extension<Cert_Extension::Authority_Key_ID>(oid);
   88|      1|         case 37:
  ------------------
  |  Branch (88:10): [True: 1, False: 10.0k]
  ------------------
   89|      1|            return make_extension<Cert_Extension::Extended_Key_Usage>(oid);
   90|      1|         case 56:
  ------------------
  |  Branch (90:10): [True: 1, False: 10.0k]
  ------------------
   91|      1|            return make_extension<Cert_Extension::NoRevocationAvailable>(oid);
   92|  10.0k|      }
   93|  10.0k|   }
   94|       |
   95|  7.70k|   if(auto pkix_ext = is_sub_element_of(oid, {1, 3, 6, 1, 5, 5, 7, 1})) {
  ------------------
  |  Branch (95:12): [True: 96, False: 7.61k]
  ------------------
   96|       |      // NOLINTNEXTLINE(*-switch-missing-default-case)
   97|     96|      switch(*pkix_ext) {
  ------------------
  |  Branch (97:14): [True: 95, False: 1]
  ------------------
   98|     92|         case 1:
  ------------------
  |  Branch (98:10): [True: 92, False: 4]
  ------------------
   99|     92|            return make_extension<Cert_Extension::Authority_Information_Access>(oid);
  100|      1|         case 7:
  ------------------
  |  Branch (100:10): [True: 1, False: 95]
  ------------------
  101|      1|            return make_extension<Cert_Extension::IPAddressBlocks>(oid);
  102|      1|         case 8:
  ------------------
  |  Branch (102:10): [True: 1, False: 95]
  ------------------
  103|      1|            return make_extension<Cert_Extension::ASBlocks>(oid);
  104|      1|         case 26:
  ------------------
  |  Branch (104:10): [True: 1, False: 95]
  ------------------
  105|      1|            return make_extension<Cert_Extension::TNAuthList>(oid);
  106|     96|      }
  107|     96|   }
  108|       |
  109|  7.61k|   if(oid == Cert_Extension::OCSP_NoCheck::static_oid()) {
  ------------------
  |  Branch (109:7): [True: 0, False: 7.61k]
  ------------------
  110|      0|      return make_extension<Cert_Extension::OCSP_NoCheck>(oid);
  111|      0|   }
  112|       |
  113|  7.61k|   return nullptr;  // unknown
  114|  7.61k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension14Subject_Key_IDEEEDaRKNS_3OIDE:
   55|      2|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      2|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      2|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      2|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 2]
  |  |  ------------------
  ------------------
   57|      2|   return std::make_unique<T>();
   58|      2|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension9Key_UsageEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension24Subject_Alternative_NameEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension23Issuer_Alternative_NameEEEDaRKNS_3OIDE:
   55|  2.06k|auto make_extension([[maybe_unused]] const OID& oid) {
   56|  2.06k|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|  2.06k|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|  2.06k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 2.06k]
  |  |  ------------------
  ------------------
   57|  2.06k|   return std::make_unique<T>();
   58|  2.06k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension17Basic_ConstraintsEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension10CRL_NumberEEEDaRKNS_3OIDE:
   55|     52|auto make_extension([[maybe_unused]] const OID& oid) {
   56|     52|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|     52|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|     52|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 52]
  |  |  ------------------
  ------------------
   57|     52|   return std::make_unique<T>();
   58|     52|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension14CRL_ReasonCodeEEEDaRKNS_3OIDE:
   55|  3.54k|auto make_extension([[maybe_unused]] const OID& oid) {
   56|  3.54k|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|  3.54k|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|  3.54k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 3.54k]
  |  |  ------------------
  ------------------
   57|  3.54k|   return std::make_unique<T>();
   58|  3.54k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension30CRL_Issuing_Distribution_PointEEEDaRKNS_3OIDE:
   55|    237|auto make_extension([[maybe_unused]] const OID& oid) {
   56|    237|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|    237|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|    237|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 237]
  |  |  ------------------
  ------------------
   57|    237|   return std::make_unique<T>();
   58|    237|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension16Name_ConstraintsEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension23CRL_Distribution_PointsEEEDaRKNS_3OIDE:
   55|      2|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      2|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      2|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      2|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 2]
  |  |  ------------------
  ------------------
   57|      2|   return std::make_unique<T>();
   58|      2|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension20Certificate_PoliciesEEEDaRKNS_3OIDE:
   55|      3|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      3|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      3|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      3|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 3]
  |  |  ------------------
  ------------------
   57|      3|   return std::make_unique<T>();
   58|      3|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension16Authority_Key_IDEEEDaRKNS_3OIDE:
   55|    248|auto make_extension([[maybe_unused]] const OID& oid) {
   56|    248|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|    248|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|    248|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 248]
  |  |  ------------------
  ------------------
   57|    248|   return std::make_unique<T>();
   58|    248|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension18Extended_Key_UsageEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension21NoRevocationAvailableEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension28Authority_Information_AccessEEEDaRKNS_3OIDE:
   55|     92|auto make_extension([[maybe_unused]] const OID& oid) {
   56|     92|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|     92|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|     92|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 92]
  |  |  ------------------
  ------------------
   57|     92|   return std::make_unique<T>();
   58|     92|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension15IPAddressBlocksEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension8ASBlocksEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_114make_extensionITkNSt3__112derived_fromINS_21Certificate_ExtensionEEENS_14Cert_Extension10TNAuthListEEEDaRKNS_3OIDE:
   55|      1|auto make_extension([[maybe_unused]] const OID& oid) {
   56|      1|   BOTAN_DEBUG_ASSERT(oid == T::static_oid());
  ------------------
  |  |  137|      1|      do { /* NOLINT(*-avoid-do-while) */ \
  |  |  138|      1|      } while(0)
  |  |  ------------------
  |  |  |  Branch (138:15): [Folded, False: 1]
  |  |  ------------------
  ------------------
   57|      1|   return std::make_unique<T>();
   58|      1|}
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_130validate_general_name_encodingENS_9ASN1_TypeENS_10ASN1_ClassENSt3__14spanIKhLm18446744073709551615EEE:
 1014|    243|void validate_general_name_encoding(ASN1_Type tag, ASN1_Class cls, std::span<const uint8_t> value) {
 1015|       |   // AlternativeName decodes GeneralNames; AIA accessLocation is a single GeneralName.
 1016|    243|   std::vector<uint8_t> wrapped_name;
 1017|    243|   DER_Encoder(wrapped_name).start_sequence().add_object(tag, cls, value).end_cons();
 1018|       |
 1019|    243|   AlternativeName decoded_name;
 1020|    243|   BER_Decoder(wrapped_name, BER_Decoder::Limits::DER()).decode(decoded_name).verify_end();
 1021|       |
 1022|    243|   if((tag == ASN1_Type(1) || tag == ASN1_Type(2) || tag == ASN1_Type(6)) && value.empty()) {
  ------------------
  |  Branch (1022:8): [True: 63, False: 180]
  |  Branch (1022:31): [True: 10, False: 170]
  |  Branch (1022:54): [True: 86, False: 84]
  |  Branch (1022:78): [True: 3, False: 105]
  ------------------
 1023|      3|      throw Decoding_Error("GeneralName IA5String value must not be empty");
 1024|      3|   }
 1025|    240|   if(tag == ASN1_Type(4) &&
  ------------------
  |  Branch (1025:7): [True: 4, False: 236]
  ------------------
 1026|      4|      std::ranges::any_of(decoded_name.directory_names(), [](const X509_DN& dn) { return dn.empty(); })) {
  ------------------
  |  Branch (1026:7): [True: 1, False: 3]
  ------------------
 1027|      1|      throw Decoding_Error("GeneralName directoryName must not be empty");
 1028|      1|   }
 1029|    240|}
x509_ext.cpp:_ZZN5Botan14Cert_Extension12_GLOBAL__N_130validate_general_name_encodingENS_9ASN1_TypeENS_10ASN1_ClassENSt3__14spanIKhLm18446744073709551615EEEENK3$_0clERKNS_7X509_DNE:
 1026|      4|      std::ranges::any_of(decoded_name.directory_names(), [](const X509_DN& dn) { return dn.empty(); })) {
x509_ext.cpp:_ZZN5Botan14Cert_Extension21DistributionPointName11decode_fromERNS_11BER_DecoderEENK3$_0clERKNS_7X509_DNE:
 1359|      3|      if(std::ranges::any_of(full_name.directory_names(), [](const X509_DN& dn) { return dn.empty(); })) {
x509_ext.cpp:_ZZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_0clERNS_11BER_DecoderE:
  636|     16|                             [&](BER_Decoder& d) {
  637|     16|                                d.decode(m_key_id, ASN1_Type::OctetString, ASN1_Type(0), ASN1_Class::ContextSpecific);
  638|     16|                                key_id_present = true;
  639|     16|                             })
x509_ext.cpp:_ZZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_1clERNS_11BER_DecoderE:
  642|      6|                             [&](BER_Decoder& d) {
  643|      6|                                AlternativeName names;
  644|      6|                                d.decode_implicit(names,
  645|      6|                                                  ASN1_Type(1),
  646|      6|                                                  ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
  647|      6|                                                  ASN1_Type::Sequence,
  648|      6|                                                  ASN1_Class::Constructed);
  649|      6|                                authority_cert_issuer = std::move(names);
  650|      6|                             })
x509_ext.cpp:_ZZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_2clERNS_11BER_DecoderE:
  651|     14|      .decode_optional_field(2, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) {
  652|     14|         X509_Serial_Number serial;
  653|     14|         d.decode_implicit(
  654|     14|            serial, ASN1_Type(2), ASN1_Class::ContextSpecific, ASN1_Type::Integer, ASN1_Class::Universal);
  655|     14|         authority_cert_serial = std::move(serial);
  656|     14|      });
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_128decode_reason_flags_implicitERNS_11BER_DecoderEj:
 1287|     46|ReasonFlags decode_reason_flags_implicit(BER_Decoder& decoder, uint32_t tag) {
 1288|     46|   uint64_t bits = 0;
 1289|     46|   decoder.decode_named_bitstring(bits, ReasonFlagsNamedBitWidth, ASN1_Type(tag), ASN1_Class::ContextSpecific);
 1290|     46|   return ReasonFlags(checked_cast_to<uint16_t>(bits));
 1291|     46|}
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_1clERNS_11BER_DecoderE:
 1575|     41|                             [&](BER_Decoder& d) {
 1576|     41|                                DistributionPointName name;
 1577|     41|                                d.start_context_specific(0).decode(name).verify_end();
 1578|     41|                                m_dp_name = std::move(name);
 1579|     41|                             })
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_2clERNS_11BER_DecoderE:
 1582|     21|                             [&](BER_Decoder& d) { m_only_contains_user_certs = decode_implicit_bool(d, 1); })
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_0clERNS_11BER_DecoderEj:
 1564|     45|   auto decode_implicit_bool = [&](BER_Decoder& dec, uint32_t tag) -> bool {
 1565|     45|      bool value = false;
 1566|     45|      dec.decode(value, ASN1_Type(tag), ASN1_Class::ContextSpecific);
 1567|     45|      return value;
 1568|     45|   };
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_3clERNS_11BER_DecoderE:
 1584|     14|         2, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) { m_only_contains_ca_certs = decode_implicit_bool(d, 2); })
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_4clERNS_11BER_DecoderE:
 1587|     46|                             [&](BER_Decoder& d) { m_only_some_reasons = decode_reason_flags_implicit(d, 3); })
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_5clERNS_11BER_DecoderE:
 1589|      6|         4, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) { m_indirect_crl = decode_implicit_bool(d, 4); })
x509_ext.cpp:_ZZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEEENK3$_6clERNS_11BER_DecoderE:
 1590|      4|      .decode_optional_field(5, ASN1_Class::ContextSpecific, [&](BER_Decoder& d) {
 1591|      4|         m_only_contains_attribute_certs = decode_implicit_bool(d, 5);
 1592|      4|      });

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

_ZN5Botan18X509_Serial_NumberC2ERKNS_6BigIntE:
   20|  8.76k|X509_Serial_Number::X509_Serial_Number(const BigInt& value) : m_contents(ASN1::integer_contents(value)) {}
_ZNK5Botan18X509_Serial_Number11is_negativeEv:
   65|  57.5k|bool X509_Serial_Number::is_negative() const {
   66|  57.5k|   BOTAN_STATE_CHECK(!m_contents.empty());
  ------------------
  |  |   51|  57.5k|   do {                                                         \
  |  |   52|  57.5k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|  57.5k|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 57.5k]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|  57.5k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 57.5k]
  |  |  ------------------
  ------------------
   67|  57.5k|   return (m_contents[0] & 0x80) == 0x80;
   68|  57.5k|}
_ZNK5Botan18X509_Serial_Number7is_zeroEv:
   70|  8.59k|bool X509_Serial_Number::is_zero() const {
   71|  8.59k|   return m_contents.size() == 1 && m_contents[0] == 0x00;
  ------------------
  |  Branch (71:11): [True: 2.07k, False: 6.51k]
  |  Branch (71:37): [True: 327, False: 1.74k]
  ------------------
   72|  8.59k|}
_ZNK5Botan18X509_Serial_Number9magnitudeEv:
   74|  8.59k|std::vector<uint8_t> X509_Serial_Number::magnitude() const {
   75|  8.59k|   BOTAN_STATE_CHECK(!m_contents.empty());
  ------------------
  |  |   51|  8.59k|   do {                                                         \
  |  |   52|  8.59k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|  8.59k|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 8.59k]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|  8.59k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 8.59k]
  |  |  ------------------
  ------------------
   76|       |
   77|  8.59k|   if(is_zero()) {
  ------------------
  |  Branch (77:7): [True: 327, False: 8.26k]
  ------------------
   78|    327|      return {};
   79|  8.26k|   } else if(is_negative()) {
  ------------------
  |  Branch (79:14): [True: 904, False: 7.36k]
  ------------------
   80|    904|      return to_bigint().serialize();
   81|  7.36k|   } else if(m_contents[0] == 0x00) {
  ------------------
  |  Branch (81:14): [True: 239, False: 7.12k]
  ------------------
   82|       |      // Positive value whose leading magnitude bit is set; skip the sign octet
   83|    239|      return {m_contents.begin() + 1, m_contents.end()};
   84|  7.12k|   } else {
   85|  7.12k|      return m_contents;
   86|  7.12k|   }
   87|  8.59k|}
_ZNK5Botan18X509_Serial_Number9to_bigintEv:
   89|    904|BigInt X509_Serial_Number::to_bigint() const {
   90|    904|   BOTAN_STATE_CHECK(!m_contents.empty());
  ------------------
  |  |   51|    904|   do {                                                         \
  |  |   52|    904|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|    904|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 904]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|    904|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 904]
  |  |  ------------------
  ------------------
   91|    904|   return ASN1::integer_from_contents(m_contents);
   92|    904|}
_ZN5Botan18X509_Serial_Number11decode_fromERNS_11BER_DecoderE:
  108|  8.78k|void X509_Serial_Number::decode_from(BER_Decoder& from) {
  109|       |   // Decode via BigInt so the decoder's limits apply, in particular the
  110|       |   // rejection of non-minimal INTEGER encodings in DER mode
  111|  8.78k|   BigInt value;
  112|  8.78k|   from.decode(value);
  113|  8.78k|   *this = X509_Serial_Number(value);
  114|  8.78k|}
_ZNK5Botan18X509_Serial_NumberssERKS0_:
  116|  24.6k|std::strong_ordering X509_Serial_Number::operator<=>(const X509_Serial_Number& other) const {
  117|  24.6k|   BOTAN_STATE_CHECK(!m_contents.empty());
  ------------------
  |  |   51|  24.6k|   do {                                                         \
  |  |   52|  24.6k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */             \
  |  |   53|  24.6k|      if(!(expr)) {                                             \
  |  |  ------------------
  |  |  |  Branch (53:10): [True: 0, False: 24.6k]
  |  |  ------------------
  |  |   54|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */    \
  |  |   55|      0|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   56|      0|      }                                                         \
  |  |   57|  24.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (57:12): [Folded, False: 24.6k]
  |  |  ------------------
  ------------------
  118|       |
  119|  24.6k|   const bool neg = is_negative();
  120|       |
  121|  24.6k|   if(neg != other.is_negative()) {
  ------------------
  |  Branch (121:7): [True: 926, False: 23.7k]
  ------------------
  122|    926|      return neg ? std::strong_ordering::less : std::strong_ordering::greater;
  ------------------
  |  Branch (122:14): [True: 718, False: 208]
  ------------------
  123|    926|   }
  124|       |
  125|       |   // Same sign: for positive values the longer encoding is the larger value,
  126|       |   // for negative values the longer encoding is the smaller (more negative)
  127|  23.7k|   if(m_contents.size() != other.m_contents.size()) {
  ------------------
  |  Branch (127:7): [True: 796, False: 22.9k]
  ------------------
  128|    796|      const bool shorter = m_contents.size() < other.m_contents.size();
  129|    796|      return (shorter != neg) ? std::strong_ordering::less : std::strong_ordering::greater;
  ------------------
  |  Branch (129:14): [True: 610, False: 186]
  ------------------
  130|    796|   }
  131|       |
  132|       |   /*
  133|       |   * When comparing two values of the same sign in two's complement
  134|       |   * encoding, the lexicographic ordering is correct for both signs,
  135|       |   * for instance -2 (0xFE) is less than -1 (0xFF)
  136|       |   */
  137|  22.9k|   const int cmp = std::memcmp(m_contents.data(), other.m_contents.data(), m_contents.size());
  138|  22.9k|   if(cmp < 0) {
  ------------------
  |  Branch (138:7): [True: 13.3k, False: 9.63k]
  ------------------
  139|  13.3k|      return std::strong_ordering::less;
  140|  13.3k|   } else if(cmp > 0) {
  ------------------
  |  Branch (140:14): [True: 7.67k, False: 1.95k]
  ------------------
  141|  7.67k|      return std::strong_ordering::greater;
  142|  7.67k|   } else {
  143|  1.95k|      return std::strong_ordering::equal;
  144|  1.95k|   }
  145|  22.9k|}