_ZN5Botan17ct_expand_top_bitITkNSt3__117unsigned_integralEmEET_S2_:
   28|  23.2k|BOTAN_FORCE_INLINE constexpr T ct_expand_top_bit(T a) {
   29|  23.2k|   const T top = CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1));
   30|  23.2k|   return static_cast<T>(0) - top;
   31|  23.2k|}
_ZN5Botan6chooseITkNSt3__117unsigned_integralEmEET_S2_S2_S2_:
  217|  19.0k|BOTAN_FORCE_INLINE constexpr T choose(T mask, T a, T b) {
  218|       |   //return (mask & a) | (~mask & b);
  219|  19.0k|   return (b ^ (mask & (a ^ b)));
  220|  19.0k|}
_ZN5Botan10ct_is_zeroITkNSt3__117unsigned_integralEmEET_S2_:
   37|  23.2k|BOTAN_FORCE_INLINE constexpr T ct_is_zero(T x) {
   38|  23.2k|   return ct_expand_top_bit<T>(~x & (x - 1));
   39|  23.2k|}
_ZN5Botan13ceil_divisionITkNSt3__117unsigned_integralEmEET_S2_S2_:
  167|    296|BOTAN_FORCE_INLINE constexpr T ceil_division(T a, T b) {
  168|       |   // Same as `(a + b - 1) / b` but avoids possible overflow
  169|    296|   return a / b + ((a % b != 0) ? 1 : 0);
  ------------------
  |  Branch (169:20): [True: 267, False: 29]
  ------------------
  170|    296|}
_ZN5Botan10ct_is_zeroITkNSt3__117unsigned_integralEhEET_S2_:
   37|    296|BOTAN_FORCE_INLINE constexpr T ct_is_zero(T x) {
   38|    296|   return ct_expand_top_bit<T>(~x & (x - 1));
   39|    296|}
_ZN5Botan17ct_expand_top_bitITkNSt3__117unsigned_integralEhEET_S2_:
   28|    296|BOTAN_FORCE_INLINE constexpr T ct_expand_top_bit(T a) {
   29|    296|   const T top = CT::value_barrier<T>(a >> (sizeof(T) * 8 - 1));
   30|    296|   return static_cast<T>(0) - top;
   31|    296|}
_ZN5Botan6chooseITkNSt3__117unsigned_integralEhEET_S2_S2_S2_:
  217|    296|BOTAN_FORCE_INLINE constexpr T choose(T mask, T a, T b) {
  218|       |   //return (mask & a) | (~mask & b);
  219|    296|   return (b ^ (mask & (a ^ b)));
  220|    296|}

_ZN5Botan13reverse_bytesITkNSt3__117unsigned_integralEmQooooooeqstT_Li1EeqstS2_Li2EeqstS2_Li4EeqstS2_Li8EEES2_S2_:
   25|  9.23k|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|  9.23k|   } else if constexpr(sizeof(T) == 8) {
   43|  9.23k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   44|  9.23k|      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|  9.23k|   }
   55|  9.23k|}

_ZN5Botan5CPUID3hasENS_10CPUFeatureES1_:
   98|     59|      static bool has(CPUID::Feature feat1, CPUID::Feature feat2) {
   99|     59|         return state().has_bit(feat1.as_u32() | feat2.as_u32());
  100|     59|      }
_ZN5Botan5CPUID5stateEv:
  155|     59|      static CPUID_Data& state() {
  156|     59|         static CPUID::CPUID_Data g_cpuid;
  157|     59|         return g_cpuid;
  158|     59|      }
_ZNK5Botan5CPUID10CPUID_Data7has_bitEj:
  143|     59|            bool has_bit(uint32_t bit) const { return (m_processor_features & bit) == bit; }
_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|    135|      uint32_t as_u32() const { return static_cast<uint32_t>(m_bit); }
_ZN5Botan10CPUFeatureC2ENS0_3BitE:
   54|    141|      CPUFeature(Bit b) : m_bit(b) {}  // NOLINT(*-explicit-conversions,*-explicit-constructor)

_ZN5Botan2CT4MaskImEC2Em:
  637|  3.80k|      constexpr explicit Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskImE5valueEv:
  630|  4.69k|      constexpr T value() const { return value_barrier<T>(m_mask); }
_ZN5Botan2CT4MaskImE7is_zeroEm:
  437|  1.60k|      static constexpr Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(value_barrier<T>(x))); }
_ZN5Botan2CT8unpoisonITkNSt3__18integralEmEEvRKT_:
  112|    888|constexpr void unpoison(const T& p) {
  113|    888|   unpoison(&p, 1);
  114|    888|}
_ZN5Botan2CT8unpoisonImEEvPKT_m:
   67|  1.77k|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|  1.77k|   BOTAN_UNUSED(p, n);
  ------------------
  |  |  151|  1.77k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   75|  1.77k|}
_ZNK5Botan2CT4MaskImEcoEv:
  533|  1.90k|      constexpr Mask<T> operator~() const { return Mask<T>(~value()); }
_ZN5Botan2CT4MaskImE6expandEm:
  392|  1.31k|      static constexpr Mask<T> expand(T v) { return ~Mask<T>::is_zero(value_barrier<T>(v)); }
_ZNK5Botan2CT4MaskImE16unpoisoned_valueEv:
  598|    296|      constexpr T unpoisoned_value() const {
  599|    296|         T r = value();
  600|    296|         CT::unpoison(r);
  601|    296|         return r;
  602|    296|      }
_ZNK5Botan2CT4MaskImE7as_boolEv:
  614|    296|      constexpr bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskImE8select_nEPmPKmS5_m:
  565|    716|      constexpr void select_n(T output[], const T x[], const T y[], size_t len) const {
  566|    716|         const T mask = value();
  567|  19.7k|         for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (567:28): [True: 19.0k, False: 716]
  ------------------
  568|  19.0k|            output[i] = choose(mask, x[i], y[i]);
  569|  19.0k|         }
  570|    716|      }
_ZN5Botan2CT4MaskIhE11expand_boolEb:
  397|    296|      static constexpr Mask<T> expand_bool(bool v) { return Mask<T>::expand(static_cast<T>(v)); }
_ZN5Botan2CT4MaskIhE6expandEh:
  392|    296|      static constexpr Mask<T> expand(T v) { return ~Mask<T>::is_zero(value_barrier<T>(v)); }
_ZN5Botan2CT4MaskIhE7is_zeroEh:
  437|    296|      static constexpr Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(value_barrier<T>(x))); }
_ZN5Botan2CT4MaskIhEC2Eh:
  637|    592|      constexpr explicit Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskIhEcoEv:
  533|    296|      constexpr Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskIhE5valueEv:
  630|    592|      constexpr T value() const { return value_barrier<T>(m_mask); }
_ZNK5Botan2CT4MaskIhE6selectEhh:
  548|    296|      constexpr T select(T x, T y) const { return choose(value(), x, y); }
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES3_PS3_PKS3_S7_m:
  738|    716|constexpr inline Mask<T> conditional_copy_mem(T cnd, T* dest, const T* if_set, const T* if_unset, size_t elems) {
  739|    716|   const auto mask = CT::Mask<T>::expand(cnd);
  740|    716|   return CT::conditional_copy_mem(mask, dest, if_set, if_unset, elems);
  741|    716|}
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES4_PS3_PKS3_S7_m:
  732|    716|constexpr inline Mask<T> conditional_copy_mem(Mask<T> mask, T* dest, const T* if_set, const T* if_unset, size_t elems) {
  733|    716|   mask.select_n(dest, if_set, if_unset, elems);
  734|    716|   return mask;
  735|    716|}
_ZN5Botan2CTeoENS0_4MaskImEES2_:
  523|    297|      friend constexpr Mask<T> operator^(Mask<T> x, Mask<T> y) { return Mask<T>(x.value() ^ y.value()); }

_ZN5Botan11checked_mulITkNSt3__117unsigned_integralEmEENS1_8optionalIT_EES3_S3_:
   46|  1.64k|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|  1.64k|   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|  1.64k|   if(a != 0 && r / a != b) {
  ------------------
  |  Branch (53:7): [True: 1.64k, False: 0]
  |  Branch (53:17): [True: 0, False: 1.64k]
  ------------------
   54|      0|      return {};
   55|      0|   }
   56|  1.64k|   return r;
   57|  1.64k|}

_ZN5Botan7load_beImJNSt3__14spanIKhLm8EEEEEEDaDpOT0_:
  504|  9.01k|inline constexpr auto load_be(ParamTs&&... params) {
  505|  9.01k|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|  9.01k|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|  9.01k|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|  9.01k|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|  9.01k|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|  9.01k|   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|  9.01k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|  9.01k|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  9.01k|      } else {
  289|  9.01k|         const std::span in{in_range};
  290|  9.01k|         if constexpr(sizeof(OutT) == 1) {
  291|  9.01k|            return static_cast<OutT>(in[0]);
  292|  9.01k|         } else if constexpr(endianness == std::endian::native) {
  293|  9.01k|            return typecast_copy<OutT>(in);
  294|  9.01k|         } else {
  295|  9.01k|            static_assert(opposite(endianness) == std::endian::native);
  296|  9.01k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  9.01k|         }
  298|  9.01k|      }
  299|  9.01k|   }());
  300|  9.01k|}
_ZN5Botan6detail24wrap_strong_type_or_enumITkNS0_20unsigned_integralishEmTkNSt3__117unsigned_integralEmEEDaT0_:
  200|  9.23k|constexpr auto wrap_strong_type_or_enum(T t) {
  201|       |   if constexpr(std::is_enum_v<OutT>) {
  202|       |      return static_cast<OutT>(t);
  203|  9.23k|   } else {
  204|  9.23k|      return Botan::wrap_strong_type<OutT>(t);
  205|  9.23k|   }
  206|  9.23k|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEENS2_4spanIKhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|  9.01k|   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|  9.01k|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 9.01k]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|  9.01k|      } else {
  289|  9.01k|         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|  9.01k|         } else {
  295|  9.01k|            static_assert(opposite(endianness) == std::endian::native);
  296|  9.01k|            return reverse_bytes(typecast_copy<OutT>(in));
  297|  9.01k|         }
  298|  9.01k|      }
  299|  9.01k|   }());
_ZN5Botan7load_beImJRNSt3__15arrayIhLm8EEEEEEDaDpOT0_:
  504|    225|inline constexpr auto load_be(ParamTs&&... params) {
  505|    225|   return detail::load_any<std::endian::big, OutT>(std::forward<ParamTs>(params)...);
  506|    225|}
_ZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_:
  278|    225|inline constexpr WrappedOutT load_any(InR&& in_range) {
  279|    225|   using OutT = detail::wrapped_type<WrappedOutT>;
  280|    225|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  281|       |
  282|    225|   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|    225|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  287|    225|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|    225|      } else {
  289|    225|         const std::span in{in_range};
  290|    225|         if constexpr(sizeof(OutT) == 1) {
  291|    225|            return static_cast<OutT>(in[0]);
  292|    225|         } else if constexpr(endianness == std::endian::native) {
  293|    225|            return typecast_copy<OutT>(in);
  294|    225|         } else {
  295|    225|            static_assert(opposite(endianness) == std::endian::native);
  296|    225|            return reverse_bytes(typecast_copy<OutT>(in));
  297|    225|         }
  298|    225|      }
  299|    225|   }());
  300|    225|}
_ZZN5Botan6detail8load_anyILNSt3__16endianE64206ETkNS0_20unsigned_integralishEmTkNS_6ranges16contiguous_rangeIhEERNS2_5arrayIhLm8EEEQnt15custom_loadableINS0_19wrapped_type_helperIu14__remove_cvrefIT0_EE4typeEEEESA_OT1_ENKUlvE_clEv:
  282|    225|   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|    225|      if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (286:10): [Folded, False: 225]
  ------------------
  287|      0|         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  288|    225|      } else {
  289|    225|         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|    225|         } else {
  295|    225|            static_assert(opposite(endianness) == std::endian::native);
  296|    225|            return reverse_bytes(typecast_copy<OutT>(in));
  297|    225|         }
  298|    225|      }
  299|    225|   }());

_ZN5Botan14zeroize_bufferITkNSt3__117unsigned_integralEmEEvPT_m:
   37|  1.81k|inline void zeroize_buffer(T buf[], size_t n) {
   38|  1.81k|   if(n > 0) {
  ------------------
  |  Branch (38:7): [True: 1.80k, False: 8]
  ------------------
   39|  1.80k|      std::memset(buf, 0, sizeof(T) * n);
   40|  1.80k|   }
   41|  1.81k|}

_ZN5Botan10word8_add3ITkNS_8WordTypeEmEET_PS1_PKS1_S4_S1_:
  304|  2.70k|inline constexpr auto word8_add3(W z[8], const W x[8], const W y[8], W carry) -> W {
  305|  2.70k|#if defined(BOTAN_MP_USE_X86_64_ASM)
  306|  2.70k|   if constexpr(std::same_as<W, uint64_t>) {
  307|  2.70k|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (307:10): [True: 2.70k, Folded]
  ------------------
  308|  2.70k|         asm volatile(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcq"))
  309|  2.70k|                      : [carry] "=r"(carry)
  310|  2.70k|                      : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  311|  2.70k|                      : "cc", "memory");
  312|  2.70k|         return carry;
  313|  2.70k|      }
  314|  2.70k|   }
  315|      0|#endif
  316|       |
  317|      0|   z[0] = word_add(x[0], y[0], &carry);
  318|  2.70k|   z[1] = word_add(x[1], y[1], &carry);
  319|  2.70k|   z[2] = word_add(x[2], y[2], &carry);
  320|  2.70k|   z[3] = word_add(x[3], y[3], &carry);
  321|  2.70k|   z[4] = word_add(x[4], y[4], &carry);
  322|  2.70k|   z[5] = word_add(x[5], y[5], &carry);
  323|  2.70k|   z[6] = word_add(x[6], y[6], &carry);
  324|  2.70k|   z[7] = word_add(x[7], y[7], &carry);
  325|  2.70k|   return carry;
  326|  2.70k|}
_ZN5Botan8word_addITkNS_8WordTypeEmEET_S1_S1_PS1_:
  239|  47.1k|inline constexpr auto word_add(W x, W y, W* carry) -> W {
  240|  47.1k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_addc)
  241|  47.1k|   if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (241:7): [True: 47.1k, Folded]
  ------------------
  242|       |      if constexpr(std::same_as<W, unsigned int>) {
  243|       |         return __builtin_addc(x, y, *carry & 1, carry);
  244|  47.1k|      } else if constexpr(std::same_as<W, unsigned long>) {
  245|  47.1k|         return __builtin_addcl(x, y, *carry & 1, carry);
  246|       |      } else if constexpr(std::same_as<W, unsigned long long>) {
  247|       |         return __builtin_addcll(x, y, *carry & 1, carry);
  248|       |      }
  249|  47.1k|   }
  250|      0|#endif
  251|       |
  252|       |   if constexpr(WordInfo<W>::dword_is_native && use_dword_for_word_add) {
  253|       |      /*
  254|       |      TODO(Botan4) this is largely a performance hack for GCCs that don't
  255|       |      support __builtin_addc, if we increase the minimum supported version of
  256|       |      GCC to GCC 14 then we can remove this and not worry about it
  257|       |      */
  258|       |      const W cb = *carry & 1;
  259|       |      const auto s = typename WordInfo<W>::dword(x) + y + cb;
  260|       |      *carry = static_cast<W>(s >> WordInfo<W>::bits);
  261|       |      return static_cast<W>(s);
  262|  47.1k|   } else {
  263|  47.1k|      const W cb = *carry & 1;
  264|  47.1k|      W z = x + y;
  265|  47.1k|      W c1 = (z < x);
  266|  47.1k|      z += cb;
  267|  47.1k|      *carry = c1 | (z < cb);
  268|  47.1k|      return z;
  269|  47.1k|   }
  270|  47.1k|}
_ZN5Botan10word8_sub3ITkNS_8WordTypeEmEET_PS1_PKS1_S4_S1_:
  385|  4.38k|inline constexpr auto word8_sub3(W z[8], const W x[8], const W y[8], W carry) -> W {
  386|  4.38k|#if defined(BOTAN_MP_USE_X86_64_ASM)
  387|  4.38k|   if constexpr(std::same_as<W, uint64_t>) {
  388|  4.38k|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (388:10): [True: 4.38k, Folded]
  ------------------
  389|  4.38k|         asm volatile(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
  390|  4.38k|                      : [carry] "=r"(carry)
  391|  4.38k|                      : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  392|  4.38k|                      : "cc", "memory");
  393|  4.38k|         return carry;
  394|  4.38k|      }
  395|  4.38k|   }
  396|      0|#endif
  397|       |
  398|      0|   z[0] = word_sub(x[0], y[0], &carry);
  399|  4.38k|   z[1] = word_sub(x[1], y[1], &carry);
  400|  4.38k|   z[2] = word_sub(x[2], y[2], &carry);
  401|  4.38k|   z[3] = word_sub(x[3], y[3], &carry);
  402|  4.38k|   z[4] = word_sub(x[4], y[4], &carry);
  403|  4.38k|   z[5] = word_sub(x[5], y[5], &carry);
  404|  4.38k|   z[6] = word_sub(x[6], y[6], &carry);
  405|  4.38k|   z[7] = word_sub(x[7], y[7], &carry);
  406|  4.38k|   return carry;
  407|  4.38k|}
_ZN5Botan8word_subITkNS_8WordTypeEmEET_S1_S1_PS1_:
  332|  29.9k|inline constexpr auto word_sub(W x, W y, W* carry) -> W {
  333|  29.9k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_subc)
  334|  29.9k|   if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (334:7): [True: 29.9k, Folded]
  ------------------
  335|       |      if constexpr(std::same_as<W, unsigned int>) {
  336|       |         return __builtin_subc(x, y, *carry & 1, carry);
  337|  29.9k|      } else if constexpr(std::same_as<W, unsigned long>) {
  338|  29.9k|         return __builtin_subcl(x, y, *carry & 1, carry);
  339|       |      } else if constexpr(std::same_as<W, unsigned long long>) {
  340|       |         return __builtin_subcll(x, y, *carry & 1, carry);
  341|       |      }
  342|  29.9k|   }
  343|      0|#endif
  344|       |
  345|      0|   const W cb = *carry & 1;
  346|  29.9k|   W t0 = x - y;
  347|  29.9k|   W c1 = (t0 > x);
  348|  29.9k|   W z = t0 - cb;
  349|  29.9k|   *carry = c1 | (z > t0);
  350|  29.9k|   return z;
  351|  29.9k|}
_ZN5Botan10word_madd2ITkNS_8WordTypeEmEET_S1_S1_PS1_:
   90|    242|inline constexpr auto word_madd2(W a, W b, W* c) -> W {
   91|    242|#if defined(BOTAN_MP_USE_X86_64_ASM)
   92|    242|   if constexpr(std::same_as<W, uint64_t>) {
   93|    242|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (93:10): [True: 242, Folded]
  ------------------
   94|    242|         asm(R"(
   95|    242|            mulq %[b]
   96|    242|            addq %[c],%[a]
   97|    242|            adcq $0,%[carry]
   98|    242|            )"
   99|    242|             : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*c)
  100|    242|             : "0"(a), "1"(b), [c] "g"(*c)
  101|    242|             : "cc");
  102|       |
  103|    242|         return a;
  104|    242|      }
  105|    242|   }
  106|       |#elif defined(BOTAN_MP_USE_AARCH64_ASM)
  107|       |   if constexpr(std::same_as<W, uint64_t>) {
  108|       |      if(!std::is_constant_evaluated()) {
  109|       |         W lo = 0;
  110|       |         W hi = 0;
  111|       |         asm(R"(
  112|       |            mul  %[lo], %[a], %[b]
  113|       |            umulh %[hi], %[a], %[b]
  114|       |            adds %[lo], %[lo], %[c]
  115|       |            adc  %[hi], %[hi], xzr
  116|       |            )"
  117|       |             : [lo] "=&r"(lo), [hi] "=&r"(hi)
  118|       |             : [a] "r"(a), [b] "r"(b), [c] "r"(*c)
  119|       |             : "cc");
  120|       |
  121|       |         *c = hi;
  122|       |         return lo;
  123|       |      }
  124|       |   }
  125|       |#endif
  126|       |
  127|      0|   typedef typename WordInfo<W>::dword dword;
  128|    242|   const dword s = dword(a) * b + *c;
  129|    242|   *c = static_cast<W>(s >> WordInfo<W>::bits);
  130|    242|   return static_cast<W>(s);
  131|    242|}
_ZN5Botan11word8_madd3ITkNS_8WordTypeEmEET_PS1_PKS1_S1_S1_:
  441|  72.4k|inline constexpr auto word8_madd3(W z[8], const W x[8], W y, W carry) -> W {
  442|  72.4k|#if defined(BOTAN_MP_USE_X86_64_ASM)
  443|  72.4k|   if constexpr(std::same_as<W, uint64_t>) {
  444|  72.4k|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (444:10): [True: 72.4k, Folded]
  ------------------
  445|  72.4k|         asm volatile(DO_8_TIMES(MULADD_OP, "")
  446|  72.4k|                      : [carry] "=r"(carry)
  447|  72.4k|                      : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  448|  72.4k|                      : "cc", "%rax", "%rdx", "memory");
  449|  72.4k|         return carry;
  450|  72.4k|      }
  451|  72.4k|   }
  452|      0|#endif
  453|       |
  454|      0|   z[0] = word_madd3(x[0], y, z[0], &carry);
  455|  72.4k|   z[1] = word_madd3(x[1], y, z[1], &carry);
  456|  72.4k|   z[2] = word_madd3(x[2], y, z[2], &carry);
  457|  72.4k|   z[3] = word_madd3(x[3], y, z[3], &carry);
  458|  72.4k|   z[4] = word_madd3(x[4], y, z[4], &carry);
  459|  72.4k|   z[5] = word_madd3(x[5], y, z[5], &carry);
  460|  72.4k|   z[6] = word_madd3(x[6], y, z[6], &carry);
  461|  72.4k|   z[7] = word_madd3(x[7], y, z[7], &carry);
  462|  72.4k|   return carry;
  463|  72.4k|}
_ZN5Botan10word_madd3ITkNS_8WordTypeEmEET_S1_S1_S1_PS1_:
  137|  74.6k|inline constexpr auto word_madd3(W a, W b, W c, W* d) -> W {
  138|  74.6k|#if defined(BOTAN_MP_USE_X86_64_ASM)
  139|  74.6k|   if constexpr(std::same_as<W, uint64_t>) {
  140|  74.6k|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (140:10): [True: 74.6k, Folded]
  ------------------
  141|  74.6k|         asm(R"(
  142|  74.6k|            mulq %[b]
  143|  74.6k|
  144|  74.6k|            addq %[c],%[a]
  145|  74.6k|            adcq $0,%[carry]
  146|  74.6k|
  147|  74.6k|            addq %[d],%[a]
  148|  74.6k|            adcq $0,%[carry]
  149|  74.6k|            )"
  150|  74.6k|             : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*d)
  151|  74.6k|             : "0"(a), "1"(b), [c] "g"(c), [d] "g"(*d)
  152|  74.6k|             : "cc");
  153|       |
  154|  74.6k|         return a;
  155|  74.6k|      }
  156|  74.6k|   }
  157|       |#elif defined(BOTAN_MP_USE_AARCH64_ASM)
  158|       |   if constexpr(std::same_as<W, uint64_t>) {
  159|       |      if(!std::is_constant_evaluated()) {
  160|       |         W lo = 0;
  161|       |         W hi = 0;
  162|       |         asm(R"(
  163|       |            mul  %[lo], %[a], %[b]
  164|       |            umulh %[hi], %[a], %[b]
  165|       |            adds %[lo], %[lo], %[c]
  166|       |            adc  %[hi], %[hi], xzr
  167|       |            adds %[lo], %[lo], %[d]
  168|       |            adc  %[hi], %[hi], xzr
  169|       |            )"
  170|       |             : [lo] "=&r"(lo), [hi] "=&r"(hi)
  171|       |             : [a] "r"(a), [b] "r"(b), [c] "r"(c), [d] "r"(*d)
  172|       |             : "cc");
  173|       |
  174|       |         *d = hi;
  175|       |         return lo;
  176|       |      }
  177|       |   }
  178|       |#endif
  179|       |
  180|      0|   typedef typename WordInfo<W>::dword dword;
  181|  74.6k|   const dword s = dword(a) * b + c + *d;
  182|  74.6k|   *d = static_cast<W>(s >> WordInfo<W>::bits);
  183|  74.6k|   return static_cast<W>(s);
  184|  74.6k|}
_ZN5Botan10word8_add2ITkNS_8WordTypeEmEET_PS1_PKS1_S1_:
  276|  2.70k|inline constexpr auto word8_add2(W x[8], const W y[8], W carry) -> W {
  277|  2.70k|#if defined(BOTAN_MP_USE_X86_64_ASM)
  278|  2.70k|   if constexpr(std::same_as<W, uint64_t>) {
  279|  2.70k|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (279:10): [True: 2.70k, Folded]
  ------------------
  280|  2.70k|         asm volatile(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcq"))
  281|  2.70k|                      : [carry] "=r"(carry)
  282|  2.70k|                      : [x] "r"(x), [y] "r"(y), "0"(carry)
  283|  2.70k|                      : "cc", "memory");
  284|  2.70k|         return carry;
  285|  2.70k|      }
  286|  2.70k|   }
  287|      0|#endif
  288|       |
  289|      0|   x[0] = word_add(x[0], y[0], &carry);
  290|  2.70k|   x[1] = word_add(x[1], y[1], &carry);
  291|  2.70k|   x[2] = word_add(x[2], y[2], &carry);
  292|  2.70k|   x[3] = word_add(x[3], y[3], &carry);
  293|  2.70k|   x[4] = word_add(x[4], y[4], &carry);
  294|  2.70k|   x[5] = word_add(x[5], y[5], &carry);
  295|  2.70k|   x[6] = word_add(x[6], y[6], &carry);
  296|  2.70k|   x[7] = word_add(x[7], y[7], &carry);
  297|  2.70k|   return carry;
  298|  2.70k|}
_ZN5Botan10word8_sub2ITkNS_8WordTypeEmEET_PS1_PKS1_S1_:
  357|    802|inline constexpr auto word8_sub2(W x[8], const W y[8], W carry) -> W {
  358|    802|#if defined(BOTAN_MP_USE_X86_64_ASM)
  359|    802|   if constexpr(std::same_as<W, uint64_t>) {
  360|    802|      if(!std::is_constant_evaluated()) {
  ------------------
  |  Branch (360:10): [True: 802, Folded]
  ------------------
  361|    802|         asm volatile(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbq"))
  362|    802|                      : [carry] "=r"(carry)
  363|    802|                      : [x] "r"(x), [y] "r"(y), "0"(carry)
  364|    802|                      : "cc", "memory");
  365|    802|         return carry;
  366|    802|      }
  367|    802|   }
  368|      0|#endif
  369|       |
  370|      0|   x[0] = word_sub(x[0], y[0], &carry);
  371|    802|   x[1] = word_sub(x[1], y[1], &carry);
  372|    802|   x[2] = word_sub(x[2], y[2], &carry);
  373|    802|   x[3] = word_sub(x[3], y[3], &carry);
  374|    802|   x[4] = word_sub(x[4], y[4], &carry);
  375|    802|   x[5] = word_sub(x[5], y[5], &carry);
  376|    802|   x[6] = word_sub(x[6], y[6], &carry);
  377|    802|   x[7] = word_sub(x[7], y[7], &carry);
  378|    802|   return carry;
  379|    802|}
_ZN5Botan5word3ImEC2Ev:
  478|    494|      constexpr word3() : m_w(0) {}
_ZN5Botan5word3ImE3mulEmm:
  480|   109k|      inline constexpr void mul(W x, W y) { m_w += static_cast<W3>(x) * y; }
_ZN5Botan5word3ImE7extractEv:
  486|  16.9k|      inline constexpr W extract() {
  487|  16.9k|         W r = static_cast<W>(m_w);
  488|  16.9k|         m_w >>= WordInfo<W>::bits;
  489|  16.9k|         return r;
  490|  16.9k|      }
_ZN5Botan5word3ImE6mul_x2Emm:
  482|  19.6k|      inline constexpr void mul_x2(W x, W y) { m_w += static_cast<W3>(x) * y * 2; }

_ZN5Botan11bigint_add3ITkNS_8WordTypeEmEET_PS1_PKS1_mS4_m:
  123|    419|inline constexpr auto bigint_add3(W z[], const W x[], size_t x_size, const W y[], size_t y_size) -> W {
  124|    419|   if(x_size < y_size) {
  ------------------
  |  Branch (124:7): [True: 0, False: 419]
  ------------------
  125|      0|      return bigint_add3(z, y, y_size, x, x_size);
  126|      0|   }
  127|       |
  128|    419|   W carry = 0;
  129|       |
  130|    419|   const size_t blocks = y_size - (y_size % 8);
  131|       |
  132|  3.12k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (132:22): [True: 2.70k, False: 419]
  ------------------
  133|  2.70k|      carry = word8_add3(z + i, x + i, y + i, carry);
  134|  2.70k|   }
  135|       |
  136|  1.05k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (136:27): [True: 636, False: 419]
  ------------------
  137|    636|      z[i] = word_add(x[i], y[i], &carry);
  138|    636|   }
  139|       |
  140|    419|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (140:27): [True: 0, False: 419]
  ------------------
  141|      0|      z[i] = word_add(x[i], static_cast<W>(0), &carry);
  142|      0|   }
  143|       |
  144|    419|   return carry;
  145|    419|}
_ZN5Botan14bigint_linmul3ITkNS_8WordTypeEmEEvPT_PKS1_mS1_:
  419|    242|inline constexpr void bigint_linmul3(W z[], const W x[], size_t x_size, W y) {
  420|    242|   const size_t blocks = x_size - (x_size % 8);
  421|       |
  422|    242|   W carry = 0;
  423|       |
  424|    242|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (424:22): [True: 0, False: 242]
  ------------------
  425|      0|      carry = word8_linmul3(z + i, x + i, y, carry);
  426|      0|   }
  427|       |
  428|    484|   for(size_t i = blocks; i != x_size; ++i) {
  ------------------
  |  Branch (428:27): [True: 242, False: 242]
  ------------------
  429|    242|      z[i] = word_madd2(x[i], y, &carry);
  430|    242|   }
  431|       |
  432|    242|   z[x_size] = carry;
  433|    242|}
_ZN5Botan15bigint_ct_is_eqITkNS_8WordTypeEmEENS_2CT4MaskIT_EEPKS3_mS6_m:
  542|    296|inline constexpr auto bigint_ct_is_eq(const W x[], size_t x_size, const W y[], size_t y_size) -> CT::Mask<W> {
  543|    296|   const size_t common_elems = std::min(x_size, y_size);
  544|       |
  545|    296|   W diff = 0;
  546|       |
  547|  15.2k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (547:22): [True: 14.9k, False: 296]
  ------------------
  548|  14.9k|      diff |= (x[i] ^ y[i]);
  549|  14.9k|   }
  550|       |
  551|       |   // If any bits were set in high part of x/y, then they are not equal
  552|    296|   if(x_size < y_size) {
  ------------------
  |  Branch (552:7): [True: 296, False: 0]
  ------------------
  553|  9.30k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (553:30): [True: 9.01k, False: 296]
  ------------------
  554|  9.01k|         diff |= y[i];
  555|  9.01k|      }
  556|    296|   } else if(y_size < x_size) {
  ------------------
  |  Branch (556:14): [True: 0, False: 0]
  ------------------
  557|      0|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (557:30): [True: 0, False: 0]
  ------------------
  558|      0|         diff |= x[i];
  559|      0|      }
  560|      0|   }
  561|       |
  562|    296|   return CT::Mask<W>::is_zero(diff);
  563|    296|}
_ZN5Botan14bigint_cnd_addITkNS_8WordTypeEmEET_S1_PS1_PKS1_m:
   48|    297|inline constexpr W bigint_cnd_add(W cnd, W x[], const W y[], size_t size) {
   49|    297|   const auto mask = CT::Mask<W>::expand(cnd).value();
   50|       |
   51|    297|   W carry = 0;
   52|       |
   53|  23.8k|   for(size_t i = 0; i != size; ++i) {
  ------------------
  |  Branch (53:22): [True: 23.5k, False: 297]
  ------------------
   54|  23.5k|      x[i] = word_add(x[i], y[i] & mask, &carry);
   55|  23.5k|   }
   56|       |
   57|    297|   return (mask & carry);
   58|    297|}
_ZN5Botan14bigint_sub_absITkNS_8WordTypeEmEENS_2CT4MaskIT_EEPS3_PKS3_S7_mS5_:
  282|    716|inline constexpr auto bigint_sub_abs(W z[], const W x[], const W y[], size_t N, W ws[]) -> CT::Mask<W> {
  283|       |   // Subtract in both direction then conditional copy out the result
  284|       |
  285|    716|   W* ws0 = ws;
  286|    716|   W* ws1 = ws + N;
  287|       |
  288|    716|   W borrow0 = 0;
  289|    716|   W borrow1 = 0;
  290|       |
  291|    716|   const size_t blocks = N - (N % 8);
  292|       |
  293|  2.91k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (293:22): [True: 2.19k, False: 716]
  ------------------
  294|  2.19k|      borrow0 = word8_sub3(ws0 + i, x + i, y + i, borrow0);
  295|  2.19k|      borrow1 = word8_sub3(ws1 + i, y + i, x + i, borrow1);
  296|  2.19k|   }
  297|       |
  298|  2.16k|   for(size_t i = blocks; i != N; ++i) {
  ------------------
  |  Branch (298:27): [True: 1.45k, False: 716]
  ------------------
  299|  1.45k|      ws0[i] = word_sub(x[i], y[i], &borrow0);
  300|  1.45k|      ws1[i] = word_sub(y[i], x[i], &borrow1);
  301|  1.45k|   }
  302|       |
  303|    716|   return CT::conditional_copy_mem(borrow0, z, ws1, ws0, N);
  304|    716|}
_ZN5Botan11bigint_add2ITkNS_8WordTypeEmEET_PS1_mPKS1_m:
   97|  1.25k|inline constexpr auto bigint_add2(W x[], size_t x_size, const W y[], size_t y_size) -> W {
   98|  1.25k|   W carry = 0;
   99|       |
  100|  1.25k|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   71|  1.25k|   do {                                                                                 \
  |  |   72|  1.25k|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                     \
  |  |   73|  1.25k|      if(!(expr)) {                                                                     \
  |  |  ------------------
  |  |  |  Branch (73:10): [True: 0, False: 1.25k]
  |  |  ------------------
  |  |   74|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                            \
  |  |   75|      0|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   76|      0|      }                                                                                 \
  |  |   77|  1.25k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (77:12): [Folded, False: 1.25k]
  |  |  ------------------
  ------------------
  101|       |
  102|  1.25k|   const size_t blocks = y_size - (y_size % 8);
  103|       |
  104|  3.96k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (104:22): [True: 2.70k, False: 1.25k]
  ------------------
  105|  2.70k|      carry = word8_add2(x + i, y + i, carry);
  106|  2.70k|   }
  107|       |
  108|  2.73k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (108:27): [True: 1.47k, False: 1.25k]
  ------------------
  109|  1.47k|      x[i] = word_add(x[i], y[i], &carry);
  110|  1.47k|   }
  111|       |
  112|  22.7k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (112:27): [True: 21.4k, False: 1.25k]
  ------------------
  113|  21.4k|      x[i] = word_add(x[i], static_cast<W>(0), &carry);
  114|  21.4k|   }
  115|       |
  116|  1.25k|   return carry;
  117|  1.25k|}
_ZN5Botan14bigint_cnd_subITkNS_8WordTypeEmEET_S1_PS1_PKS1_m:
   65|    297|inline constexpr auto bigint_cnd_sub(W cnd, W x[], const W y[], size_t size) -> W {
   66|    297|   const auto mask = CT::Mask<W>::expand(cnd).value();
   67|       |
   68|    297|   W carry = 0;
   69|       |
   70|  23.8k|   for(size_t i = 0; i != size; ++i) {
  ------------------
  |  Branch (70:22): [True: 23.5k, False: 297]
  ------------------
   71|  23.5k|      x[i] = word_sub(x[i], y[i] & mask, &carry);
   72|  23.5k|   }
   73|       |
   74|    297|   return (mask & carry);
   75|    297|}
_ZN5Botan11bigint_sub2ITkNS_8WordTypeEmEET_PS1_mPKS1_m:
  151|    122|inline constexpr auto bigint_sub2(W x[], size_t x_size, const W y[], size_t y_size) -> W {
  152|    122|   W borrow = 0;
  153|       |
  154|    122|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   71|    122|   do {                                                                                 \
  |  |   72|    122|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                     \
  |  |   73|    122|      if(!(expr)) {                                                                     \
  |  |  ------------------
  |  |  |  Branch (73:10): [True: 0, False: 122]
  |  |  ------------------
  |  |   74|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                            \
  |  |   75|      0|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   76|      0|      }                                                                                 \
  |  |   77|    122|   } while(0)
  |  |  ------------------
  |  |  |  Branch (77:12): [Folded, False: 122]
  |  |  ------------------
  ------------------
  155|       |
  156|    122|   const size_t blocks = y_size - (y_size % 8);
  157|       |
  158|    924|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (158:22): [True: 802, False: 122]
  ------------------
  159|    802|      borrow = word8_sub2(x + i, y + i, borrow);
  160|    802|   }
  161|       |
  162|    312|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (162:27): [True: 190, False: 122]
  ------------------
  163|    190|      x[i] = word_sub(x[i], y[i], &borrow);
  164|    190|   }
  165|       |
  166|  3.42k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (166:27): [True: 3.30k, False: 122]
  ------------------
  167|  3.30k|      x[i] = word_sub(x[i], static_cast<W>(0), &borrow);
  168|  3.30k|   }
  169|       |
  170|    122|   return borrow;
  171|    122|}

_ZN5Botan2CT13value_barrierITkNSt3__117unsigned_integralEmQntsr3stdE7same_asIbT_EEES3_S3_:
   43|  30.8k|constexpr inline T value_barrier(T x) {
   44|  30.8k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (44:7): [Folded, False: 30.8k]
  ------------------
   45|      0|      return x;
   46|  30.8k|   } else {
   47|  30.8k|#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|  30.8k|      asm("" : "+r"(x) : /* no input */);  // NOLINT(*-no-assembler)
   56|  30.8k|      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|  30.8k|   }
   64|  30.8k|}
_ZN5Botan2CT13value_barrierITkNSt3__117unsigned_integralEhQntsr3stdE7same_asIbT_EEES3_S3_:
   43|  1.48k|constexpr inline T value_barrier(T x) {
   44|  1.48k|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (44:7): [Folded, False: 1.48k]
  ------------------
   45|      0|      return x;
   46|  1.48k|   } else {
   47|  1.48k|#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|  1.48k|      asm("" : "+r"(x) : /* no input */);  // NOLINT(*-no-assembler)
   56|  1.48k|      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|  1.48k|   }
   64|  1.48k|}

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

_ZN5BotanneERKNS_6BigIntES2_:
 1323|    296|inline bool operator!=(const BigInt& a, const BigInt& b) {
 1324|    296|   return !a.is_equal(b);
 1325|    296|}
_ZN5Botan6BigIntD2Ev:
  185|    888|      ~BigInt() { _const_time_unpoison(); }
_ZN5Botan6BigInt8swap_regERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  218|    296|      BOTAN_DEPRECATED("Deprecated no replacement") void swap_reg(secure_vector<word>& reg) {
  219|    296|         m_data.swap(reg);
  220|       |         // sign left unchanged
  221|    296|      }
_ZN5Botan6BigInt5clearEv:
  441|    296|      void clear() {
  442|    296|         m_data.set_to_zero();
  443|    296|         m_signedness = Positive;
  444|    296|      }
_ZNK5Botan6BigInt7word_atEm:
  601|    121|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZNK5Botan6BigInt4signEv:
  641|  1.47k|      Sign sign() const { return (m_signedness); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  663|    592|      void set_sign(Sign sign) {
  664|    592|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (664:13): [True: 0, False: 592]
  |  Branch (664:33): [True: 0, False: 0]
  ------------------
  665|      0|            sign = Positive;
  666|      0|         }
  667|       |
  668|    592|         m_signedness = sign;
  669|    592|      }
_ZNK5Botan6BigInt4sizeEv:
  681|  2.16k|      size_t size() const { return m_data.size(); }
_ZNK5Botan6BigInt9sig_wordsEv:
  687|    888|      size_t sig_words() const { return m_data.sig_words(); }
_ZN5Botan6BigInt12mutable_dataEv:
  712|    292|      BOTAN_DEPRECATED("Deprecated no replacement") word* mutable_data() { return m_data.mutable_data(); }
_ZNK5Botan6BigInt7grow_toEm:
  738|    296|      BOTAN_DEPRECATED("Deprecated no replacement") void grow_to(size_t n) const { m_data.grow_to(n); }
_ZNK5Botan6BigInt5_dataEv:
 1033|  1.35k|      const word* _data() const { return m_data.const_data(); }
_ZN5Botan6BigInt4Data12mutable_dataEv:
 1083|    292|            word* mutable_data() {
 1084|    292|               invalidate_sig_words();
 1085|    292|               return m_reg.data();
 1086|    292|            }
_ZNK5Botan6BigInt4Data10const_dataEv:
 1088|  2.23k|            const word* const_data() const { return m_reg.data(); }
_ZNK5Botan6BigInt4Data11get_word_atEm:
 1099|    121|            word get_word_at(size_t n) const {
 1100|    121|               if(n < m_reg.size()) {
  ------------------
  |  Branch (1100:19): [True: 121, False: 0]
  ------------------
 1101|    121|                  return m_reg[n];
 1102|    121|               }
 1103|      0|               return 0;
 1104|    121|            }
_ZNK5Botan6BigInt4Data7grow_toEm:
 1126|    296|            void grow_to(size_t n) const {
 1127|    296|               if(n > size()) {
  ------------------
  |  Branch (1127:19): [True: 296, False: 0]
  ------------------
 1128|    296|                  if(n <= m_reg.capacity()) {
  ------------------
  |  Branch (1128:22): [True: 0, False: 296]
  ------------------
 1129|      0|                     m_reg.resize(n);
 1130|    296|                  } else {
 1131|    296|                     m_reg.resize(n + (8 - (n % 8)));
 1132|    296|                  }
 1133|    296|               }
 1134|    296|            }
_ZNK5Botan6BigInt4Data4sizeEv:
 1136|  3.34k|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
 1156|    592|            void swap(secure_vector<word>& reg) noexcept {
 1157|    592|               m_reg.swap(reg);
 1158|    592|               invalidate_sig_words();
 1159|    592|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
 1161|    884|            void invalidate_sig_words() const noexcept { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
 1163|    888|            size_t sig_words() const {
 1164|    888|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (1164:19): [True: 592, False: 296]
  ------------------
 1165|    592|                  m_sig_words = calc_sig_words();
 1166|    592|               }
 1167|    888|               return m_sig_words;
 1168|    888|            }
_ZN5Botan6BigIntC2Ev:
   45|    592|      BigInt() = default;
_ZN5Botan6BigIntC2ERKS0_:
   88|    296|      BigInt(const BigInt& other) = default;

_ZN5Botan11clear_bytesEPvm:
  101|    302|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  102|    302|   if(bytes > 0) {
  ------------------
  |  Branch (102:7): [True: 6, False: 296]
  ------------------
  103|      6|      std::memset(ptr, 0, bytes);
  104|      6|   }
  105|    302|}
_ZN5Botan9clear_memImEEvPT_m:
  118|    296|inline constexpr void clear_mem(T* ptr, size_t n) {
  119|    296|   clear_bytes(ptr, sizeof(T) * n);
  120|    296|}
_ZN5Botan8copy_memImQsr3stdE12is_trivial_vIu7__decayIT_EEEEvPS1_PKS1_m:
  144|      5|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  145|      5|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |  110|      5|   do {                                                                                          \
  |  |  111|      5|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                              \
  |  |  112|     10|      if((expr1) && !(expr2)) {                                                                  \
  |  |  ------------------
  |  |  |  Branch (112:10): [True: 5, False: 0]
  |  |  |  Branch (112:23): [True: 5, False: 0]
  |  |  |  Branch (112:23): [True: 5, False: 0]
  |  |  ------------------
  |  |  113|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                                     \
  |  |  114|      0|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |  115|      0|      }                                                                                          \
  |  |  116|      5|   } while(0)
  |  |  ------------------
  |  |  |  Branch (116:12): [Folded, False: 5]
  |  |  ------------------
  ------------------
  146|       |
  147|      5|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (147:7): [True: 5, False: 0]
  |  Branch (147:24): [True: 5, False: 0]
  |  Branch (147:42): [True: 5, False: 0]
  ------------------
  148|      5|      std::memmove(out, in, sizeof(T) * n);
  149|      5|   }
  150|      5|}
_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|  9.01k|inline constexpr ToT typecast_copy(const FromR& src) {
  211|  9.01k|   ToT dst;  // NOLINT(*-member-init)
  212|  9.01k|   typecast_copy(dst, src);
  213|  9.01k|   return dst;
  214|  9.01k|}
_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|  9.01k|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|  9.01k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  9.01k|}
_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|  9.01k|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|  9.01k|   ranges::assert_equal_byte_lengths(out, in);
  178|  9.01k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  9.01k|}
_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|    225|inline constexpr void copy_mem(OutR&& out /* NOLINT(*-std-forward) */, const InR& in) {
  161|    225|   ranges::assert_equal_byte_lengths(out, in);
  162|    225|   if(std::is_constant_evaluated()) {
  ------------------
  |  Branch (162:7): [Folded, False: 225]
  ------------------
  163|      0|      std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
  164|    225|   } else if(ranges::size_bytes(out) > 0) {
  ------------------
  |  Branch (164:14): [True: 225, False: 0]
  ------------------
  165|    225|      std::memmove(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  166|    225|   }
  167|    225|}
_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|    225|inline constexpr ToT typecast_copy(const FromR& src) {
  211|    225|   ToT dst;  // NOLINT(*-member-init)
  212|    225|   typecast_copy(dst, src);
  213|    225|   return dst;
  214|    225|}
_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|    225|inline constexpr void typecast_copy(ToT& out, const FromR& in) {
  189|    225|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|    225|}
_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|    225|inline constexpr void typecast_copy(ToR&& out /* NOLINT(*-std-forward) */, const FromR& in) {
  177|    225|   ranges::assert_equal_byte_lengths(out, in);
  178|    225|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|    225|}
_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|}

_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJNS3_IKhLm18446744073709551615EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|    225|{
  101|    225|   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|    225|   } else {
  107|    225|      const size_t expected_size = s0.size_bytes();
  108|    225|      const bool correct_size =
  109|    225|         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
  110|       |
  111|    225|      if(!correct_size) {
  ------------------
  |  Branch (111:10): [True: 0, False: 225]
  ------------------
  112|      0|         memory_region_size_violation();
  113|      0|      }
  114|    225|   }
  115|    225|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIhLm8EEEEEvRKT0_:
   77|    225|inline constexpr void assert_exact_byte_length(const R& r) {
   78|    225|   const std::span s{r};
   79|    225|   if constexpr(statically_spanable_range<R>) {
   80|    225|      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|    225|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__14spanIKhLm8EEEEEvRKT0_:
   77|  18.0k|inline constexpr void assert_exact_byte_length(const R& r) {
   78|  18.0k|   const std::span s{r};
   79|  18.0k|   if constexpr(statically_spanable_range<R>) {
   80|  18.0k|      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|  18.0k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IKhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|  9.01k|{
  101|  9.01k|   const std::span s0{r0};
  102|       |
  103|  9.01k|   if constexpr(statically_spanable_range<R0>) {
  104|  9.01k|      constexpr size_t expected_size = s0.size_bytes();
  105|  9.01k|      (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|  9.01k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanImLm1EEEEEmRKT_:
   59|  9.23k|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|  9.23k|   return std::span{r}.size_bytes();
   61|  9.23k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeENSt3__14spanIhLm18446744073709551615EEEEEmRKT_:
   59|    450|inline constexpr size_t size_bytes(const spanable_range auto& r) {
   60|    450|   return std::span{r}.size_bytes();
   61|    450|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeENSt3__15arrayIhLm8EEEEEvRKT0_:
   77|    225|inline constexpr void assert_exact_byte_length(const R& r) {
   78|    225|   const std::span s{r};
   79|    225|   if constexpr(statically_spanable_range<R>) {
   80|    225|      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|    225|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeENSt3__14spanImLm1EEETpTkNS0_14spanable_rangeEJNS3_IhLm8EEEEEEvRKT_DpRKT0_QgtsZT0_Li0E:
  100|    225|{
  101|    225|   const std::span s0{r0};
  102|       |
  103|    225|   if constexpr(statically_spanable_range<R0>) {
  104|    225|      constexpr size_t expected_size = s0.size_bytes();
  105|    225|      (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|    225|}

_ZN5Botan16secure_allocatorImE10deallocateEPmm:
  102|  1.64k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE8allocateEm:
   95|  1.64k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }

_ZN5Botan16wrap_strong_typeImRmQoosr3stdE18constructible_fromIT_T0_Eaasr8conceptsE11strong_typeIS2_Esr3stdE18constructible_fromINS2_12wrapped_typeES3_EEEDcOS3_:
  144|  9.23k|[[nodiscard]] constexpr decltype(auto) wrap_strong_type(ParamT&& t) {
  145|  9.23k|   if constexpr(std::same_as<std::remove_cvref_t<ParamT>, T>) {
  146|       |      // Noop, if the parameter type already is the desired return type.
  147|  9.23k|      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|  9.23k|}

_Z4fuzzNSt3__14spanIKhLm18446744073709551615EEE:
   12|    313|void fuzz(std::span<const uint8_t> in) {
   13|    313|   if(in.size() > 8192 / 8) {
  ------------------
  |  Branch (13:7): [True: 17, False: 296]
  ------------------
   14|     17|      return;
   15|     17|   }
   16|       |
   17|    296|   const Botan::BigInt x = Botan::BigInt::from_bytes(in);
   18|       |
   19|    296|   const Botan::BigInt x_sqr = square(x);
   20|    296|   const Botan::BigInt x_mul = x * x;
   21|       |
   22|    296|   FUZZER_ASSERT_EQUAL(x_sqr, x_mul);
  ------------------
  |  |   79|    296|   do {                                                                                      \
  |  |   80|    296|      if((x) != (y)) {                                                                       \
  |  |  ------------------
  |  |  |  Branch (80:10): [True: 0, False: 296]
  |  |  ------------------
  |  |   81|      0|         FUZZER_WRITE_AND_CRASH(#x << " = " << (x) << " != " << #y << " = " << (y) << "\n"); \
  |  |  ------------------
  |  |  |  |   70|      0|   do {                                                                                                       \
  |  |  |  |   71|      0|      std::cerr << expr << " @ Line " << __LINE__ << " in " << __FILE__ << "\n"; /* NOLINT(*-macro-paren*) */ \
  |  |  |  |   72|      0|      abort();                                                                                                \
  |  |  |  |   73|      0|   } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (73:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|      }                                                                                      \
  |  |   83|    296|   } while(0)
  |  |  ------------------
  |  |  |  Branch (83:12): [Folded, False: 296]
  |  |  ------------------
  ------------------
   23|    296|}

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|    323|extern "C" int LLVMFuzzerTestOneInput(const uint8_t in[], size_t len) {
   40|    323|   if(len <= max_fuzzer_input_size) {
  ------------------
  |  Branch (40:7): [True: 313, False: 10]
  ------------------
   41|    313|      try {
   42|    313|         fuzz(std::span<const uint8_t>(in, len));
   43|    313|      } 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|    313|   }
   51|    323|   return 0;
   52|    323|}

_ZN5Botan6BigInt6squareERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  191|    296|BigInt& BigInt::square(secure_vector<word>& ws) {
  192|    296|   const size_t sw = sig_words();
  193|       |
  194|    296|   secure_vector<word> z(2 * sw);
  195|    296|   ws.resize(z.size());
  196|       |
  197|    296|   bigint_sqr(z.data(), z.size(), _data(), size(), sw, ws.data(), ws.size());
  198|       |
  199|    296|   swap_reg(z);
  200|    296|   set_sign(BigInt::Positive);
  201|       |
  202|    296|   return (*this);
  203|    296|}

_ZN5BotanmlERKNS_6BigIntES2_:
   57|    296|BigInt operator*(const BigInt& x, const BigInt& y) {
   58|    296|   const size_t x_sw = x.sig_words();
   59|    296|   const size_t y_sw = y.sig_words();
   60|       |
   61|    296|   BigInt z = BigInt::with_capacity(x.size() + y.size());
   62|       |
   63|    296|   if(x_sw == 1 && y_sw > 0) {
  ------------------
  |  Branch (63:7): [True: 121, False: 175]
  |  Branch (63:20): [True: 121, False: 0]
  ------------------
   64|    121|      bigint_linmul3(z.mutable_data(), y._data(), y_sw, x.word_at(0));
   65|    175|   } else if(y_sw == 1 && x_sw > 0) {
  ------------------
  |  Branch (65:14): [True: 0, False: 175]
  |  Branch (65:27): [True: 0, False: 0]
  ------------------
   66|      0|      bigint_linmul3(z.mutable_data(), x._data(), x_sw, y.word_at(0));
   67|    175|   } else if(x_sw > 0 && y_sw > 0) {
  ------------------
  |  Branch (67:14): [True: 171, False: 4]
  |  Branch (67:26): [True: 171, False: 0]
  ------------------
   68|    171|      secure_vector<word> workspace(z.size());
   69|       |
   70|    171|      bigint_mul(z.mutable_data(),
   71|    171|                 z.size(),
   72|    171|                 x._data(),
   73|    171|                 x.size(),
   74|    171|                 x_sw,
   75|    171|                 y._data(),
   76|    171|                 y.size(),
   77|    171|                 y_sw,
   78|    171|                 workspace.data(),
   79|    171|                 workspace.size());
   80|    171|   }
   81|       |
   82|    296|   z.cond_flip_sign(x_sw > 0 && y_sw > 0 && x.sign() != y.sign());
  ------------------
  |  Branch (82:21): [True: 292, False: 4]
  |  Branch (82:33): [True: 292, False: 0]
  |  Branch (82:45): [True: 0, False: 292]
  ------------------
   83|       |
   84|    296|   return z;
   85|    296|}

_ZN5Botan6BigInt13with_capacityEm:
   49|    296|BigInt BigInt::with_capacity(size_t size) {
   50|    296|   BigInt bn;
   51|    296|   bn.grow_to(size);
   52|    296|   return bn;
   53|    296|}
_ZN5Botan6BigInt10from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
   81|    296|BigInt BigInt::from_bytes(std::span<const uint8_t> input) {
   82|    296|   BigInt r;
   83|    296|   r.assign_from_bytes(input);
   84|    296|   return r;
   85|    296|}
_ZNK5Botan6BigInt8is_equalERKS0_:
  154|    296|bool BigInt::is_equal(const BigInt& other) const {
  155|    296|   if(this->sign() != other.sign()) {
  ------------------
  |  Branch (155:7): [True: 0, False: 296]
  ------------------
  156|      0|      return false;
  157|      0|   }
  158|       |
  159|    296|   return bigint_ct_is_eq(this->_data(), this->size(), other._data(), other.size()).as_bool();
  160|    296|}
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  189|    296|void BigInt::Data::set_to_zero() {
  190|    296|   m_reg.resize(m_reg.capacity());
  191|    296|   clear_mem(m_reg.data(), m_reg.size());
  192|    296|   m_sig_words = 0;
  193|    296|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  213|    592|size_t BigInt::Data::calc_sig_words() const {
  214|    592|   const size_t sz = m_reg.size();
  215|    592|   size_t sig = sz;
  216|       |
  217|    592|   word sub = 1;
  218|       |
  219|  22.2k|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (219:22): [True: 21.6k, False: 592]
  ------------------
  220|  21.6k|      const word w = m_reg[sz - i - 1];
  221|  21.6k|      sub &= ct_is_zero(w);
  222|  21.6k|      sig -= sub;
  223|  21.6k|   }
  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|    592|   CT::unpoison(sig);
  230|       |
  231|    592|   return sig;
  232|    592|}
_ZN5Botan6BigInt17assign_from_bytesENSt3__14spanIKhLm18446744073709551615EEE:
  423|    296|void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {
  424|    296|   clear();
  425|       |
  426|    296|   const size_t length = bytes.size();
  427|    296|   const size_t full_words = length / sizeof(word);
  428|    296|   const size_t extra_bytes = length % sizeof(word);
  429|       |
  430|    296|   const size_t total_words = full_words + (extra_bytes > 0 ? 1 : 0);
  ------------------
  |  Branch (430:45): [True: 225, False: 71]
  ------------------
  431|       |
  432|    296|   secure_vector<word> reg(8 * ceil_division<size_t>(total_words, 8));
  433|       |
  434|  9.30k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (434:22): [True: 9.01k, False: 296]
  ------------------
  435|  9.01k|      reg[i] = load_be<word>(bytes.last<sizeof(word)>());
  436|  9.01k|      bytes = bytes.first(bytes.size() - sizeof(word));
  437|  9.01k|   }
  438|       |
  439|    296|   if(!bytes.empty()) {
  ------------------
  |  Branch (439:7): [True: 225, False: 71]
  ------------------
  440|    225|      BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());
  ------------------
  |  |   84|    225|   do {                                                                     \
  |  |   85|    225|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                         \
  |  |   86|    225|      if(!(expr)) {                                                         \
  |  |  ------------------
  |  |  |  Branch (86:10): [True: 0, False: 225]
  |  |  ------------------
  |  |   87|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                \
  |  |   88|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   89|      0|      }                                                                     \
  |  |   90|    225|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded, False: 225]
  |  |  ------------------
  ------------------
  441|    225|      std::array<uint8_t, sizeof(word)> last_partial_word = {0};
  442|    225|      copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);
  443|    225|      reg[full_words] = load_be<word>(last_partial_word);
  444|    225|   }
  445|       |
  446|    296|   m_data.swap(reg);
  447|    296|}
_ZN5Botan6BigInt14cond_flip_signEb:
  521|    296|void BigInt::cond_flip_sign(bool predicate) {
  522|       |   // This code is assuming Negative == 0, Positive == 1
  523|       |
  524|    296|   const auto mask = CT::Mask<uint8_t>::expand_bool(predicate);
  525|       |
  526|    296|   const uint8_t current_sign = static_cast<uint8_t>(sign());
  527|       |
  528|    296|   const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
  529|       |
  530|    296|   set_sign(static_cast<Sign>(new_sign));
  531|    296|}
_ZNK5Botan6BigInt20_const_time_unpoisonEv:
  559|    888|void BigInt::_const_time_unpoison() const {
  560|    888|   CT::unpoison(m_data.const_data(), m_data.size());
  561|    888|}

_ZN5Botan17bigint_comba_sqr4EPmPKm:
   22|      4|void bigint_comba_sqr4(word z[8], const word x[4]) {
   23|      4|#if defined(BOTAN_HAS_MP_MULX)
   24|      4|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (24:7): [True: 4, False: 0]
  ------------------
   25|      4|      return bigint_mulx_sqr4(z, x);
   26|      4|   }
   27|      0|#endif
   28|       |
   29|      0|   word3<word> accum;
   30|       |
   31|      0|   accum.mul(x[0], x[0]);
   32|      0|   z[0] = accum.extract();
   33|      0|   accum.mul_x2(x[0], x[1]);
   34|      0|   z[1] = accum.extract();
   35|      0|   accum.mul_x2(x[0], x[2]);
   36|      0|   accum.mul(x[1], x[1]);
   37|      0|   z[2] = accum.extract();
   38|      0|   accum.mul_x2(x[0], x[3]);
   39|      0|   accum.mul_x2(x[1], x[2]);
   40|      0|   z[3] = accum.extract();
   41|      0|   accum.mul_x2(x[1], x[3]);
   42|      0|   accum.mul(x[2], x[2]);
   43|      0|   z[4] = accum.extract();
   44|      0|   accum.mul_x2(x[2], x[3]);
   45|      0|   z[5] = accum.extract();
   46|      0|   accum.mul(x[3], x[3]);
   47|      0|   z[6] = accum.extract();
   48|      0|   z[7] = accum.extract();
   49|      0|}
_ZN5Botan17bigint_comba_mul4EPmPKmS2_:
   54|     20|void bigint_comba_mul4(word z[8], const word x[4], const word y[4]) {
   55|     20|#if defined(BOTAN_HAS_MP_MULX)
   56|     20|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (56:7): [True: 20, False: 0]
  ------------------
   57|     20|      return bigint_mulx_mul4(z, x, y);
   58|     20|   }
   59|      0|#endif
   60|       |
   61|      0|   word3<word> accum;
   62|       |
   63|      0|   accum.mul(x[0], y[0]);
   64|      0|   z[0] = accum.extract();
   65|      0|   accum.mul(x[0], y[1]);
   66|      0|   accum.mul(x[1], y[0]);
   67|      0|   z[1] = accum.extract();
   68|      0|   accum.mul(x[0], y[2]);
   69|      0|   accum.mul(x[1], y[1]);
   70|      0|   accum.mul(x[2], y[0]);
   71|      0|   z[2] = accum.extract();
   72|      0|   accum.mul(x[0], y[3]);
   73|      0|   accum.mul(x[1], y[2]);
   74|      0|   accum.mul(x[2], y[1]);
   75|      0|   accum.mul(x[3], y[0]);
   76|      0|   z[3] = accum.extract();
   77|      0|   accum.mul(x[1], y[3]);
   78|      0|   accum.mul(x[2], y[2]);
   79|      0|   accum.mul(x[3], y[1]);
   80|      0|   z[4] = accum.extract();
   81|      0|   accum.mul(x[2], y[3]);
   82|      0|   accum.mul(x[3], y[2]);
   83|      0|   z[5] = accum.extract();
   84|      0|   accum.mul(x[3], y[3]);
   85|      0|   z[6] = accum.extract();
   86|      0|   z[7] = accum.extract();
   87|      0|}
_ZN5Botan17bigint_comba_sqr6EPmPKm:
   92|      2|void bigint_comba_sqr6(word z[12], const word x[6]) {
   93|      2|#if defined(BOTAN_HAS_MP_MULX)
   94|      2|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (94:7): [True: 2, False: 0]
  ------------------
   95|      2|      return bigint_mulx_sqr6(z, x);
   96|      2|   }
   97|      0|#endif
   98|       |
   99|      0|   word3<word> accum;
  100|       |
  101|      0|   accum.mul(x[0], x[0]);
  102|      0|   z[0] = accum.extract();
  103|      0|   accum.mul_x2(x[0], x[1]);
  104|      0|   z[1] = accum.extract();
  105|      0|   accum.mul_x2(x[0], x[2]);
  106|      0|   accum.mul(x[1], x[1]);
  107|      0|   z[2] = accum.extract();
  108|      0|   accum.mul_x2(x[0], x[3]);
  109|      0|   accum.mul_x2(x[1], x[2]);
  110|      0|   z[3] = accum.extract();
  111|      0|   accum.mul_x2(x[0], x[4]);
  112|      0|   accum.mul_x2(x[1], x[3]);
  113|      0|   accum.mul(x[2], x[2]);
  114|      0|   z[4] = accum.extract();
  115|      0|   accum.mul_x2(x[0], x[5]);
  116|      0|   accum.mul_x2(x[1], x[4]);
  117|      0|   accum.mul_x2(x[2], x[3]);
  118|      0|   z[5] = accum.extract();
  119|      0|   accum.mul_x2(x[1], x[5]);
  120|      0|   accum.mul_x2(x[2], x[4]);
  121|      0|   accum.mul(x[3], x[3]);
  122|      0|   z[6] = accum.extract();
  123|      0|   accum.mul_x2(x[2], x[5]);
  124|      0|   accum.mul_x2(x[3], x[4]);
  125|      0|   z[7] = accum.extract();
  126|      0|   accum.mul_x2(x[3], x[5]);
  127|      0|   accum.mul(x[4], x[4]);
  128|      0|   z[8] = accum.extract();
  129|      0|   accum.mul_x2(x[4], x[5]);
  130|      0|   z[9] = accum.extract();
  131|      0|   accum.mul(x[5], x[5]);
  132|      0|   z[10] = accum.extract();
  133|      0|   z[11] = accum.extract();
  134|      0|}
_ZN5Botan17bigint_comba_mul6EPmPKmS2_:
  139|      8|void bigint_comba_mul6(word z[12], const word x[6], const word y[6]) {
  140|      8|#if defined(BOTAN_HAS_MP_MULX)
  141|      8|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (141:7): [True: 8, False: 0]
  ------------------
  142|      8|      return bigint_mulx_mul6(z, x, y);
  143|      8|   }
  144|      0|#endif
  145|       |
  146|      0|   word3<word> accum;
  147|       |
  148|      0|   accum.mul(x[0], y[0]);
  149|      0|   z[0] = accum.extract();
  150|      0|   accum.mul(x[0], y[1]);
  151|      0|   accum.mul(x[1], y[0]);
  152|      0|   z[1] = accum.extract();
  153|      0|   accum.mul(x[0], y[2]);
  154|      0|   accum.mul(x[1], y[1]);
  155|      0|   accum.mul(x[2], y[0]);
  156|      0|   z[2] = accum.extract();
  157|      0|   accum.mul(x[0], y[3]);
  158|      0|   accum.mul(x[1], y[2]);
  159|      0|   accum.mul(x[2], y[1]);
  160|      0|   accum.mul(x[3], y[0]);
  161|      0|   z[3] = accum.extract();
  162|      0|   accum.mul(x[0], y[4]);
  163|      0|   accum.mul(x[1], y[3]);
  164|      0|   accum.mul(x[2], y[2]);
  165|      0|   accum.mul(x[3], y[1]);
  166|      0|   accum.mul(x[4], y[0]);
  167|      0|   z[4] = accum.extract();
  168|      0|   accum.mul(x[0], y[5]);
  169|      0|   accum.mul(x[1], y[4]);
  170|      0|   accum.mul(x[2], y[3]);
  171|      0|   accum.mul(x[3], y[2]);
  172|      0|   accum.mul(x[4], y[1]);
  173|      0|   accum.mul(x[5], y[0]);
  174|      0|   z[5] = accum.extract();
  175|      0|   accum.mul(x[1], y[5]);
  176|      0|   accum.mul(x[2], y[4]);
  177|      0|   accum.mul(x[3], y[3]);
  178|      0|   accum.mul(x[4], y[2]);
  179|      0|   accum.mul(x[5], y[1]);
  180|      0|   z[6] = accum.extract();
  181|      0|   accum.mul(x[2], y[5]);
  182|      0|   accum.mul(x[3], y[4]);
  183|      0|   accum.mul(x[4], y[3]);
  184|      0|   accum.mul(x[5], y[2]);
  185|      0|   z[7] = accum.extract();
  186|      0|   accum.mul(x[3], y[5]);
  187|      0|   accum.mul(x[4], y[4]);
  188|      0|   accum.mul(x[5], y[3]);
  189|      0|   z[8] = accum.extract();
  190|      0|   accum.mul(x[4], y[5]);
  191|      0|   accum.mul(x[5], y[4]);
  192|      0|   z[9] = accum.extract();
  193|      0|   accum.mul(x[5], y[5]);
  194|      0|   z[10] = accum.extract();
  195|      0|   z[11] = accum.extract();
  196|      0|}
_ZN5Botan17bigint_comba_sqr8EPmPKm:
  322|      5|void bigint_comba_sqr8(word z[16], const word x[8]) {
  323|      5|#if defined(BOTAN_HAS_MP_MULX)
  324|      5|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (324:7): [True: 5, False: 0]
  ------------------
  325|      5|      return bigint_mulx_sqr8(z, x);
  326|      5|   }
  327|      0|#endif
  328|       |
  329|      0|   word3<word> accum;
  330|       |
  331|      0|   accum.mul(x[0], x[0]);
  332|      0|   z[0] = accum.extract();
  333|      0|   accum.mul_x2(x[0], x[1]);
  334|      0|   z[1] = accum.extract();
  335|      0|   accum.mul_x2(x[0], x[2]);
  336|      0|   accum.mul(x[1], x[1]);
  337|      0|   z[2] = accum.extract();
  338|      0|   accum.mul_x2(x[0], x[3]);
  339|      0|   accum.mul_x2(x[1], x[2]);
  340|      0|   z[3] = accum.extract();
  341|      0|   accum.mul_x2(x[0], x[4]);
  342|      0|   accum.mul_x2(x[1], x[3]);
  343|      0|   accum.mul(x[2], x[2]);
  344|      0|   z[4] = accum.extract();
  345|      0|   accum.mul_x2(x[0], x[5]);
  346|      0|   accum.mul_x2(x[1], x[4]);
  347|      0|   accum.mul_x2(x[2], x[3]);
  348|      0|   z[5] = accum.extract();
  349|      0|   accum.mul_x2(x[0], x[6]);
  350|      0|   accum.mul_x2(x[1], x[5]);
  351|      0|   accum.mul_x2(x[2], x[4]);
  352|      0|   accum.mul(x[3], x[3]);
  353|      0|   z[6] = accum.extract();
  354|      0|   accum.mul_x2(x[0], x[7]);
  355|      0|   accum.mul_x2(x[1], x[6]);
  356|      0|   accum.mul_x2(x[2], x[5]);
  357|      0|   accum.mul_x2(x[3], x[4]);
  358|      0|   z[7] = accum.extract();
  359|      0|   accum.mul_x2(x[1], x[7]);
  360|      0|   accum.mul_x2(x[2], x[6]);
  361|      0|   accum.mul_x2(x[3], x[5]);
  362|      0|   accum.mul(x[4], x[4]);
  363|      0|   z[8] = accum.extract();
  364|      0|   accum.mul_x2(x[2], x[7]);
  365|      0|   accum.mul_x2(x[3], x[6]);
  366|      0|   accum.mul_x2(x[4], x[5]);
  367|      0|   z[9] = accum.extract();
  368|      0|   accum.mul_x2(x[3], x[7]);
  369|      0|   accum.mul_x2(x[4], x[6]);
  370|      0|   accum.mul(x[5], x[5]);
  371|      0|   z[10] = accum.extract();
  372|      0|   accum.mul_x2(x[4], x[7]);
  373|      0|   accum.mul_x2(x[5], x[6]);
  374|      0|   z[11] = accum.extract();
  375|      0|   accum.mul_x2(x[5], x[7]);
  376|      0|   accum.mul(x[6], x[6]);
  377|      0|   z[12] = accum.extract();
  378|      0|   accum.mul_x2(x[6], x[7]);
  379|      0|   z[13] = accum.extract();
  380|      0|   accum.mul(x[7], x[7]);
  381|      0|   z[14] = accum.extract();
  382|      0|   z[15] = accum.extract();
  383|      0|}
_ZN5Botan17bigint_comba_mul8EPmPKmS2_:
  388|     10|void bigint_comba_mul8(word z[16], const word x[8], const word y[8]) {
  389|     10|#if defined(BOTAN_HAS_MP_MULX)
  390|     10|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (390:7): [True: 10, False: 0]
  ------------------
  391|     10|      return bigint_mulx_mul8(z, x, y);
  392|     10|   }
  393|      0|#endif
  394|       |
  395|      0|   word3<word> accum;
  396|       |
  397|      0|   accum.mul(x[0], y[0]);
  398|      0|   z[0] = accum.extract();
  399|      0|   accum.mul(x[0], y[1]);
  400|      0|   accum.mul(x[1], y[0]);
  401|      0|   z[1] = accum.extract();
  402|      0|   accum.mul(x[0], y[2]);
  403|      0|   accum.mul(x[1], y[1]);
  404|      0|   accum.mul(x[2], y[0]);
  405|      0|   z[2] = accum.extract();
  406|      0|   accum.mul(x[0], y[3]);
  407|      0|   accum.mul(x[1], y[2]);
  408|      0|   accum.mul(x[2], y[1]);
  409|      0|   accum.mul(x[3], y[0]);
  410|      0|   z[3] = accum.extract();
  411|      0|   accum.mul(x[0], y[4]);
  412|      0|   accum.mul(x[1], y[3]);
  413|      0|   accum.mul(x[2], y[2]);
  414|      0|   accum.mul(x[3], y[1]);
  415|      0|   accum.mul(x[4], y[0]);
  416|      0|   z[4] = accum.extract();
  417|      0|   accum.mul(x[0], y[5]);
  418|      0|   accum.mul(x[1], y[4]);
  419|      0|   accum.mul(x[2], y[3]);
  420|      0|   accum.mul(x[3], y[2]);
  421|      0|   accum.mul(x[4], y[1]);
  422|      0|   accum.mul(x[5], y[0]);
  423|      0|   z[5] = accum.extract();
  424|      0|   accum.mul(x[0], y[6]);
  425|      0|   accum.mul(x[1], y[5]);
  426|      0|   accum.mul(x[2], y[4]);
  427|      0|   accum.mul(x[3], y[3]);
  428|      0|   accum.mul(x[4], y[2]);
  429|      0|   accum.mul(x[5], y[1]);
  430|      0|   accum.mul(x[6], y[0]);
  431|      0|   z[6] = accum.extract();
  432|      0|   accum.mul(x[0], y[7]);
  433|      0|   accum.mul(x[1], y[6]);
  434|      0|   accum.mul(x[2], y[5]);
  435|      0|   accum.mul(x[3], y[4]);
  436|      0|   accum.mul(x[4], y[3]);
  437|      0|   accum.mul(x[5], y[2]);
  438|      0|   accum.mul(x[6], y[1]);
  439|      0|   accum.mul(x[7], y[0]);
  440|      0|   z[7] = accum.extract();
  441|      0|   accum.mul(x[1], y[7]);
  442|      0|   accum.mul(x[2], y[6]);
  443|      0|   accum.mul(x[3], y[5]);
  444|      0|   accum.mul(x[4], y[4]);
  445|      0|   accum.mul(x[5], y[3]);
  446|      0|   accum.mul(x[6], y[2]);
  447|      0|   accum.mul(x[7], y[1]);
  448|      0|   z[8] = accum.extract();
  449|      0|   accum.mul(x[2], y[7]);
  450|      0|   accum.mul(x[3], y[6]);
  451|      0|   accum.mul(x[4], y[5]);
  452|      0|   accum.mul(x[5], y[4]);
  453|      0|   accum.mul(x[6], y[3]);
  454|      0|   accum.mul(x[7], y[2]);
  455|      0|   z[9] = accum.extract();
  456|      0|   accum.mul(x[3], y[7]);
  457|      0|   accum.mul(x[4], y[6]);
  458|      0|   accum.mul(x[5], y[5]);
  459|      0|   accum.mul(x[6], y[4]);
  460|      0|   accum.mul(x[7], y[3]);
  461|      0|   z[10] = accum.extract();
  462|      0|   accum.mul(x[4], y[7]);
  463|      0|   accum.mul(x[5], y[6]);
  464|      0|   accum.mul(x[6], y[5]);
  465|      0|   accum.mul(x[7], y[4]);
  466|      0|   z[11] = accum.extract();
  467|      0|   accum.mul(x[5], y[7]);
  468|      0|   accum.mul(x[6], y[6]);
  469|      0|   accum.mul(x[7], y[5]);
  470|      0|   z[12] = accum.extract();
  471|      0|   accum.mul(x[6], y[7]);
  472|      0|   accum.mul(x[7], y[6]);
  473|      0|   z[13] = accum.extract();
  474|      0|   accum.mul(x[7], y[7]);
  475|      0|   z[14] = accum.extract();
  476|      0|   z[15] = accum.extract();
  477|      0|}
_ZN5Botan17bigint_comba_sqr9EPmPKm:
  482|      5|void bigint_comba_sqr9(word z[18], const word x[9]) {
  483|      5|#if defined(BOTAN_HAS_MP_MULX)
  484|      5|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (484:7): [True: 5, False: 0]
  ------------------
  485|      5|      return bigint_mulx_sqr9(z, x);
  486|      5|   }
  487|      0|#endif
  488|       |
  489|      0|   word3<word> accum;
  490|       |
  491|      0|   accum.mul(x[0], x[0]);
  492|      0|   z[0] = accum.extract();
  493|      0|   accum.mul_x2(x[0], x[1]);
  494|      0|   z[1] = accum.extract();
  495|      0|   accum.mul_x2(x[0], x[2]);
  496|      0|   accum.mul(x[1], x[1]);
  497|      0|   z[2] = accum.extract();
  498|      0|   accum.mul_x2(x[0], x[3]);
  499|      0|   accum.mul_x2(x[1], x[2]);
  500|      0|   z[3] = accum.extract();
  501|      0|   accum.mul_x2(x[0], x[4]);
  502|      0|   accum.mul_x2(x[1], x[3]);
  503|      0|   accum.mul(x[2], x[2]);
  504|      0|   z[4] = accum.extract();
  505|      0|   accum.mul_x2(x[0], x[5]);
  506|      0|   accum.mul_x2(x[1], x[4]);
  507|      0|   accum.mul_x2(x[2], x[3]);
  508|      0|   z[5] = accum.extract();
  509|      0|   accum.mul_x2(x[0], x[6]);
  510|      0|   accum.mul_x2(x[1], x[5]);
  511|      0|   accum.mul_x2(x[2], x[4]);
  512|      0|   accum.mul(x[3], x[3]);
  513|      0|   z[6] = accum.extract();
  514|      0|   accum.mul_x2(x[0], x[7]);
  515|      0|   accum.mul_x2(x[1], x[6]);
  516|      0|   accum.mul_x2(x[2], x[5]);
  517|      0|   accum.mul_x2(x[3], x[4]);
  518|      0|   z[7] = accum.extract();
  519|      0|   accum.mul_x2(x[0], x[8]);
  520|      0|   accum.mul_x2(x[1], x[7]);
  521|      0|   accum.mul_x2(x[2], x[6]);
  522|      0|   accum.mul_x2(x[3], x[5]);
  523|      0|   accum.mul(x[4], x[4]);
  524|      0|   z[8] = accum.extract();
  525|      0|   accum.mul_x2(x[1], x[8]);
  526|      0|   accum.mul_x2(x[2], x[7]);
  527|      0|   accum.mul_x2(x[3], x[6]);
  528|      0|   accum.mul_x2(x[4], x[5]);
  529|      0|   z[9] = accum.extract();
  530|      0|   accum.mul_x2(x[2], x[8]);
  531|      0|   accum.mul_x2(x[3], x[7]);
  532|      0|   accum.mul_x2(x[4], x[6]);
  533|      0|   accum.mul(x[5], x[5]);
  534|      0|   z[10] = accum.extract();
  535|      0|   accum.mul_x2(x[3], x[8]);
  536|      0|   accum.mul_x2(x[4], x[7]);
  537|      0|   accum.mul_x2(x[5], x[6]);
  538|      0|   z[11] = accum.extract();
  539|      0|   accum.mul_x2(x[4], x[8]);
  540|      0|   accum.mul_x2(x[5], x[7]);
  541|      0|   accum.mul(x[6], x[6]);
  542|      0|   z[12] = accum.extract();
  543|      0|   accum.mul_x2(x[5], x[8]);
  544|      0|   accum.mul_x2(x[6], x[7]);
  545|      0|   z[13] = accum.extract();
  546|      0|   accum.mul_x2(x[6], x[8]);
  547|      0|   accum.mul(x[7], x[7]);
  548|      0|   z[14] = accum.extract();
  549|      0|   accum.mul_x2(x[7], x[8]);
  550|      0|   z[15] = accum.extract();
  551|      0|   accum.mul(x[8], x[8]);
  552|      0|   z[16] = accum.extract();
  553|      0|   z[17] = accum.extract();
  554|      0|}
_ZN5Botan17bigint_comba_mul9EPmPKmS2_:
  559|      5|void bigint_comba_mul9(word z[18], const word x[9], const word y[9]) {
  560|      5|#if defined(BOTAN_HAS_MP_MULX)
  561|      5|   if(CPUID::has(CPUID::Feature::BMI, CPUID::Feature::ADX)) {
  ------------------
  |  Branch (561:7): [True: 5, False: 0]
  ------------------
  562|      5|      return bigint_mulx_mul9(z, x, y);
  563|      5|   }
  564|      0|#endif
  565|       |
  566|      0|   word3<word> accum;
  567|       |
  568|      0|   accum.mul(x[0], y[0]);
  569|      0|   z[0] = accum.extract();
  570|      0|   accum.mul(x[0], y[1]);
  571|      0|   accum.mul(x[1], y[0]);
  572|      0|   z[1] = accum.extract();
  573|      0|   accum.mul(x[0], y[2]);
  574|      0|   accum.mul(x[1], y[1]);
  575|      0|   accum.mul(x[2], y[0]);
  576|      0|   z[2] = accum.extract();
  577|      0|   accum.mul(x[0], y[3]);
  578|      0|   accum.mul(x[1], y[2]);
  579|      0|   accum.mul(x[2], y[1]);
  580|      0|   accum.mul(x[3], y[0]);
  581|      0|   z[3] = accum.extract();
  582|      0|   accum.mul(x[0], y[4]);
  583|      0|   accum.mul(x[1], y[3]);
  584|      0|   accum.mul(x[2], y[2]);
  585|      0|   accum.mul(x[3], y[1]);
  586|      0|   accum.mul(x[4], y[0]);
  587|      0|   z[4] = accum.extract();
  588|      0|   accum.mul(x[0], y[5]);
  589|      0|   accum.mul(x[1], y[4]);
  590|      0|   accum.mul(x[2], y[3]);
  591|      0|   accum.mul(x[3], y[2]);
  592|      0|   accum.mul(x[4], y[1]);
  593|      0|   accum.mul(x[5], y[0]);
  594|      0|   z[5] = accum.extract();
  595|      0|   accum.mul(x[0], y[6]);
  596|      0|   accum.mul(x[1], y[5]);
  597|      0|   accum.mul(x[2], y[4]);
  598|      0|   accum.mul(x[3], y[3]);
  599|      0|   accum.mul(x[4], y[2]);
  600|      0|   accum.mul(x[5], y[1]);
  601|      0|   accum.mul(x[6], y[0]);
  602|      0|   z[6] = accum.extract();
  603|      0|   accum.mul(x[0], y[7]);
  604|      0|   accum.mul(x[1], y[6]);
  605|      0|   accum.mul(x[2], y[5]);
  606|      0|   accum.mul(x[3], y[4]);
  607|      0|   accum.mul(x[4], y[3]);
  608|      0|   accum.mul(x[5], y[2]);
  609|      0|   accum.mul(x[6], y[1]);
  610|      0|   accum.mul(x[7], y[0]);
  611|      0|   z[7] = accum.extract();
  612|      0|   accum.mul(x[0], y[8]);
  613|      0|   accum.mul(x[1], y[7]);
  614|      0|   accum.mul(x[2], y[6]);
  615|      0|   accum.mul(x[3], y[5]);
  616|      0|   accum.mul(x[4], y[4]);
  617|      0|   accum.mul(x[5], y[3]);
  618|      0|   accum.mul(x[6], y[2]);
  619|      0|   accum.mul(x[7], y[1]);
  620|      0|   accum.mul(x[8], y[0]);
  621|      0|   z[8] = accum.extract();
  622|      0|   accum.mul(x[1], y[8]);
  623|      0|   accum.mul(x[2], y[7]);
  624|      0|   accum.mul(x[3], y[6]);
  625|      0|   accum.mul(x[4], y[5]);
  626|      0|   accum.mul(x[5], y[4]);
  627|      0|   accum.mul(x[6], y[3]);
  628|      0|   accum.mul(x[7], y[2]);
  629|      0|   accum.mul(x[8], y[1]);
  630|      0|   z[9] = accum.extract();
  631|      0|   accum.mul(x[2], y[8]);
  632|      0|   accum.mul(x[3], y[7]);
  633|      0|   accum.mul(x[4], y[6]);
  634|      0|   accum.mul(x[5], y[5]);
  635|      0|   accum.mul(x[6], y[4]);
  636|      0|   accum.mul(x[7], y[3]);
  637|      0|   accum.mul(x[8], y[2]);
  638|      0|   z[10] = accum.extract();
  639|      0|   accum.mul(x[3], y[8]);
  640|      0|   accum.mul(x[4], y[7]);
  641|      0|   accum.mul(x[5], y[6]);
  642|      0|   accum.mul(x[6], y[5]);
  643|      0|   accum.mul(x[7], y[4]);
  644|      0|   accum.mul(x[8], y[3]);
  645|      0|   z[11] = accum.extract();
  646|      0|   accum.mul(x[4], y[8]);
  647|      0|   accum.mul(x[5], y[7]);
  648|      0|   accum.mul(x[6], y[6]);
  649|      0|   accum.mul(x[7], y[5]);
  650|      0|   accum.mul(x[8], y[4]);
  651|      0|   z[12] = accum.extract();
  652|      0|   accum.mul(x[5], y[8]);
  653|      0|   accum.mul(x[6], y[7]);
  654|      0|   accum.mul(x[7], y[6]);
  655|      0|   accum.mul(x[8], y[5]);
  656|      0|   z[13] = accum.extract();
  657|      0|   accum.mul(x[6], y[8]);
  658|      0|   accum.mul(x[7], y[7]);
  659|      0|   accum.mul(x[8], y[6]);
  660|      0|   z[14] = accum.extract();
  661|      0|   accum.mul(x[7], y[8]);
  662|      0|   accum.mul(x[8], y[7]);
  663|      0|   z[15] = accum.extract();
  664|      0|   accum.mul(x[8], y[8]);
  665|      0|   z[16] = accum.extract();
  666|      0|   z[17] = accum.extract();
  667|      0|}
_ZN5Botan18bigint_comba_sqr16EPmPKm:
  672|    134|void bigint_comba_sqr16(word z[32], const word x[16]) {
  673|    134|   word3<word> accum;
  674|       |
  675|    134|   accum.mul(x[0], x[0]);
  676|    134|   z[0] = accum.extract();
  677|    134|   accum.mul_x2(x[0], x[1]);
  678|    134|   z[1] = accum.extract();
  679|    134|   accum.mul_x2(x[0], x[2]);
  680|    134|   accum.mul(x[1], x[1]);
  681|    134|   z[2] = accum.extract();
  682|    134|   accum.mul_x2(x[0], x[3]);
  683|    134|   accum.mul_x2(x[1], x[2]);
  684|    134|   z[3] = accum.extract();
  685|    134|   accum.mul_x2(x[0], x[4]);
  686|    134|   accum.mul_x2(x[1], x[3]);
  687|    134|   accum.mul(x[2], x[2]);
  688|    134|   z[4] = accum.extract();
  689|    134|   accum.mul_x2(x[0], x[5]);
  690|    134|   accum.mul_x2(x[1], x[4]);
  691|    134|   accum.mul_x2(x[2], x[3]);
  692|    134|   z[5] = accum.extract();
  693|    134|   accum.mul_x2(x[0], x[6]);
  694|    134|   accum.mul_x2(x[1], x[5]);
  695|    134|   accum.mul_x2(x[2], x[4]);
  696|    134|   accum.mul(x[3], x[3]);
  697|    134|   z[6] = accum.extract();
  698|    134|   accum.mul_x2(x[0], x[7]);
  699|    134|   accum.mul_x2(x[1], x[6]);
  700|    134|   accum.mul_x2(x[2], x[5]);
  701|    134|   accum.mul_x2(x[3], x[4]);
  702|    134|   z[7] = accum.extract();
  703|    134|   accum.mul_x2(x[0], x[8]);
  704|    134|   accum.mul_x2(x[1], x[7]);
  705|    134|   accum.mul_x2(x[2], x[6]);
  706|    134|   accum.mul_x2(x[3], x[5]);
  707|    134|   accum.mul(x[4], x[4]);
  708|    134|   z[8] = accum.extract();
  709|    134|   accum.mul_x2(x[0], x[9]);
  710|    134|   accum.mul_x2(x[1], x[8]);
  711|    134|   accum.mul_x2(x[2], x[7]);
  712|    134|   accum.mul_x2(x[3], x[6]);
  713|    134|   accum.mul_x2(x[4], x[5]);
  714|    134|   z[9] = accum.extract();
  715|    134|   accum.mul_x2(x[0], x[10]);
  716|    134|   accum.mul_x2(x[1], x[9]);
  717|    134|   accum.mul_x2(x[2], x[8]);
  718|    134|   accum.mul_x2(x[3], x[7]);
  719|    134|   accum.mul_x2(x[4], x[6]);
  720|    134|   accum.mul(x[5], x[5]);
  721|    134|   z[10] = accum.extract();
  722|    134|   accum.mul_x2(x[0], x[11]);
  723|    134|   accum.mul_x2(x[1], x[10]);
  724|    134|   accum.mul_x2(x[2], x[9]);
  725|    134|   accum.mul_x2(x[3], x[8]);
  726|    134|   accum.mul_x2(x[4], x[7]);
  727|    134|   accum.mul_x2(x[5], x[6]);
  728|    134|   z[11] = accum.extract();
  729|    134|   accum.mul_x2(x[0], x[12]);
  730|    134|   accum.mul_x2(x[1], x[11]);
  731|    134|   accum.mul_x2(x[2], x[10]);
  732|    134|   accum.mul_x2(x[3], x[9]);
  733|    134|   accum.mul_x2(x[4], x[8]);
  734|    134|   accum.mul_x2(x[5], x[7]);
  735|    134|   accum.mul(x[6], x[6]);
  736|    134|   z[12] = accum.extract();
  737|    134|   accum.mul_x2(x[0], x[13]);
  738|    134|   accum.mul_x2(x[1], x[12]);
  739|    134|   accum.mul_x2(x[2], x[11]);
  740|    134|   accum.mul_x2(x[3], x[10]);
  741|    134|   accum.mul_x2(x[4], x[9]);
  742|    134|   accum.mul_x2(x[5], x[8]);
  743|    134|   accum.mul_x2(x[6], x[7]);
  744|    134|   z[13] = accum.extract();
  745|    134|   accum.mul_x2(x[0], x[14]);
  746|    134|   accum.mul_x2(x[1], x[13]);
  747|    134|   accum.mul_x2(x[2], x[12]);
  748|    134|   accum.mul_x2(x[3], x[11]);
  749|    134|   accum.mul_x2(x[4], x[10]);
  750|    134|   accum.mul_x2(x[5], x[9]);
  751|    134|   accum.mul_x2(x[6], x[8]);
  752|    134|   accum.mul(x[7], x[7]);
  753|    134|   z[14] = accum.extract();
  754|    134|   accum.mul_x2(x[0], x[15]);
  755|    134|   accum.mul_x2(x[1], x[14]);
  756|    134|   accum.mul_x2(x[2], x[13]);
  757|    134|   accum.mul_x2(x[3], x[12]);
  758|    134|   accum.mul_x2(x[4], x[11]);
  759|    134|   accum.mul_x2(x[5], x[10]);
  760|    134|   accum.mul_x2(x[6], x[9]);
  761|    134|   accum.mul_x2(x[7], x[8]);
  762|    134|   z[15] = accum.extract();
  763|    134|   accum.mul_x2(x[1], x[15]);
  764|    134|   accum.mul_x2(x[2], x[14]);
  765|    134|   accum.mul_x2(x[3], x[13]);
  766|    134|   accum.mul_x2(x[4], x[12]);
  767|    134|   accum.mul_x2(x[5], x[11]);
  768|    134|   accum.mul_x2(x[6], x[10]);
  769|    134|   accum.mul_x2(x[7], x[9]);
  770|    134|   accum.mul(x[8], x[8]);
  771|    134|   z[16] = accum.extract();
  772|    134|   accum.mul_x2(x[2], x[15]);
  773|    134|   accum.mul_x2(x[3], x[14]);
  774|    134|   accum.mul_x2(x[4], x[13]);
  775|    134|   accum.mul_x2(x[5], x[12]);
  776|    134|   accum.mul_x2(x[6], x[11]);
  777|    134|   accum.mul_x2(x[7], x[10]);
  778|    134|   accum.mul_x2(x[8], x[9]);
  779|    134|   z[17] = accum.extract();
  780|    134|   accum.mul_x2(x[3], x[15]);
  781|    134|   accum.mul_x2(x[4], x[14]);
  782|    134|   accum.mul_x2(x[5], x[13]);
  783|    134|   accum.mul_x2(x[6], x[12]);
  784|    134|   accum.mul_x2(x[7], x[11]);
  785|    134|   accum.mul_x2(x[8], x[10]);
  786|    134|   accum.mul(x[9], x[9]);
  787|    134|   z[18] = accum.extract();
  788|    134|   accum.mul_x2(x[4], x[15]);
  789|    134|   accum.mul_x2(x[5], x[14]);
  790|    134|   accum.mul_x2(x[6], x[13]);
  791|    134|   accum.mul_x2(x[7], x[12]);
  792|    134|   accum.mul_x2(x[8], x[11]);
  793|    134|   accum.mul_x2(x[9], x[10]);
  794|    134|   z[19] = accum.extract();
  795|    134|   accum.mul_x2(x[5], x[15]);
  796|    134|   accum.mul_x2(x[6], x[14]);
  797|    134|   accum.mul_x2(x[7], x[13]);
  798|    134|   accum.mul_x2(x[8], x[12]);
  799|    134|   accum.mul_x2(x[9], x[11]);
  800|    134|   accum.mul(x[10], x[10]);
  801|    134|   z[20] = accum.extract();
  802|    134|   accum.mul_x2(x[6], x[15]);
  803|    134|   accum.mul_x2(x[7], x[14]);
  804|    134|   accum.mul_x2(x[8], x[13]);
  805|    134|   accum.mul_x2(x[9], x[12]);
  806|    134|   accum.mul_x2(x[10], x[11]);
  807|    134|   z[21] = accum.extract();
  808|    134|   accum.mul_x2(x[7], x[15]);
  809|    134|   accum.mul_x2(x[8], x[14]);
  810|    134|   accum.mul_x2(x[9], x[13]);
  811|    134|   accum.mul_x2(x[10], x[12]);
  812|    134|   accum.mul(x[11], x[11]);
  813|    134|   z[22] = accum.extract();
  814|    134|   accum.mul_x2(x[8], x[15]);
  815|    134|   accum.mul_x2(x[9], x[14]);
  816|    134|   accum.mul_x2(x[10], x[13]);
  817|    134|   accum.mul_x2(x[11], x[12]);
  818|    134|   z[23] = accum.extract();
  819|    134|   accum.mul_x2(x[9], x[15]);
  820|    134|   accum.mul_x2(x[10], x[14]);
  821|    134|   accum.mul_x2(x[11], x[13]);
  822|    134|   accum.mul(x[12], x[12]);
  823|    134|   z[24] = accum.extract();
  824|    134|   accum.mul_x2(x[10], x[15]);
  825|    134|   accum.mul_x2(x[11], x[14]);
  826|    134|   accum.mul_x2(x[12], x[13]);
  827|    134|   z[25] = accum.extract();
  828|    134|   accum.mul_x2(x[11], x[15]);
  829|    134|   accum.mul_x2(x[12], x[14]);
  830|    134|   accum.mul(x[13], x[13]);
  831|    134|   z[26] = accum.extract();
  832|    134|   accum.mul_x2(x[12], x[15]);
  833|    134|   accum.mul_x2(x[13], x[14]);
  834|    134|   z[27] = accum.extract();
  835|    134|   accum.mul_x2(x[13], x[15]);
  836|    134|   accum.mul(x[14], x[14]);
  837|    134|   z[28] = accum.extract();
  838|    134|   accum.mul_x2(x[14], x[15]);
  839|    134|   z[29] = accum.extract();
  840|    134|   accum.mul(x[15], x[15]);
  841|    134|   z[30] = accum.extract();
  842|    134|   z[31] = accum.extract();
  843|    134|}
_ZN5Botan18bigint_comba_mul16EPmPKmS2_:
  848|    290|void bigint_comba_mul16(word z[32], const word x[16], const word y[16]) {
  849|    290|   word3<word> accum;
  850|       |
  851|    290|   accum.mul(x[0], y[0]);
  852|    290|   z[0] = accum.extract();
  853|    290|   accum.mul(x[0], y[1]);
  854|    290|   accum.mul(x[1], y[0]);
  855|    290|   z[1] = accum.extract();
  856|    290|   accum.mul(x[0], y[2]);
  857|    290|   accum.mul(x[1], y[1]);
  858|    290|   accum.mul(x[2], y[0]);
  859|    290|   z[2] = accum.extract();
  860|    290|   accum.mul(x[0], y[3]);
  861|    290|   accum.mul(x[1], y[2]);
  862|    290|   accum.mul(x[2], y[1]);
  863|    290|   accum.mul(x[3], y[0]);
  864|    290|   z[3] = accum.extract();
  865|    290|   accum.mul(x[0], y[4]);
  866|    290|   accum.mul(x[1], y[3]);
  867|    290|   accum.mul(x[2], y[2]);
  868|    290|   accum.mul(x[3], y[1]);
  869|    290|   accum.mul(x[4], y[0]);
  870|    290|   z[4] = accum.extract();
  871|    290|   accum.mul(x[0], y[5]);
  872|    290|   accum.mul(x[1], y[4]);
  873|    290|   accum.mul(x[2], y[3]);
  874|    290|   accum.mul(x[3], y[2]);
  875|    290|   accum.mul(x[4], y[1]);
  876|    290|   accum.mul(x[5], y[0]);
  877|    290|   z[5] = accum.extract();
  878|    290|   accum.mul(x[0], y[6]);
  879|    290|   accum.mul(x[1], y[5]);
  880|    290|   accum.mul(x[2], y[4]);
  881|    290|   accum.mul(x[3], y[3]);
  882|    290|   accum.mul(x[4], y[2]);
  883|    290|   accum.mul(x[5], y[1]);
  884|    290|   accum.mul(x[6], y[0]);
  885|    290|   z[6] = accum.extract();
  886|    290|   accum.mul(x[0], y[7]);
  887|    290|   accum.mul(x[1], y[6]);
  888|    290|   accum.mul(x[2], y[5]);
  889|    290|   accum.mul(x[3], y[4]);
  890|    290|   accum.mul(x[4], y[3]);
  891|    290|   accum.mul(x[5], y[2]);
  892|    290|   accum.mul(x[6], y[1]);
  893|    290|   accum.mul(x[7], y[0]);
  894|    290|   z[7] = accum.extract();
  895|    290|   accum.mul(x[0], y[8]);
  896|    290|   accum.mul(x[1], y[7]);
  897|    290|   accum.mul(x[2], y[6]);
  898|    290|   accum.mul(x[3], y[5]);
  899|    290|   accum.mul(x[4], y[4]);
  900|    290|   accum.mul(x[5], y[3]);
  901|    290|   accum.mul(x[6], y[2]);
  902|    290|   accum.mul(x[7], y[1]);
  903|    290|   accum.mul(x[8], y[0]);
  904|    290|   z[8] = accum.extract();
  905|    290|   accum.mul(x[0], y[9]);
  906|    290|   accum.mul(x[1], y[8]);
  907|    290|   accum.mul(x[2], y[7]);
  908|    290|   accum.mul(x[3], y[6]);
  909|    290|   accum.mul(x[4], y[5]);
  910|    290|   accum.mul(x[5], y[4]);
  911|    290|   accum.mul(x[6], y[3]);
  912|    290|   accum.mul(x[7], y[2]);
  913|    290|   accum.mul(x[8], y[1]);
  914|    290|   accum.mul(x[9], y[0]);
  915|    290|   z[9] = accum.extract();
  916|    290|   accum.mul(x[0], y[10]);
  917|    290|   accum.mul(x[1], y[9]);
  918|    290|   accum.mul(x[2], y[8]);
  919|    290|   accum.mul(x[3], y[7]);
  920|    290|   accum.mul(x[4], y[6]);
  921|    290|   accum.mul(x[5], y[5]);
  922|    290|   accum.mul(x[6], y[4]);
  923|    290|   accum.mul(x[7], y[3]);
  924|    290|   accum.mul(x[8], y[2]);
  925|    290|   accum.mul(x[9], y[1]);
  926|    290|   accum.mul(x[10], y[0]);
  927|    290|   z[10] = accum.extract();
  928|    290|   accum.mul(x[0], y[11]);
  929|    290|   accum.mul(x[1], y[10]);
  930|    290|   accum.mul(x[2], y[9]);
  931|    290|   accum.mul(x[3], y[8]);
  932|    290|   accum.mul(x[4], y[7]);
  933|    290|   accum.mul(x[5], y[6]);
  934|    290|   accum.mul(x[6], y[5]);
  935|    290|   accum.mul(x[7], y[4]);
  936|    290|   accum.mul(x[8], y[3]);
  937|    290|   accum.mul(x[9], y[2]);
  938|    290|   accum.mul(x[10], y[1]);
  939|    290|   accum.mul(x[11], y[0]);
  940|    290|   z[11] = accum.extract();
  941|    290|   accum.mul(x[0], y[12]);
  942|    290|   accum.mul(x[1], y[11]);
  943|    290|   accum.mul(x[2], y[10]);
  944|    290|   accum.mul(x[3], y[9]);
  945|    290|   accum.mul(x[4], y[8]);
  946|    290|   accum.mul(x[5], y[7]);
  947|    290|   accum.mul(x[6], y[6]);
  948|    290|   accum.mul(x[7], y[5]);
  949|    290|   accum.mul(x[8], y[4]);
  950|    290|   accum.mul(x[9], y[3]);
  951|    290|   accum.mul(x[10], y[2]);
  952|    290|   accum.mul(x[11], y[1]);
  953|    290|   accum.mul(x[12], y[0]);
  954|    290|   z[12] = accum.extract();
  955|    290|   accum.mul(x[0], y[13]);
  956|    290|   accum.mul(x[1], y[12]);
  957|    290|   accum.mul(x[2], y[11]);
  958|    290|   accum.mul(x[3], y[10]);
  959|    290|   accum.mul(x[4], y[9]);
  960|    290|   accum.mul(x[5], y[8]);
  961|    290|   accum.mul(x[6], y[7]);
  962|    290|   accum.mul(x[7], y[6]);
  963|    290|   accum.mul(x[8], y[5]);
  964|    290|   accum.mul(x[9], y[4]);
  965|    290|   accum.mul(x[10], y[3]);
  966|    290|   accum.mul(x[11], y[2]);
  967|    290|   accum.mul(x[12], y[1]);
  968|    290|   accum.mul(x[13], y[0]);
  969|    290|   z[13] = accum.extract();
  970|    290|   accum.mul(x[0], y[14]);
  971|    290|   accum.mul(x[1], y[13]);
  972|    290|   accum.mul(x[2], y[12]);
  973|    290|   accum.mul(x[3], y[11]);
  974|    290|   accum.mul(x[4], y[10]);
  975|    290|   accum.mul(x[5], y[9]);
  976|    290|   accum.mul(x[6], y[8]);
  977|    290|   accum.mul(x[7], y[7]);
  978|    290|   accum.mul(x[8], y[6]);
  979|    290|   accum.mul(x[9], y[5]);
  980|    290|   accum.mul(x[10], y[4]);
  981|    290|   accum.mul(x[11], y[3]);
  982|    290|   accum.mul(x[12], y[2]);
  983|    290|   accum.mul(x[13], y[1]);
  984|    290|   accum.mul(x[14], y[0]);
  985|    290|   z[14] = accum.extract();
  986|    290|   accum.mul(x[0], y[15]);
  987|    290|   accum.mul(x[1], y[14]);
  988|    290|   accum.mul(x[2], y[13]);
  989|    290|   accum.mul(x[3], y[12]);
  990|    290|   accum.mul(x[4], y[11]);
  991|    290|   accum.mul(x[5], y[10]);
  992|    290|   accum.mul(x[6], y[9]);
  993|    290|   accum.mul(x[7], y[8]);
  994|    290|   accum.mul(x[8], y[7]);
  995|    290|   accum.mul(x[9], y[6]);
  996|    290|   accum.mul(x[10], y[5]);
  997|    290|   accum.mul(x[11], y[4]);
  998|    290|   accum.mul(x[12], y[3]);
  999|    290|   accum.mul(x[13], y[2]);
 1000|    290|   accum.mul(x[14], y[1]);
 1001|    290|   accum.mul(x[15], y[0]);
 1002|    290|   z[15] = accum.extract();
 1003|    290|   accum.mul(x[1], y[15]);
 1004|    290|   accum.mul(x[2], y[14]);
 1005|    290|   accum.mul(x[3], y[13]);
 1006|    290|   accum.mul(x[4], y[12]);
 1007|    290|   accum.mul(x[5], y[11]);
 1008|    290|   accum.mul(x[6], y[10]);
 1009|    290|   accum.mul(x[7], y[9]);
 1010|    290|   accum.mul(x[8], y[8]);
 1011|    290|   accum.mul(x[9], y[7]);
 1012|    290|   accum.mul(x[10], y[6]);
 1013|    290|   accum.mul(x[11], y[5]);
 1014|    290|   accum.mul(x[12], y[4]);
 1015|    290|   accum.mul(x[13], y[3]);
 1016|    290|   accum.mul(x[14], y[2]);
 1017|    290|   accum.mul(x[15], y[1]);
 1018|    290|   z[16] = accum.extract();
 1019|    290|   accum.mul(x[2], y[15]);
 1020|    290|   accum.mul(x[3], y[14]);
 1021|    290|   accum.mul(x[4], y[13]);
 1022|    290|   accum.mul(x[5], y[12]);
 1023|    290|   accum.mul(x[6], y[11]);
 1024|    290|   accum.mul(x[7], y[10]);
 1025|    290|   accum.mul(x[8], y[9]);
 1026|    290|   accum.mul(x[9], y[8]);
 1027|    290|   accum.mul(x[10], y[7]);
 1028|    290|   accum.mul(x[11], y[6]);
 1029|    290|   accum.mul(x[12], y[5]);
 1030|    290|   accum.mul(x[13], y[4]);
 1031|    290|   accum.mul(x[14], y[3]);
 1032|    290|   accum.mul(x[15], y[2]);
 1033|    290|   z[17] = accum.extract();
 1034|    290|   accum.mul(x[3], y[15]);
 1035|    290|   accum.mul(x[4], y[14]);
 1036|    290|   accum.mul(x[5], y[13]);
 1037|    290|   accum.mul(x[6], y[12]);
 1038|    290|   accum.mul(x[7], y[11]);
 1039|    290|   accum.mul(x[8], y[10]);
 1040|    290|   accum.mul(x[9], y[9]);
 1041|    290|   accum.mul(x[10], y[8]);
 1042|    290|   accum.mul(x[11], y[7]);
 1043|    290|   accum.mul(x[12], y[6]);
 1044|    290|   accum.mul(x[13], y[5]);
 1045|    290|   accum.mul(x[14], y[4]);
 1046|    290|   accum.mul(x[15], y[3]);
 1047|    290|   z[18] = accum.extract();
 1048|    290|   accum.mul(x[4], y[15]);
 1049|    290|   accum.mul(x[5], y[14]);
 1050|    290|   accum.mul(x[6], y[13]);
 1051|    290|   accum.mul(x[7], y[12]);
 1052|    290|   accum.mul(x[8], y[11]);
 1053|    290|   accum.mul(x[9], y[10]);
 1054|    290|   accum.mul(x[10], y[9]);
 1055|    290|   accum.mul(x[11], y[8]);
 1056|    290|   accum.mul(x[12], y[7]);
 1057|    290|   accum.mul(x[13], y[6]);
 1058|    290|   accum.mul(x[14], y[5]);
 1059|    290|   accum.mul(x[15], y[4]);
 1060|    290|   z[19] = accum.extract();
 1061|    290|   accum.mul(x[5], y[15]);
 1062|    290|   accum.mul(x[6], y[14]);
 1063|    290|   accum.mul(x[7], y[13]);
 1064|    290|   accum.mul(x[8], y[12]);
 1065|    290|   accum.mul(x[9], y[11]);
 1066|    290|   accum.mul(x[10], y[10]);
 1067|    290|   accum.mul(x[11], y[9]);
 1068|    290|   accum.mul(x[12], y[8]);
 1069|    290|   accum.mul(x[13], y[7]);
 1070|    290|   accum.mul(x[14], y[6]);
 1071|    290|   accum.mul(x[15], y[5]);
 1072|    290|   z[20] = accum.extract();
 1073|    290|   accum.mul(x[6], y[15]);
 1074|    290|   accum.mul(x[7], y[14]);
 1075|    290|   accum.mul(x[8], y[13]);
 1076|    290|   accum.mul(x[9], y[12]);
 1077|    290|   accum.mul(x[10], y[11]);
 1078|    290|   accum.mul(x[11], y[10]);
 1079|    290|   accum.mul(x[12], y[9]);
 1080|    290|   accum.mul(x[13], y[8]);
 1081|    290|   accum.mul(x[14], y[7]);
 1082|    290|   accum.mul(x[15], y[6]);
 1083|    290|   z[21] = accum.extract();
 1084|    290|   accum.mul(x[7], y[15]);
 1085|    290|   accum.mul(x[8], y[14]);
 1086|    290|   accum.mul(x[9], y[13]);
 1087|    290|   accum.mul(x[10], y[12]);
 1088|    290|   accum.mul(x[11], y[11]);
 1089|    290|   accum.mul(x[12], y[10]);
 1090|    290|   accum.mul(x[13], y[9]);
 1091|    290|   accum.mul(x[14], y[8]);
 1092|    290|   accum.mul(x[15], y[7]);
 1093|    290|   z[22] = accum.extract();
 1094|    290|   accum.mul(x[8], y[15]);
 1095|    290|   accum.mul(x[9], y[14]);
 1096|    290|   accum.mul(x[10], y[13]);
 1097|    290|   accum.mul(x[11], y[12]);
 1098|    290|   accum.mul(x[12], y[11]);
 1099|    290|   accum.mul(x[13], y[10]);
 1100|    290|   accum.mul(x[14], y[9]);
 1101|    290|   accum.mul(x[15], y[8]);
 1102|    290|   z[23] = accum.extract();
 1103|    290|   accum.mul(x[9], y[15]);
 1104|    290|   accum.mul(x[10], y[14]);
 1105|    290|   accum.mul(x[11], y[13]);
 1106|    290|   accum.mul(x[12], y[12]);
 1107|    290|   accum.mul(x[13], y[11]);
 1108|    290|   accum.mul(x[14], y[10]);
 1109|    290|   accum.mul(x[15], y[9]);
 1110|    290|   z[24] = accum.extract();
 1111|    290|   accum.mul(x[10], y[15]);
 1112|    290|   accum.mul(x[11], y[14]);
 1113|    290|   accum.mul(x[12], y[13]);
 1114|    290|   accum.mul(x[13], y[12]);
 1115|    290|   accum.mul(x[14], y[11]);
 1116|    290|   accum.mul(x[15], y[10]);
 1117|    290|   z[25] = accum.extract();
 1118|    290|   accum.mul(x[11], y[15]);
 1119|    290|   accum.mul(x[12], y[14]);
 1120|    290|   accum.mul(x[13], y[13]);
 1121|    290|   accum.mul(x[14], y[12]);
 1122|    290|   accum.mul(x[15], y[11]);
 1123|    290|   z[26] = accum.extract();
 1124|    290|   accum.mul(x[12], y[15]);
 1125|    290|   accum.mul(x[13], y[14]);
 1126|    290|   accum.mul(x[14], y[13]);
 1127|    290|   accum.mul(x[15], y[12]);
 1128|    290|   z[27] = accum.extract();
 1129|    290|   accum.mul(x[13], y[15]);
 1130|    290|   accum.mul(x[14], y[14]);
 1131|    290|   accum.mul(x[15], y[13]);
 1132|    290|   z[28] = accum.extract();
 1133|    290|   accum.mul(x[14], y[15]);
 1134|    290|   accum.mul(x[15], y[14]);
 1135|    290|   z[29] = accum.extract();
 1136|    290|   accum.mul(x[15], y[15]);
 1137|    290|   z[30] = accum.extract();
 1138|    290|   z[31] = accum.extract();
 1139|    290|}
_ZN5Botan18bigint_comba_sqr24EPmPKm:
 1144|     13|void bigint_comba_sqr24(word z[48], const word x[24]) {
 1145|     13|   word3<word> accum;
 1146|       |
 1147|     13|   accum.mul(x[0], x[0]);
 1148|     13|   z[0] = accum.extract();
 1149|     13|   accum.mul_x2(x[0], x[1]);
 1150|     13|   z[1] = accum.extract();
 1151|     13|   accum.mul_x2(x[0], x[2]);
 1152|     13|   accum.mul(x[1], x[1]);
 1153|     13|   z[2] = accum.extract();
 1154|     13|   accum.mul_x2(x[0], x[3]);
 1155|     13|   accum.mul_x2(x[1], x[2]);
 1156|     13|   z[3] = accum.extract();
 1157|     13|   accum.mul_x2(x[0], x[4]);
 1158|     13|   accum.mul_x2(x[1], x[3]);
 1159|     13|   accum.mul(x[2], x[2]);
 1160|     13|   z[4] = accum.extract();
 1161|     13|   accum.mul_x2(x[0], x[5]);
 1162|     13|   accum.mul_x2(x[1], x[4]);
 1163|     13|   accum.mul_x2(x[2], x[3]);
 1164|     13|   z[5] = accum.extract();
 1165|     13|   accum.mul_x2(x[0], x[6]);
 1166|     13|   accum.mul_x2(x[1], x[5]);
 1167|     13|   accum.mul_x2(x[2], x[4]);
 1168|     13|   accum.mul(x[3], x[3]);
 1169|     13|   z[6] = accum.extract();
 1170|     13|   accum.mul_x2(x[0], x[7]);
 1171|     13|   accum.mul_x2(x[1], x[6]);
 1172|     13|   accum.mul_x2(x[2], x[5]);
 1173|     13|   accum.mul_x2(x[3], x[4]);
 1174|     13|   z[7] = accum.extract();
 1175|     13|   accum.mul_x2(x[0], x[8]);
 1176|     13|   accum.mul_x2(x[1], x[7]);
 1177|     13|   accum.mul_x2(x[2], x[6]);
 1178|     13|   accum.mul_x2(x[3], x[5]);
 1179|     13|   accum.mul(x[4], x[4]);
 1180|     13|   z[8] = accum.extract();
 1181|     13|   accum.mul_x2(x[0], x[9]);
 1182|     13|   accum.mul_x2(x[1], x[8]);
 1183|     13|   accum.mul_x2(x[2], x[7]);
 1184|     13|   accum.mul_x2(x[3], x[6]);
 1185|     13|   accum.mul_x2(x[4], x[5]);
 1186|     13|   z[9] = accum.extract();
 1187|     13|   accum.mul_x2(x[0], x[10]);
 1188|     13|   accum.mul_x2(x[1], x[9]);
 1189|     13|   accum.mul_x2(x[2], x[8]);
 1190|     13|   accum.mul_x2(x[3], x[7]);
 1191|     13|   accum.mul_x2(x[4], x[6]);
 1192|     13|   accum.mul(x[5], x[5]);
 1193|     13|   z[10] = accum.extract();
 1194|     13|   accum.mul_x2(x[0], x[11]);
 1195|     13|   accum.mul_x2(x[1], x[10]);
 1196|     13|   accum.mul_x2(x[2], x[9]);
 1197|     13|   accum.mul_x2(x[3], x[8]);
 1198|     13|   accum.mul_x2(x[4], x[7]);
 1199|     13|   accum.mul_x2(x[5], x[6]);
 1200|     13|   z[11] = accum.extract();
 1201|     13|   accum.mul_x2(x[0], x[12]);
 1202|     13|   accum.mul_x2(x[1], x[11]);
 1203|     13|   accum.mul_x2(x[2], x[10]);
 1204|     13|   accum.mul_x2(x[3], x[9]);
 1205|     13|   accum.mul_x2(x[4], x[8]);
 1206|     13|   accum.mul_x2(x[5], x[7]);
 1207|     13|   accum.mul(x[6], x[6]);
 1208|     13|   z[12] = accum.extract();
 1209|     13|   accum.mul_x2(x[0], x[13]);
 1210|     13|   accum.mul_x2(x[1], x[12]);
 1211|     13|   accum.mul_x2(x[2], x[11]);
 1212|     13|   accum.mul_x2(x[3], x[10]);
 1213|     13|   accum.mul_x2(x[4], x[9]);
 1214|     13|   accum.mul_x2(x[5], x[8]);
 1215|     13|   accum.mul_x2(x[6], x[7]);
 1216|     13|   z[13] = accum.extract();
 1217|     13|   accum.mul_x2(x[0], x[14]);
 1218|     13|   accum.mul_x2(x[1], x[13]);
 1219|     13|   accum.mul_x2(x[2], x[12]);
 1220|     13|   accum.mul_x2(x[3], x[11]);
 1221|     13|   accum.mul_x2(x[4], x[10]);
 1222|     13|   accum.mul_x2(x[5], x[9]);
 1223|     13|   accum.mul_x2(x[6], x[8]);
 1224|     13|   accum.mul(x[7], x[7]);
 1225|     13|   z[14] = accum.extract();
 1226|     13|   accum.mul_x2(x[0], x[15]);
 1227|     13|   accum.mul_x2(x[1], x[14]);
 1228|     13|   accum.mul_x2(x[2], x[13]);
 1229|     13|   accum.mul_x2(x[3], x[12]);
 1230|     13|   accum.mul_x2(x[4], x[11]);
 1231|     13|   accum.mul_x2(x[5], x[10]);
 1232|     13|   accum.mul_x2(x[6], x[9]);
 1233|     13|   accum.mul_x2(x[7], x[8]);
 1234|     13|   z[15] = accum.extract();
 1235|     13|   accum.mul_x2(x[0], x[16]);
 1236|     13|   accum.mul_x2(x[1], x[15]);
 1237|     13|   accum.mul_x2(x[2], x[14]);
 1238|     13|   accum.mul_x2(x[3], x[13]);
 1239|     13|   accum.mul_x2(x[4], x[12]);
 1240|     13|   accum.mul_x2(x[5], x[11]);
 1241|     13|   accum.mul_x2(x[6], x[10]);
 1242|     13|   accum.mul_x2(x[7], x[9]);
 1243|     13|   accum.mul(x[8], x[8]);
 1244|     13|   z[16] = accum.extract();
 1245|     13|   accum.mul_x2(x[0], x[17]);
 1246|     13|   accum.mul_x2(x[1], x[16]);
 1247|     13|   accum.mul_x2(x[2], x[15]);
 1248|     13|   accum.mul_x2(x[3], x[14]);
 1249|     13|   accum.mul_x2(x[4], x[13]);
 1250|     13|   accum.mul_x2(x[5], x[12]);
 1251|     13|   accum.mul_x2(x[6], x[11]);
 1252|     13|   accum.mul_x2(x[7], x[10]);
 1253|     13|   accum.mul_x2(x[8], x[9]);
 1254|     13|   z[17] = accum.extract();
 1255|     13|   accum.mul_x2(x[0], x[18]);
 1256|     13|   accum.mul_x2(x[1], x[17]);
 1257|     13|   accum.mul_x2(x[2], x[16]);
 1258|     13|   accum.mul_x2(x[3], x[15]);
 1259|     13|   accum.mul_x2(x[4], x[14]);
 1260|     13|   accum.mul_x2(x[5], x[13]);
 1261|     13|   accum.mul_x2(x[6], x[12]);
 1262|     13|   accum.mul_x2(x[7], x[11]);
 1263|     13|   accum.mul_x2(x[8], x[10]);
 1264|     13|   accum.mul(x[9], x[9]);
 1265|     13|   z[18] = accum.extract();
 1266|     13|   accum.mul_x2(x[0], x[19]);
 1267|     13|   accum.mul_x2(x[1], x[18]);
 1268|     13|   accum.mul_x2(x[2], x[17]);
 1269|     13|   accum.mul_x2(x[3], x[16]);
 1270|     13|   accum.mul_x2(x[4], x[15]);
 1271|     13|   accum.mul_x2(x[5], x[14]);
 1272|     13|   accum.mul_x2(x[6], x[13]);
 1273|     13|   accum.mul_x2(x[7], x[12]);
 1274|     13|   accum.mul_x2(x[8], x[11]);
 1275|     13|   accum.mul_x2(x[9], x[10]);
 1276|     13|   z[19] = accum.extract();
 1277|     13|   accum.mul_x2(x[0], x[20]);
 1278|     13|   accum.mul_x2(x[1], x[19]);
 1279|     13|   accum.mul_x2(x[2], x[18]);
 1280|     13|   accum.mul_x2(x[3], x[17]);
 1281|     13|   accum.mul_x2(x[4], x[16]);
 1282|     13|   accum.mul_x2(x[5], x[15]);
 1283|     13|   accum.mul_x2(x[6], x[14]);
 1284|     13|   accum.mul_x2(x[7], x[13]);
 1285|     13|   accum.mul_x2(x[8], x[12]);
 1286|     13|   accum.mul_x2(x[9], x[11]);
 1287|     13|   accum.mul(x[10], x[10]);
 1288|     13|   z[20] = accum.extract();
 1289|     13|   accum.mul_x2(x[0], x[21]);
 1290|     13|   accum.mul_x2(x[1], x[20]);
 1291|     13|   accum.mul_x2(x[2], x[19]);
 1292|     13|   accum.mul_x2(x[3], x[18]);
 1293|     13|   accum.mul_x2(x[4], x[17]);
 1294|     13|   accum.mul_x2(x[5], x[16]);
 1295|     13|   accum.mul_x2(x[6], x[15]);
 1296|     13|   accum.mul_x2(x[7], x[14]);
 1297|     13|   accum.mul_x2(x[8], x[13]);
 1298|     13|   accum.mul_x2(x[9], x[12]);
 1299|     13|   accum.mul_x2(x[10], x[11]);
 1300|     13|   z[21] = accum.extract();
 1301|     13|   accum.mul_x2(x[0], x[22]);
 1302|     13|   accum.mul_x2(x[1], x[21]);
 1303|     13|   accum.mul_x2(x[2], x[20]);
 1304|     13|   accum.mul_x2(x[3], x[19]);
 1305|     13|   accum.mul_x2(x[4], x[18]);
 1306|     13|   accum.mul_x2(x[5], x[17]);
 1307|     13|   accum.mul_x2(x[6], x[16]);
 1308|     13|   accum.mul_x2(x[7], x[15]);
 1309|     13|   accum.mul_x2(x[8], x[14]);
 1310|     13|   accum.mul_x2(x[9], x[13]);
 1311|     13|   accum.mul_x2(x[10], x[12]);
 1312|     13|   accum.mul(x[11], x[11]);
 1313|     13|   z[22] = accum.extract();
 1314|     13|   accum.mul_x2(x[0], x[23]);
 1315|     13|   accum.mul_x2(x[1], x[22]);
 1316|     13|   accum.mul_x2(x[2], x[21]);
 1317|     13|   accum.mul_x2(x[3], x[20]);
 1318|     13|   accum.mul_x2(x[4], x[19]);
 1319|     13|   accum.mul_x2(x[5], x[18]);
 1320|     13|   accum.mul_x2(x[6], x[17]);
 1321|     13|   accum.mul_x2(x[7], x[16]);
 1322|     13|   accum.mul_x2(x[8], x[15]);
 1323|     13|   accum.mul_x2(x[9], x[14]);
 1324|     13|   accum.mul_x2(x[10], x[13]);
 1325|     13|   accum.mul_x2(x[11], x[12]);
 1326|     13|   z[23] = accum.extract();
 1327|     13|   accum.mul_x2(x[1], x[23]);
 1328|     13|   accum.mul_x2(x[2], x[22]);
 1329|     13|   accum.mul_x2(x[3], x[21]);
 1330|     13|   accum.mul_x2(x[4], x[20]);
 1331|     13|   accum.mul_x2(x[5], x[19]);
 1332|     13|   accum.mul_x2(x[6], x[18]);
 1333|     13|   accum.mul_x2(x[7], x[17]);
 1334|     13|   accum.mul_x2(x[8], x[16]);
 1335|     13|   accum.mul_x2(x[9], x[15]);
 1336|     13|   accum.mul_x2(x[10], x[14]);
 1337|     13|   accum.mul_x2(x[11], x[13]);
 1338|     13|   accum.mul(x[12], x[12]);
 1339|     13|   z[24] = accum.extract();
 1340|     13|   accum.mul_x2(x[2], x[23]);
 1341|     13|   accum.mul_x2(x[3], x[22]);
 1342|     13|   accum.mul_x2(x[4], x[21]);
 1343|     13|   accum.mul_x2(x[5], x[20]);
 1344|     13|   accum.mul_x2(x[6], x[19]);
 1345|     13|   accum.mul_x2(x[7], x[18]);
 1346|     13|   accum.mul_x2(x[8], x[17]);
 1347|     13|   accum.mul_x2(x[9], x[16]);
 1348|     13|   accum.mul_x2(x[10], x[15]);
 1349|     13|   accum.mul_x2(x[11], x[14]);
 1350|     13|   accum.mul_x2(x[12], x[13]);
 1351|     13|   z[25] = accum.extract();
 1352|     13|   accum.mul_x2(x[3], x[23]);
 1353|     13|   accum.mul_x2(x[4], x[22]);
 1354|     13|   accum.mul_x2(x[5], x[21]);
 1355|     13|   accum.mul_x2(x[6], x[20]);
 1356|     13|   accum.mul_x2(x[7], x[19]);
 1357|     13|   accum.mul_x2(x[8], x[18]);
 1358|     13|   accum.mul_x2(x[9], x[17]);
 1359|     13|   accum.mul_x2(x[10], x[16]);
 1360|     13|   accum.mul_x2(x[11], x[15]);
 1361|     13|   accum.mul_x2(x[12], x[14]);
 1362|     13|   accum.mul(x[13], x[13]);
 1363|     13|   z[26] = accum.extract();
 1364|     13|   accum.mul_x2(x[4], x[23]);
 1365|     13|   accum.mul_x2(x[5], x[22]);
 1366|     13|   accum.mul_x2(x[6], x[21]);
 1367|     13|   accum.mul_x2(x[7], x[20]);
 1368|     13|   accum.mul_x2(x[8], x[19]);
 1369|     13|   accum.mul_x2(x[9], x[18]);
 1370|     13|   accum.mul_x2(x[10], x[17]);
 1371|     13|   accum.mul_x2(x[11], x[16]);
 1372|     13|   accum.mul_x2(x[12], x[15]);
 1373|     13|   accum.mul_x2(x[13], x[14]);
 1374|     13|   z[27] = accum.extract();
 1375|     13|   accum.mul_x2(x[5], x[23]);
 1376|     13|   accum.mul_x2(x[6], x[22]);
 1377|     13|   accum.mul_x2(x[7], x[21]);
 1378|     13|   accum.mul_x2(x[8], x[20]);
 1379|     13|   accum.mul_x2(x[9], x[19]);
 1380|     13|   accum.mul_x2(x[10], x[18]);
 1381|     13|   accum.mul_x2(x[11], x[17]);
 1382|     13|   accum.mul_x2(x[12], x[16]);
 1383|     13|   accum.mul_x2(x[13], x[15]);
 1384|     13|   accum.mul(x[14], x[14]);
 1385|     13|   z[28] = accum.extract();
 1386|     13|   accum.mul_x2(x[6], x[23]);
 1387|     13|   accum.mul_x2(x[7], x[22]);
 1388|     13|   accum.mul_x2(x[8], x[21]);
 1389|     13|   accum.mul_x2(x[9], x[20]);
 1390|     13|   accum.mul_x2(x[10], x[19]);
 1391|     13|   accum.mul_x2(x[11], x[18]);
 1392|     13|   accum.mul_x2(x[12], x[17]);
 1393|     13|   accum.mul_x2(x[13], x[16]);
 1394|     13|   accum.mul_x2(x[14], x[15]);
 1395|     13|   z[29] = accum.extract();
 1396|     13|   accum.mul_x2(x[7], x[23]);
 1397|     13|   accum.mul_x2(x[8], x[22]);
 1398|     13|   accum.mul_x2(x[9], x[21]);
 1399|     13|   accum.mul_x2(x[10], x[20]);
 1400|     13|   accum.mul_x2(x[11], x[19]);
 1401|     13|   accum.mul_x2(x[12], x[18]);
 1402|     13|   accum.mul_x2(x[13], x[17]);
 1403|     13|   accum.mul_x2(x[14], x[16]);
 1404|     13|   accum.mul(x[15], x[15]);
 1405|     13|   z[30] = accum.extract();
 1406|     13|   accum.mul_x2(x[8], x[23]);
 1407|     13|   accum.mul_x2(x[9], x[22]);
 1408|     13|   accum.mul_x2(x[10], x[21]);
 1409|     13|   accum.mul_x2(x[11], x[20]);
 1410|     13|   accum.mul_x2(x[12], x[19]);
 1411|     13|   accum.mul_x2(x[13], x[18]);
 1412|     13|   accum.mul_x2(x[14], x[17]);
 1413|     13|   accum.mul_x2(x[15], x[16]);
 1414|     13|   z[31] = accum.extract();
 1415|     13|   accum.mul_x2(x[9], x[23]);
 1416|     13|   accum.mul_x2(x[10], x[22]);
 1417|     13|   accum.mul_x2(x[11], x[21]);
 1418|     13|   accum.mul_x2(x[12], x[20]);
 1419|     13|   accum.mul_x2(x[13], x[19]);
 1420|     13|   accum.mul_x2(x[14], x[18]);
 1421|     13|   accum.mul_x2(x[15], x[17]);
 1422|     13|   accum.mul(x[16], x[16]);
 1423|     13|   z[32] = accum.extract();
 1424|     13|   accum.mul_x2(x[10], x[23]);
 1425|     13|   accum.mul_x2(x[11], x[22]);
 1426|     13|   accum.mul_x2(x[12], x[21]);
 1427|     13|   accum.mul_x2(x[13], x[20]);
 1428|     13|   accum.mul_x2(x[14], x[19]);
 1429|     13|   accum.mul_x2(x[15], x[18]);
 1430|     13|   accum.mul_x2(x[16], x[17]);
 1431|     13|   z[33] = accum.extract();
 1432|     13|   accum.mul_x2(x[11], x[23]);
 1433|     13|   accum.mul_x2(x[12], x[22]);
 1434|     13|   accum.mul_x2(x[13], x[21]);
 1435|     13|   accum.mul_x2(x[14], x[20]);
 1436|     13|   accum.mul_x2(x[15], x[19]);
 1437|     13|   accum.mul_x2(x[16], x[18]);
 1438|     13|   accum.mul(x[17], x[17]);
 1439|     13|   z[34] = accum.extract();
 1440|     13|   accum.mul_x2(x[12], x[23]);
 1441|     13|   accum.mul_x2(x[13], x[22]);
 1442|     13|   accum.mul_x2(x[14], x[21]);
 1443|     13|   accum.mul_x2(x[15], x[20]);
 1444|     13|   accum.mul_x2(x[16], x[19]);
 1445|     13|   accum.mul_x2(x[17], x[18]);
 1446|     13|   z[35] = accum.extract();
 1447|     13|   accum.mul_x2(x[13], x[23]);
 1448|     13|   accum.mul_x2(x[14], x[22]);
 1449|     13|   accum.mul_x2(x[15], x[21]);
 1450|     13|   accum.mul_x2(x[16], x[20]);
 1451|     13|   accum.mul_x2(x[17], x[19]);
 1452|     13|   accum.mul(x[18], x[18]);
 1453|     13|   z[36] = accum.extract();
 1454|     13|   accum.mul_x2(x[14], x[23]);
 1455|     13|   accum.mul_x2(x[15], x[22]);
 1456|     13|   accum.mul_x2(x[16], x[21]);
 1457|     13|   accum.mul_x2(x[17], x[20]);
 1458|     13|   accum.mul_x2(x[18], x[19]);
 1459|     13|   z[37] = accum.extract();
 1460|     13|   accum.mul_x2(x[15], x[23]);
 1461|     13|   accum.mul_x2(x[16], x[22]);
 1462|     13|   accum.mul_x2(x[17], x[21]);
 1463|     13|   accum.mul_x2(x[18], x[20]);
 1464|     13|   accum.mul(x[19], x[19]);
 1465|     13|   z[38] = accum.extract();
 1466|     13|   accum.mul_x2(x[16], x[23]);
 1467|     13|   accum.mul_x2(x[17], x[22]);
 1468|     13|   accum.mul_x2(x[18], x[21]);
 1469|     13|   accum.mul_x2(x[19], x[20]);
 1470|     13|   z[39] = accum.extract();
 1471|     13|   accum.mul_x2(x[17], x[23]);
 1472|     13|   accum.mul_x2(x[18], x[22]);
 1473|     13|   accum.mul_x2(x[19], x[21]);
 1474|     13|   accum.mul(x[20], x[20]);
 1475|     13|   z[40] = accum.extract();
 1476|     13|   accum.mul_x2(x[18], x[23]);
 1477|     13|   accum.mul_x2(x[19], x[22]);
 1478|     13|   accum.mul_x2(x[20], x[21]);
 1479|     13|   z[41] = accum.extract();
 1480|     13|   accum.mul_x2(x[19], x[23]);
 1481|     13|   accum.mul_x2(x[20], x[22]);
 1482|     13|   accum.mul(x[21], x[21]);
 1483|     13|   z[42] = accum.extract();
 1484|     13|   accum.mul_x2(x[20], x[23]);
 1485|     13|   accum.mul_x2(x[21], x[22]);
 1486|     13|   z[43] = accum.extract();
 1487|     13|   accum.mul_x2(x[21], x[23]);
 1488|     13|   accum.mul(x[22], x[22]);
 1489|     13|   z[44] = accum.extract();
 1490|     13|   accum.mul_x2(x[22], x[23]);
 1491|     13|   z[45] = accum.extract();
 1492|     13|   accum.mul(x[23], x[23]);
 1493|     13|   z[46] = accum.extract();
 1494|     13|   z[47] = accum.extract();
 1495|     13|}
_ZN5Botan18bigint_comba_mul24EPmPKmS2_:
 1500|     57|void bigint_comba_mul24(word z[48], const word x[24], const word y[24]) {
 1501|     57|   word3<word> accum;
 1502|       |
 1503|     57|   accum.mul(x[0], y[0]);
 1504|     57|   z[0] = accum.extract();
 1505|     57|   accum.mul(x[0], y[1]);
 1506|     57|   accum.mul(x[1], y[0]);
 1507|     57|   z[1] = accum.extract();
 1508|     57|   accum.mul(x[0], y[2]);
 1509|     57|   accum.mul(x[1], y[1]);
 1510|     57|   accum.mul(x[2], y[0]);
 1511|     57|   z[2] = accum.extract();
 1512|     57|   accum.mul(x[0], y[3]);
 1513|     57|   accum.mul(x[1], y[2]);
 1514|     57|   accum.mul(x[2], y[1]);
 1515|     57|   accum.mul(x[3], y[0]);
 1516|     57|   z[3] = accum.extract();
 1517|     57|   accum.mul(x[0], y[4]);
 1518|     57|   accum.mul(x[1], y[3]);
 1519|     57|   accum.mul(x[2], y[2]);
 1520|     57|   accum.mul(x[3], y[1]);
 1521|     57|   accum.mul(x[4], y[0]);
 1522|     57|   z[4] = accum.extract();
 1523|     57|   accum.mul(x[0], y[5]);
 1524|     57|   accum.mul(x[1], y[4]);
 1525|     57|   accum.mul(x[2], y[3]);
 1526|     57|   accum.mul(x[3], y[2]);
 1527|     57|   accum.mul(x[4], y[1]);
 1528|     57|   accum.mul(x[5], y[0]);
 1529|     57|   z[5] = accum.extract();
 1530|     57|   accum.mul(x[0], y[6]);
 1531|     57|   accum.mul(x[1], y[5]);
 1532|     57|   accum.mul(x[2], y[4]);
 1533|     57|   accum.mul(x[3], y[3]);
 1534|     57|   accum.mul(x[4], y[2]);
 1535|     57|   accum.mul(x[5], y[1]);
 1536|     57|   accum.mul(x[6], y[0]);
 1537|     57|   z[6] = accum.extract();
 1538|     57|   accum.mul(x[0], y[7]);
 1539|     57|   accum.mul(x[1], y[6]);
 1540|     57|   accum.mul(x[2], y[5]);
 1541|     57|   accum.mul(x[3], y[4]);
 1542|     57|   accum.mul(x[4], y[3]);
 1543|     57|   accum.mul(x[5], y[2]);
 1544|     57|   accum.mul(x[6], y[1]);
 1545|     57|   accum.mul(x[7], y[0]);
 1546|     57|   z[7] = accum.extract();
 1547|     57|   accum.mul(x[0], y[8]);
 1548|     57|   accum.mul(x[1], y[7]);
 1549|     57|   accum.mul(x[2], y[6]);
 1550|     57|   accum.mul(x[3], y[5]);
 1551|     57|   accum.mul(x[4], y[4]);
 1552|     57|   accum.mul(x[5], y[3]);
 1553|     57|   accum.mul(x[6], y[2]);
 1554|     57|   accum.mul(x[7], y[1]);
 1555|     57|   accum.mul(x[8], y[0]);
 1556|     57|   z[8] = accum.extract();
 1557|     57|   accum.mul(x[0], y[9]);
 1558|     57|   accum.mul(x[1], y[8]);
 1559|     57|   accum.mul(x[2], y[7]);
 1560|     57|   accum.mul(x[3], y[6]);
 1561|     57|   accum.mul(x[4], y[5]);
 1562|     57|   accum.mul(x[5], y[4]);
 1563|     57|   accum.mul(x[6], y[3]);
 1564|     57|   accum.mul(x[7], y[2]);
 1565|     57|   accum.mul(x[8], y[1]);
 1566|     57|   accum.mul(x[9], y[0]);
 1567|     57|   z[9] = accum.extract();
 1568|     57|   accum.mul(x[0], y[10]);
 1569|     57|   accum.mul(x[1], y[9]);
 1570|     57|   accum.mul(x[2], y[8]);
 1571|     57|   accum.mul(x[3], y[7]);
 1572|     57|   accum.mul(x[4], y[6]);
 1573|     57|   accum.mul(x[5], y[5]);
 1574|     57|   accum.mul(x[6], y[4]);
 1575|     57|   accum.mul(x[7], y[3]);
 1576|     57|   accum.mul(x[8], y[2]);
 1577|     57|   accum.mul(x[9], y[1]);
 1578|     57|   accum.mul(x[10], y[0]);
 1579|     57|   z[10] = accum.extract();
 1580|     57|   accum.mul(x[0], y[11]);
 1581|     57|   accum.mul(x[1], y[10]);
 1582|     57|   accum.mul(x[2], y[9]);
 1583|     57|   accum.mul(x[3], y[8]);
 1584|     57|   accum.mul(x[4], y[7]);
 1585|     57|   accum.mul(x[5], y[6]);
 1586|     57|   accum.mul(x[6], y[5]);
 1587|     57|   accum.mul(x[7], y[4]);
 1588|     57|   accum.mul(x[8], y[3]);
 1589|     57|   accum.mul(x[9], y[2]);
 1590|     57|   accum.mul(x[10], y[1]);
 1591|     57|   accum.mul(x[11], y[0]);
 1592|     57|   z[11] = accum.extract();
 1593|     57|   accum.mul(x[0], y[12]);
 1594|     57|   accum.mul(x[1], y[11]);
 1595|     57|   accum.mul(x[2], y[10]);
 1596|     57|   accum.mul(x[3], y[9]);
 1597|     57|   accum.mul(x[4], y[8]);
 1598|     57|   accum.mul(x[5], y[7]);
 1599|     57|   accum.mul(x[6], y[6]);
 1600|     57|   accum.mul(x[7], y[5]);
 1601|     57|   accum.mul(x[8], y[4]);
 1602|     57|   accum.mul(x[9], y[3]);
 1603|     57|   accum.mul(x[10], y[2]);
 1604|     57|   accum.mul(x[11], y[1]);
 1605|     57|   accum.mul(x[12], y[0]);
 1606|     57|   z[12] = accum.extract();
 1607|     57|   accum.mul(x[0], y[13]);
 1608|     57|   accum.mul(x[1], y[12]);
 1609|     57|   accum.mul(x[2], y[11]);
 1610|     57|   accum.mul(x[3], y[10]);
 1611|     57|   accum.mul(x[4], y[9]);
 1612|     57|   accum.mul(x[5], y[8]);
 1613|     57|   accum.mul(x[6], y[7]);
 1614|     57|   accum.mul(x[7], y[6]);
 1615|     57|   accum.mul(x[8], y[5]);
 1616|     57|   accum.mul(x[9], y[4]);
 1617|     57|   accum.mul(x[10], y[3]);
 1618|     57|   accum.mul(x[11], y[2]);
 1619|     57|   accum.mul(x[12], y[1]);
 1620|     57|   accum.mul(x[13], y[0]);
 1621|     57|   z[13] = accum.extract();
 1622|     57|   accum.mul(x[0], y[14]);
 1623|     57|   accum.mul(x[1], y[13]);
 1624|     57|   accum.mul(x[2], y[12]);
 1625|     57|   accum.mul(x[3], y[11]);
 1626|     57|   accum.mul(x[4], y[10]);
 1627|     57|   accum.mul(x[5], y[9]);
 1628|     57|   accum.mul(x[6], y[8]);
 1629|     57|   accum.mul(x[7], y[7]);
 1630|     57|   accum.mul(x[8], y[6]);
 1631|     57|   accum.mul(x[9], y[5]);
 1632|     57|   accum.mul(x[10], y[4]);
 1633|     57|   accum.mul(x[11], y[3]);
 1634|     57|   accum.mul(x[12], y[2]);
 1635|     57|   accum.mul(x[13], y[1]);
 1636|     57|   accum.mul(x[14], y[0]);
 1637|     57|   z[14] = accum.extract();
 1638|     57|   accum.mul(x[0], y[15]);
 1639|     57|   accum.mul(x[1], y[14]);
 1640|     57|   accum.mul(x[2], y[13]);
 1641|     57|   accum.mul(x[3], y[12]);
 1642|     57|   accum.mul(x[4], y[11]);
 1643|     57|   accum.mul(x[5], y[10]);
 1644|     57|   accum.mul(x[6], y[9]);
 1645|     57|   accum.mul(x[7], y[8]);
 1646|     57|   accum.mul(x[8], y[7]);
 1647|     57|   accum.mul(x[9], y[6]);
 1648|     57|   accum.mul(x[10], y[5]);
 1649|     57|   accum.mul(x[11], y[4]);
 1650|     57|   accum.mul(x[12], y[3]);
 1651|     57|   accum.mul(x[13], y[2]);
 1652|     57|   accum.mul(x[14], y[1]);
 1653|     57|   accum.mul(x[15], y[0]);
 1654|     57|   z[15] = accum.extract();
 1655|     57|   accum.mul(x[0], y[16]);
 1656|     57|   accum.mul(x[1], y[15]);
 1657|     57|   accum.mul(x[2], y[14]);
 1658|     57|   accum.mul(x[3], y[13]);
 1659|     57|   accum.mul(x[4], y[12]);
 1660|     57|   accum.mul(x[5], y[11]);
 1661|     57|   accum.mul(x[6], y[10]);
 1662|     57|   accum.mul(x[7], y[9]);
 1663|     57|   accum.mul(x[8], y[8]);
 1664|     57|   accum.mul(x[9], y[7]);
 1665|     57|   accum.mul(x[10], y[6]);
 1666|     57|   accum.mul(x[11], y[5]);
 1667|     57|   accum.mul(x[12], y[4]);
 1668|     57|   accum.mul(x[13], y[3]);
 1669|     57|   accum.mul(x[14], y[2]);
 1670|     57|   accum.mul(x[15], y[1]);
 1671|     57|   accum.mul(x[16], y[0]);
 1672|     57|   z[16] = accum.extract();
 1673|     57|   accum.mul(x[0], y[17]);
 1674|     57|   accum.mul(x[1], y[16]);
 1675|     57|   accum.mul(x[2], y[15]);
 1676|     57|   accum.mul(x[3], y[14]);
 1677|     57|   accum.mul(x[4], y[13]);
 1678|     57|   accum.mul(x[5], y[12]);
 1679|     57|   accum.mul(x[6], y[11]);
 1680|     57|   accum.mul(x[7], y[10]);
 1681|     57|   accum.mul(x[8], y[9]);
 1682|     57|   accum.mul(x[9], y[8]);
 1683|     57|   accum.mul(x[10], y[7]);
 1684|     57|   accum.mul(x[11], y[6]);
 1685|     57|   accum.mul(x[12], y[5]);
 1686|     57|   accum.mul(x[13], y[4]);
 1687|     57|   accum.mul(x[14], y[3]);
 1688|     57|   accum.mul(x[15], y[2]);
 1689|     57|   accum.mul(x[16], y[1]);
 1690|     57|   accum.mul(x[17], y[0]);
 1691|     57|   z[17] = accum.extract();
 1692|     57|   accum.mul(x[0], y[18]);
 1693|     57|   accum.mul(x[1], y[17]);
 1694|     57|   accum.mul(x[2], y[16]);
 1695|     57|   accum.mul(x[3], y[15]);
 1696|     57|   accum.mul(x[4], y[14]);
 1697|     57|   accum.mul(x[5], y[13]);
 1698|     57|   accum.mul(x[6], y[12]);
 1699|     57|   accum.mul(x[7], y[11]);
 1700|     57|   accum.mul(x[8], y[10]);
 1701|     57|   accum.mul(x[9], y[9]);
 1702|     57|   accum.mul(x[10], y[8]);
 1703|     57|   accum.mul(x[11], y[7]);
 1704|     57|   accum.mul(x[12], y[6]);
 1705|     57|   accum.mul(x[13], y[5]);
 1706|     57|   accum.mul(x[14], y[4]);
 1707|     57|   accum.mul(x[15], y[3]);
 1708|     57|   accum.mul(x[16], y[2]);
 1709|     57|   accum.mul(x[17], y[1]);
 1710|     57|   accum.mul(x[18], y[0]);
 1711|     57|   z[18] = accum.extract();
 1712|     57|   accum.mul(x[0], y[19]);
 1713|     57|   accum.mul(x[1], y[18]);
 1714|     57|   accum.mul(x[2], y[17]);
 1715|     57|   accum.mul(x[3], y[16]);
 1716|     57|   accum.mul(x[4], y[15]);
 1717|     57|   accum.mul(x[5], y[14]);
 1718|     57|   accum.mul(x[6], y[13]);
 1719|     57|   accum.mul(x[7], y[12]);
 1720|     57|   accum.mul(x[8], y[11]);
 1721|     57|   accum.mul(x[9], y[10]);
 1722|     57|   accum.mul(x[10], y[9]);
 1723|     57|   accum.mul(x[11], y[8]);
 1724|     57|   accum.mul(x[12], y[7]);
 1725|     57|   accum.mul(x[13], y[6]);
 1726|     57|   accum.mul(x[14], y[5]);
 1727|     57|   accum.mul(x[15], y[4]);
 1728|     57|   accum.mul(x[16], y[3]);
 1729|     57|   accum.mul(x[17], y[2]);
 1730|     57|   accum.mul(x[18], y[1]);
 1731|     57|   accum.mul(x[19], y[0]);
 1732|     57|   z[19] = accum.extract();
 1733|     57|   accum.mul(x[0], y[20]);
 1734|     57|   accum.mul(x[1], y[19]);
 1735|     57|   accum.mul(x[2], y[18]);
 1736|     57|   accum.mul(x[3], y[17]);
 1737|     57|   accum.mul(x[4], y[16]);
 1738|     57|   accum.mul(x[5], y[15]);
 1739|     57|   accum.mul(x[6], y[14]);
 1740|     57|   accum.mul(x[7], y[13]);
 1741|     57|   accum.mul(x[8], y[12]);
 1742|     57|   accum.mul(x[9], y[11]);
 1743|     57|   accum.mul(x[10], y[10]);
 1744|     57|   accum.mul(x[11], y[9]);
 1745|     57|   accum.mul(x[12], y[8]);
 1746|     57|   accum.mul(x[13], y[7]);
 1747|     57|   accum.mul(x[14], y[6]);
 1748|     57|   accum.mul(x[15], y[5]);
 1749|     57|   accum.mul(x[16], y[4]);
 1750|     57|   accum.mul(x[17], y[3]);
 1751|     57|   accum.mul(x[18], y[2]);
 1752|     57|   accum.mul(x[19], y[1]);
 1753|     57|   accum.mul(x[20], y[0]);
 1754|     57|   z[20] = accum.extract();
 1755|     57|   accum.mul(x[0], y[21]);
 1756|     57|   accum.mul(x[1], y[20]);
 1757|     57|   accum.mul(x[2], y[19]);
 1758|     57|   accum.mul(x[3], y[18]);
 1759|     57|   accum.mul(x[4], y[17]);
 1760|     57|   accum.mul(x[5], y[16]);
 1761|     57|   accum.mul(x[6], y[15]);
 1762|     57|   accum.mul(x[7], y[14]);
 1763|     57|   accum.mul(x[8], y[13]);
 1764|     57|   accum.mul(x[9], y[12]);
 1765|     57|   accum.mul(x[10], y[11]);
 1766|     57|   accum.mul(x[11], y[10]);
 1767|     57|   accum.mul(x[12], y[9]);
 1768|     57|   accum.mul(x[13], y[8]);
 1769|     57|   accum.mul(x[14], y[7]);
 1770|     57|   accum.mul(x[15], y[6]);
 1771|     57|   accum.mul(x[16], y[5]);
 1772|     57|   accum.mul(x[17], y[4]);
 1773|     57|   accum.mul(x[18], y[3]);
 1774|     57|   accum.mul(x[19], y[2]);
 1775|     57|   accum.mul(x[20], y[1]);
 1776|     57|   accum.mul(x[21], y[0]);
 1777|     57|   z[21] = accum.extract();
 1778|     57|   accum.mul(x[0], y[22]);
 1779|     57|   accum.mul(x[1], y[21]);
 1780|     57|   accum.mul(x[2], y[20]);
 1781|     57|   accum.mul(x[3], y[19]);
 1782|     57|   accum.mul(x[4], y[18]);
 1783|     57|   accum.mul(x[5], y[17]);
 1784|     57|   accum.mul(x[6], y[16]);
 1785|     57|   accum.mul(x[7], y[15]);
 1786|     57|   accum.mul(x[8], y[14]);
 1787|     57|   accum.mul(x[9], y[13]);
 1788|     57|   accum.mul(x[10], y[12]);
 1789|     57|   accum.mul(x[11], y[11]);
 1790|     57|   accum.mul(x[12], y[10]);
 1791|     57|   accum.mul(x[13], y[9]);
 1792|     57|   accum.mul(x[14], y[8]);
 1793|     57|   accum.mul(x[15], y[7]);
 1794|     57|   accum.mul(x[16], y[6]);
 1795|     57|   accum.mul(x[17], y[5]);
 1796|     57|   accum.mul(x[18], y[4]);
 1797|     57|   accum.mul(x[19], y[3]);
 1798|     57|   accum.mul(x[20], y[2]);
 1799|     57|   accum.mul(x[21], y[1]);
 1800|     57|   accum.mul(x[22], y[0]);
 1801|     57|   z[22] = accum.extract();
 1802|     57|   accum.mul(x[0], y[23]);
 1803|     57|   accum.mul(x[1], y[22]);
 1804|     57|   accum.mul(x[2], y[21]);
 1805|     57|   accum.mul(x[3], y[20]);
 1806|     57|   accum.mul(x[4], y[19]);
 1807|     57|   accum.mul(x[5], y[18]);
 1808|     57|   accum.mul(x[6], y[17]);
 1809|     57|   accum.mul(x[7], y[16]);
 1810|     57|   accum.mul(x[8], y[15]);
 1811|     57|   accum.mul(x[9], y[14]);
 1812|     57|   accum.mul(x[10], y[13]);
 1813|     57|   accum.mul(x[11], y[12]);
 1814|     57|   accum.mul(x[12], y[11]);
 1815|     57|   accum.mul(x[13], y[10]);
 1816|     57|   accum.mul(x[14], y[9]);
 1817|     57|   accum.mul(x[15], y[8]);
 1818|     57|   accum.mul(x[16], y[7]);
 1819|     57|   accum.mul(x[17], y[6]);
 1820|     57|   accum.mul(x[18], y[5]);
 1821|     57|   accum.mul(x[19], y[4]);
 1822|     57|   accum.mul(x[20], y[3]);
 1823|     57|   accum.mul(x[21], y[2]);
 1824|     57|   accum.mul(x[22], y[1]);
 1825|     57|   accum.mul(x[23], y[0]);
 1826|     57|   z[23] = accum.extract();
 1827|     57|   accum.mul(x[1], y[23]);
 1828|     57|   accum.mul(x[2], y[22]);
 1829|     57|   accum.mul(x[3], y[21]);
 1830|     57|   accum.mul(x[4], y[20]);
 1831|     57|   accum.mul(x[5], y[19]);
 1832|     57|   accum.mul(x[6], y[18]);
 1833|     57|   accum.mul(x[7], y[17]);
 1834|     57|   accum.mul(x[8], y[16]);
 1835|     57|   accum.mul(x[9], y[15]);
 1836|     57|   accum.mul(x[10], y[14]);
 1837|     57|   accum.mul(x[11], y[13]);
 1838|     57|   accum.mul(x[12], y[12]);
 1839|     57|   accum.mul(x[13], y[11]);
 1840|     57|   accum.mul(x[14], y[10]);
 1841|     57|   accum.mul(x[15], y[9]);
 1842|     57|   accum.mul(x[16], y[8]);
 1843|     57|   accum.mul(x[17], y[7]);
 1844|     57|   accum.mul(x[18], y[6]);
 1845|     57|   accum.mul(x[19], y[5]);
 1846|     57|   accum.mul(x[20], y[4]);
 1847|     57|   accum.mul(x[21], y[3]);
 1848|     57|   accum.mul(x[22], y[2]);
 1849|     57|   accum.mul(x[23], y[1]);
 1850|     57|   z[24] = accum.extract();
 1851|     57|   accum.mul(x[2], y[23]);
 1852|     57|   accum.mul(x[3], y[22]);
 1853|     57|   accum.mul(x[4], y[21]);
 1854|     57|   accum.mul(x[5], y[20]);
 1855|     57|   accum.mul(x[6], y[19]);
 1856|     57|   accum.mul(x[7], y[18]);
 1857|     57|   accum.mul(x[8], y[17]);
 1858|     57|   accum.mul(x[9], y[16]);
 1859|     57|   accum.mul(x[10], y[15]);
 1860|     57|   accum.mul(x[11], y[14]);
 1861|     57|   accum.mul(x[12], y[13]);
 1862|     57|   accum.mul(x[13], y[12]);
 1863|     57|   accum.mul(x[14], y[11]);
 1864|     57|   accum.mul(x[15], y[10]);
 1865|     57|   accum.mul(x[16], y[9]);
 1866|     57|   accum.mul(x[17], y[8]);
 1867|     57|   accum.mul(x[18], y[7]);
 1868|     57|   accum.mul(x[19], y[6]);
 1869|     57|   accum.mul(x[20], y[5]);
 1870|     57|   accum.mul(x[21], y[4]);
 1871|     57|   accum.mul(x[22], y[3]);
 1872|     57|   accum.mul(x[23], y[2]);
 1873|     57|   z[25] = accum.extract();
 1874|     57|   accum.mul(x[3], y[23]);
 1875|     57|   accum.mul(x[4], y[22]);
 1876|     57|   accum.mul(x[5], y[21]);
 1877|     57|   accum.mul(x[6], y[20]);
 1878|     57|   accum.mul(x[7], y[19]);
 1879|     57|   accum.mul(x[8], y[18]);
 1880|     57|   accum.mul(x[9], y[17]);
 1881|     57|   accum.mul(x[10], y[16]);
 1882|     57|   accum.mul(x[11], y[15]);
 1883|     57|   accum.mul(x[12], y[14]);
 1884|     57|   accum.mul(x[13], y[13]);
 1885|     57|   accum.mul(x[14], y[12]);
 1886|     57|   accum.mul(x[15], y[11]);
 1887|     57|   accum.mul(x[16], y[10]);
 1888|     57|   accum.mul(x[17], y[9]);
 1889|     57|   accum.mul(x[18], y[8]);
 1890|     57|   accum.mul(x[19], y[7]);
 1891|     57|   accum.mul(x[20], y[6]);
 1892|     57|   accum.mul(x[21], y[5]);
 1893|     57|   accum.mul(x[22], y[4]);
 1894|     57|   accum.mul(x[23], y[3]);
 1895|     57|   z[26] = accum.extract();
 1896|     57|   accum.mul(x[4], y[23]);
 1897|     57|   accum.mul(x[5], y[22]);
 1898|     57|   accum.mul(x[6], y[21]);
 1899|     57|   accum.mul(x[7], y[20]);
 1900|     57|   accum.mul(x[8], y[19]);
 1901|     57|   accum.mul(x[9], y[18]);
 1902|     57|   accum.mul(x[10], y[17]);
 1903|     57|   accum.mul(x[11], y[16]);
 1904|     57|   accum.mul(x[12], y[15]);
 1905|     57|   accum.mul(x[13], y[14]);
 1906|     57|   accum.mul(x[14], y[13]);
 1907|     57|   accum.mul(x[15], y[12]);
 1908|     57|   accum.mul(x[16], y[11]);
 1909|     57|   accum.mul(x[17], y[10]);
 1910|     57|   accum.mul(x[18], y[9]);
 1911|     57|   accum.mul(x[19], y[8]);
 1912|     57|   accum.mul(x[20], y[7]);
 1913|     57|   accum.mul(x[21], y[6]);
 1914|     57|   accum.mul(x[22], y[5]);
 1915|     57|   accum.mul(x[23], y[4]);
 1916|     57|   z[27] = accum.extract();
 1917|     57|   accum.mul(x[5], y[23]);
 1918|     57|   accum.mul(x[6], y[22]);
 1919|     57|   accum.mul(x[7], y[21]);
 1920|     57|   accum.mul(x[8], y[20]);
 1921|     57|   accum.mul(x[9], y[19]);
 1922|     57|   accum.mul(x[10], y[18]);
 1923|     57|   accum.mul(x[11], y[17]);
 1924|     57|   accum.mul(x[12], y[16]);
 1925|     57|   accum.mul(x[13], y[15]);
 1926|     57|   accum.mul(x[14], y[14]);
 1927|     57|   accum.mul(x[15], y[13]);
 1928|     57|   accum.mul(x[16], y[12]);
 1929|     57|   accum.mul(x[17], y[11]);
 1930|     57|   accum.mul(x[18], y[10]);
 1931|     57|   accum.mul(x[19], y[9]);
 1932|     57|   accum.mul(x[20], y[8]);
 1933|     57|   accum.mul(x[21], y[7]);
 1934|     57|   accum.mul(x[22], y[6]);
 1935|     57|   accum.mul(x[23], y[5]);
 1936|     57|   z[28] = accum.extract();
 1937|     57|   accum.mul(x[6], y[23]);
 1938|     57|   accum.mul(x[7], y[22]);
 1939|     57|   accum.mul(x[8], y[21]);
 1940|     57|   accum.mul(x[9], y[20]);
 1941|     57|   accum.mul(x[10], y[19]);
 1942|     57|   accum.mul(x[11], y[18]);
 1943|     57|   accum.mul(x[12], y[17]);
 1944|     57|   accum.mul(x[13], y[16]);
 1945|     57|   accum.mul(x[14], y[15]);
 1946|     57|   accum.mul(x[15], y[14]);
 1947|     57|   accum.mul(x[16], y[13]);
 1948|     57|   accum.mul(x[17], y[12]);
 1949|     57|   accum.mul(x[18], y[11]);
 1950|     57|   accum.mul(x[19], y[10]);
 1951|     57|   accum.mul(x[20], y[9]);
 1952|     57|   accum.mul(x[21], y[8]);
 1953|     57|   accum.mul(x[22], y[7]);
 1954|     57|   accum.mul(x[23], y[6]);
 1955|     57|   z[29] = accum.extract();
 1956|     57|   accum.mul(x[7], y[23]);
 1957|     57|   accum.mul(x[8], y[22]);
 1958|     57|   accum.mul(x[9], y[21]);
 1959|     57|   accum.mul(x[10], y[20]);
 1960|     57|   accum.mul(x[11], y[19]);
 1961|     57|   accum.mul(x[12], y[18]);
 1962|     57|   accum.mul(x[13], y[17]);
 1963|     57|   accum.mul(x[14], y[16]);
 1964|     57|   accum.mul(x[15], y[15]);
 1965|     57|   accum.mul(x[16], y[14]);
 1966|     57|   accum.mul(x[17], y[13]);
 1967|     57|   accum.mul(x[18], y[12]);
 1968|     57|   accum.mul(x[19], y[11]);
 1969|     57|   accum.mul(x[20], y[10]);
 1970|     57|   accum.mul(x[21], y[9]);
 1971|     57|   accum.mul(x[22], y[8]);
 1972|     57|   accum.mul(x[23], y[7]);
 1973|     57|   z[30] = accum.extract();
 1974|     57|   accum.mul(x[8], y[23]);
 1975|     57|   accum.mul(x[9], y[22]);
 1976|     57|   accum.mul(x[10], y[21]);
 1977|     57|   accum.mul(x[11], y[20]);
 1978|     57|   accum.mul(x[12], y[19]);
 1979|     57|   accum.mul(x[13], y[18]);
 1980|     57|   accum.mul(x[14], y[17]);
 1981|     57|   accum.mul(x[15], y[16]);
 1982|     57|   accum.mul(x[16], y[15]);
 1983|     57|   accum.mul(x[17], y[14]);
 1984|     57|   accum.mul(x[18], y[13]);
 1985|     57|   accum.mul(x[19], y[12]);
 1986|     57|   accum.mul(x[20], y[11]);
 1987|     57|   accum.mul(x[21], y[10]);
 1988|     57|   accum.mul(x[22], y[9]);
 1989|     57|   accum.mul(x[23], y[8]);
 1990|     57|   z[31] = accum.extract();
 1991|     57|   accum.mul(x[9], y[23]);
 1992|     57|   accum.mul(x[10], y[22]);
 1993|     57|   accum.mul(x[11], y[21]);
 1994|     57|   accum.mul(x[12], y[20]);
 1995|     57|   accum.mul(x[13], y[19]);
 1996|     57|   accum.mul(x[14], y[18]);
 1997|     57|   accum.mul(x[15], y[17]);
 1998|     57|   accum.mul(x[16], y[16]);
 1999|     57|   accum.mul(x[17], y[15]);
 2000|     57|   accum.mul(x[18], y[14]);
 2001|     57|   accum.mul(x[19], y[13]);
 2002|     57|   accum.mul(x[20], y[12]);
 2003|     57|   accum.mul(x[21], y[11]);
 2004|     57|   accum.mul(x[22], y[10]);
 2005|     57|   accum.mul(x[23], y[9]);
 2006|     57|   z[32] = accum.extract();
 2007|     57|   accum.mul(x[10], y[23]);
 2008|     57|   accum.mul(x[11], y[22]);
 2009|     57|   accum.mul(x[12], y[21]);
 2010|     57|   accum.mul(x[13], y[20]);
 2011|     57|   accum.mul(x[14], y[19]);
 2012|     57|   accum.mul(x[15], y[18]);
 2013|     57|   accum.mul(x[16], y[17]);
 2014|     57|   accum.mul(x[17], y[16]);
 2015|     57|   accum.mul(x[18], y[15]);
 2016|     57|   accum.mul(x[19], y[14]);
 2017|     57|   accum.mul(x[20], y[13]);
 2018|     57|   accum.mul(x[21], y[12]);
 2019|     57|   accum.mul(x[22], y[11]);
 2020|     57|   accum.mul(x[23], y[10]);
 2021|     57|   z[33] = accum.extract();
 2022|     57|   accum.mul(x[11], y[23]);
 2023|     57|   accum.mul(x[12], y[22]);
 2024|     57|   accum.mul(x[13], y[21]);
 2025|     57|   accum.mul(x[14], y[20]);
 2026|     57|   accum.mul(x[15], y[19]);
 2027|     57|   accum.mul(x[16], y[18]);
 2028|     57|   accum.mul(x[17], y[17]);
 2029|     57|   accum.mul(x[18], y[16]);
 2030|     57|   accum.mul(x[19], y[15]);
 2031|     57|   accum.mul(x[20], y[14]);
 2032|     57|   accum.mul(x[21], y[13]);
 2033|     57|   accum.mul(x[22], y[12]);
 2034|     57|   accum.mul(x[23], y[11]);
 2035|     57|   z[34] = accum.extract();
 2036|     57|   accum.mul(x[12], y[23]);
 2037|     57|   accum.mul(x[13], y[22]);
 2038|     57|   accum.mul(x[14], y[21]);
 2039|     57|   accum.mul(x[15], y[20]);
 2040|     57|   accum.mul(x[16], y[19]);
 2041|     57|   accum.mul(x[17], y[18]);
 2042|     57|   accum.mul(x[18], y[17]);
 2043|     57|   accum.mul(x[19], y[16]);
 2044|     57|   accum.mul(x[20], y[15]);
 2045|     57|   accum.mul(x[21], y[14]);
 2046|     57|   accum.mul(x[22], y[13]);
 2047|     57|   accum.mul(x[23], y[12]);
 2048|     57|   z[35] = accum.extract();
 2049|     57|   accum.mul(x[13], y[23]);
 2050|     57|   accum.mul(x[14], y[22]);
 2051|     57|   accum.mul(x[15], y[21]);
 2052|     57|   accum.mul(x[16], y[20]);
 2053|     57|   accum.mul(x[17], y[19]);
 2054|     57|   accum.mul(x[18], y[18]);
 2055|     57|   accum.mul(x[19], y[17]);
 2056|     57|   accum.mul(x[20], y[16]);
 2057|     57|   accum.mul(x[21], y[15]);
 2058|     57|   accum.mul(x[22], y[14]);
 2059|     57|   accum.mul(x[23], y[13]);
 2060|     57|   z[36] = accum.extract();
 2061|     57|   accum.mul(x[14], y[23]);
 2062|     57|   accum.mul(x[15], y[22]);
 2063|     57|   accum.mul(x[16], y[21]);
 2064|     57|   accum.mul(x[17], y[20]);
 2065|     57|   accum.mul(x[18], y[19]);
 2066|     57|   accum.mul(x[19], y[18]);
 2067|     57|   accum.mul(x[20], y[17]);
 2068|     57|   accum.mul(x[21], y[16]);
 2069|     57|   accum.mul(x[22], y[15]);
 2070|     57|   accum.mul(x[23], y[14]);
 2071|     57|   z[37] = accum.extract();
 2072|     57|   accum.mul(x[15], y[23]);
 2073|     57|   accum.mul(x[16], y[22]);
 2074|     57|   accum.mul(x[17], y[21]);
 2075|     57|   accum.mul(x[18], y[20]);
 2076|     57|   accum.mul(x[19], y[19]);
 2077|     57|   accum.mul(x[20], y[18]);
 2078|     57|   accum.mul(x[21], y[17]);
 2079|     57|   accum.mul(x[22], y[16]);
 2080|     57|   accum.mul(x[23], y[15]);
 2081|     57|   z[38] = accum.extract();
 2082|     57|   accum.mul(x[16], y[23]);
 2083|     57|   accum.mul(x[17], y[22]);
 2084|     57|   accum.mul(x[18], y[21]);
 2085|     57|   accum.mul(x[19], y[20]);
 2086|     57|   accum.mul(x[20], y[19]);
 2087|     57|   accum.mul(x[21], y[18]);
 2088|     57|   accum.mul(x[22], y[17]);
 2089|     57|   accum.mul(x[23], y[16]);
 2090|     57|   z[39] = accum.extract();
 2091|     57|   accum.mul(x[17], y[23]);
 2092|     57|   accum.mul(x[18], y[22]);
 2093|     57|   accum.mul(x[19], y[21]);
 2094|     57|   accum.mul(x[20], y[20]);
 2095|     57|   accum.mul(x[21], y[19]);
 2096|     57|   accum.mul(x[22], y[18]);
 2097|     57|   accum.mul(x[23], y[17]);
 2098|     57|   z[40] = accum.extract();
 2099|     57|   accum.mul(x[18], y[23]);
 2100|     57|   accum.mul(x[19], y[22]);
 2101|     57|   accum.mul(x[20], y[21]);
 2102|     57|   accum.mul(x[21], y[20]);
 2103|     57|   accum.mul(x[22], y[19]);
 2104|     57|   accum.mul(x[23], y[18]);
 2105|     57|   z[41] = accum.extract();
 2106|     57|   accum.mul(x[19], y[23]);
 2107|     57|   accum.mul(x[20], y[22]);
 2108|     57|   accum.mul(x[21], y[21]);
 2109|     57|   accum.mul(x[22], y[20]);
 2110|     57|   accum.mul(x[23], y[19]);
 2111|     57|   z[42] = accum.extract();
 2112|     57|   accum.mul(x[20], y[23]);
 2113|     57|   accum.mul(x[21], y[22]);
 2114|     57|   accum.mul(x[22], y[21]);
 2115|     57|   accum.mul(x[23], y[20]);
 2116|     57|   z[43] = accum.extract();
 2117|     57|   accum.mul(x[21], y[23]);
 2118|     57|   accum.mul(x[22], y[22]);
 2119|     57|   accum.mul(x[23], y[21]);
 2120|     57|   z[44] = accum.extract();
 2121|     57|   accum.mul(x[22], y[23]);
 2122|     57|   accum.mul(x[23], y[22]);
 2123|     57|   z[45] = accum.extract();
 2124|     57|   accum.mul(x[23], y[23]);
 2125|     57|   z[46] = accum.extract();
 2126|     57|   z[47] = accum.extract();
 2127|     57|}

_ZN5Botan12basecase_mulEPmmPKmmS2_m:
   20|    375|void basecase_mul(word z[], size_t z_size, const word x[], size_t x_size, const word y[], size_t y_size) {
   21|    375|   if(z_size < x_size + y_size) {
  ------------------
  |  Branch (21:7): [True: 0, False: 375]
  ------------------
   22|      0|      throw Invalid_Argument("basecase_mul z_size too small");
   23|      0|   }
   24|       |
   25|    375|   const size_t x_size_8 = x_size - (x_size % 8);
   26|       |
   27|    375|   zeroize_buffer(z, z_size);
   28|       |
   29|  9.58k|   for(size_t i = 0; i != y_size; ++i) {
  ------------------
  |  Branch (29:22): [True: 9.20k, False: 375]
  ------------------
   30|  9.20k|      const word y_i = y[i];
   31|       |
   32|  9.20k|      word carry = 0;
   33|       |
   34|  33.4k|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (34:25): [True: 24.2k, False: 9.20k]
  ------------------
   35|  24.2k|         carry = word8_madd3(z + i + j, x + j, y_i, carry);
   36|  24.2k|      }
   37|       |
   38|  50.0k|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (38:32): [True: 40.8k, False: 9.20k]
  ------------------
   39|  40.8k|         z[i + j] = word_madd3(x[j], y_i, z[i + j], &carry);
   40|  40.8k|      }
   41|       |
   42|  9.20k|      z[x_size + i] = carry;
   43|  9.20k|   }
   44|    375|}
_ZN5Botan12basecase_sqrEPmmPKmm:
   46|    256|void basecase_sqr(word z[], size_t z_size, const word x[], size_t x_size) {
   47|    256|   if(z_size < 2 * x_size) {
  ------------------
  |  Branch (47:7): [True: 0, False: 256]
  ------------------
   48|      0|      throw Invalid_Argument("basecase_sqr z_size too small");
   49|      0|   }
   50|       |
   51|    256|   const size_t x_size_8 = x_size - (x_size % 8);
   52|       |
   53|    256|   zeroize_buffer(z, z_size);
   54|       |
   55|  8.36k|   for(size_t i = 0; i != x_size; ++i) {
  ------------------
  |  Branch (55:22): [True: 8.10k, False: 256]
  ------------------
   56|  8.10k|      const word x_i = x[i];
   57|       |
   58|  8.10k|      word carry = 0;
   59|       |
   60|  56.2k|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (60:25): [True: 48.1k, False: 8.10k]
  ------------------
   61|  48.1k|         carry = word8_madd3(z + i + j, x + j, x_i, carry);
   62|  48.1k|      }
   63|       |
   64|  41.9k|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (64:32): [True: 33.8k, False: 8.10k]
  ------------------
   65|  33.8k|         z[i + j] = word_madd3(x[j], x_i, z[i + j], &carry);
   66|  33.8k|      }
   67|       |
   68|  8.10k|      z[x_size + i] = carry;
   69|  8.10k|   }
   70|    256|}
_ZN5Botan10bigint_mulEPmmPKmmmS2_mmS0_m:
  292|    171|                size_t ws_size) {
  293|    171|   zeroize_buffer(z, z_size);
  294|       |
  295|    171|   if(x_sw == 1) {
  ------------------
  |  Branch (295:7): [True: 0, False: 171]
  ------------------
  296|      0|      bigint_linmul3(z, y, y_sw, x[0]);
  297|    171|   } else if(y_sw == 1) {
  ------------------
  |  Branch (297:14): [True: 0, False: 171]
  ------------------
  298|      0|      bigint_linmul3(z, x, x_sw, y[0]);
  299|    171|   } else if(sized_for_comba_mul<4>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (299:14): [True: 20, False: 151]
  ------------------
  300|     20|      bigint_comba_mul4(z, x, y);
  301|    151|   } else if(sized_for_comba_mul<6>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (301:14): [True: 8, False: 143]
  ------------------
  302|      8|      bigint_comba_mul6(z, x, y);
  303|    143|   } else if(sized_for_comba_mul<8>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (303:14): [True: 10, False: 133]
  ------------------
  304|     10|      bigint_comba_mul8(z, x, y);
  305|    133|   } else if(sized_for_comba_mul<9>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (305:14): [True: 5, False: 128]
  ------------------
  306|      5|      bigint_comba_mul9(z, x, y);
  307|    128|   } else if(sized_for_comba_mul<16>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (307:14): [True: 14, False: 114]
  ------------------
  308|     14|      bigint_comba_mul16(z, x, y);
  309|    114|   } else if(sized_for_comba_mul<24>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (309:14): [True: 15, False: 99]
  ------------------
  310|     15|      bigint_comba_mul24(z, x, y);
  311|     99|   } else if(x_sw < KARATSUBA_MULTIPLY_THRESHOLD || y_sw < KARATSUBA_MULTIPLY_THRESHOLD || workspace == nullptr) {
  ------------------
  |  Branch (311:14): [True: 15, False: 84]
  |  Branch (311:53): [True: 0, False: 84]
  |  Branch (311:92): [True: 0, False: 84]
  ------------------
  312|     15|      basecase_mul(z, z_size, x, x_sw, y, y_sw);
  313|     84|   } else {
  314|     84|      const size_t N = karatsuba_size(z_size, x_size, x_sw, y_size, y_sw);
  315|       |
  316|     84|      if(N > 0 && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (316:10): [True: 84, False: 0]
  |  Branch (316:19): [True: 84, False: 0]
  |  Branch (316:38): [True: 84, False: 0]
  ------------------
  317|     84|         karatsuba_mul(z, x, y, N, workspace);
  318|     84|      } else {
  319|      0|         basecase_mul(z, z_size, x, x_sw, y, y_sw);
  320|      0|      }
  321|     84|   }
  322|    171|}
_ZN5Botan10bigint_sqrEPmmPKmmmS0_m:
  327|    296|void bigint_sqr(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, word workspace[], size_t ws_size) {
  328|    296|   zeroize_buffer(z, z_size);
  329|       |
  330|    296|   BOTAN_ASSERT(z_size / 2 >= x_sw, "Output size is sufficient");
  ------------------
  |  |   71|    296|   do {                                                                                 \
  |  |   72|    296|      /* NOLINTNEXTLINE(*-simplify-boolean-expr) */                                     \
  |  |   73|    296|      if(!(expr)) {                                                                     \
  |  |  ------------------
  |  |  |  Branch (73:10): [True: 0, False: 296]
  |  |  ------------------
  |  |   74|      0|         /* NOLINTNEXTLINE(bugprone-lambda-function-name) */                            \
  |  |   75|      0|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   76|      0|      }                                                                                 \
  |  |   77|    296|   } while(0)
  |  |  ------------------
  |  |  |  Branch (77:12): [Folded, False: 296]
  |  |  ------------------
  ------------------
  331|       |
  332|    296|   if(x_sw == 1) {
  ------------------
  |  Branch (332:7): [True: 121, False: 175]
  ------------------
  333|    121|      bigint_linmul3(z, x, x_sw, x[0]);
  334|    175|   } else if(sized_for_comba_sqr<4>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (334:14): [True: 4, False: 171]
  ------------------
  335|      4|      bigint_comba_sqr4(z, x);
  336|    171|   } else if(sized_for_comba_sqr<6>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (336:14): [True: 2, False: 169]
  ------------------
  337|      2|      bigint_comba_sqr6(z, x);
  338|    169|   } else if(sized_for_comba_sqr<8>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (338:14): [True: 5, False: 164]
  ------------------
  339|      5|      bigint_comba_sqr8(z, x);
  340|    164|   } else if(sized_for_comba_sqr<9>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (340:14): [True: 5, False: 159]
  ------------------
  341|      5|      bigint_comba_sqr9(z, x);
  342|    159|   } else if(sized_for_comba_sqr<16>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (342:14): [True: 2, False: 157]
  ------------------
  343|      2|      bigint_comba_sqr16(z, x);
  344|    157|   } else if(sized_for_comba_sqr<24>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (344:14): [True: 1, False: 156]
  ------------------
  345|      1|      bigint_comba_sqr24(z, x);
  346|    156|   } else if(x_size < KARATSUBA_SQUARE_THRESHOLD || workspace == nullptr) {
  ------------------
  |  Branch (346:14): [True: 37, False: 119]
  |  Branch (346:53): [True: 1, False: 118]
  ------------------
  347|     38|      basecase_sqr(z, z_size, x, x_sw);
  348|    118|   } else {
  349|    118|      const size_t N = karatsuba_size(z_size, x_size, x_sw);
  350|       |
  351|    118|      if(N > 0 && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (351:10): [True: 65, False: 53]
  |  Branch (351:19): [True: 65, False: 0]
  |  Branch (351:38): [True: 65, False: 0]
  ------------------
  352|     65|         karatsuba_sqr(z, x, N, workspace);
  353|     65|      } else {
  354|     53|         basecase_sqr(z, z_size, x, x_sw);
  355|     53|      }
  356|    118|   }
  357|    296|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmmmm:
  203|     84|size_t karatsuba_size(size_t z_size, size_t x_size, size_t x_sw, size_t y_size, size_t y_sw) {
  204|     84|   if(x_sw > x_size || x_sw > y_size || y_sw > x_size || y_sw > y_size) {
  ------------------
  |  Branch (204:7): [True: 0, False: 84]
  |  Branch (204:24): [True: 0, False: 84]
  |  Branch (204:41): [True: 0, False: 84]
  |  Branch (204:58): [True: 0, False: 84]
  ------------------
  205|      0|      return 0;
  206|      0|   }
  207|       |
  208|     84|   if(((x_size == x_sw) && (x_size % 2 != 0)) || ((y_size == y_sw) && (y_size % 2 != 0))) {
  ------------------
  |  Branch (208:8): [True: 19, False: 65]
  |  Branch (208:28): [True: 0, False: 19]
  |  Branch (208:51): [True: 19, False: 65]
  |  Branch (208:71): [True: 0, False: 19]
  ------------------
  209|      0|      return 0;
  210|      0|   }
  211|       |
  212|     84|   const size_t start = (x_sw > y_sw) ? x_sw : y_sw;
  ------------------
  |  Branch (212:25): [True: 0, False: 84]
  ------------------
  213|     84|   const size_t end = (x_size < y_size) ? x_size : y_size;
  ------------------
  |  Branch (213:23): [True: 0, False: 84]
  ------------------
  214|       |
  215|     84|   if(start == end) {
  ------------------
  |  Branch (215:7): [True: 19, False: 65]
  ------------------
  216|     19|      if(start % 2 != 0) {
  ------------------
  |  Branch (216:10): [True: 0, False: 19]
  ------------------
  217|      0|         return 0;
  218|      0|      }
  219|     19|      return start;
  220|     19|   }
  221|       |
  222|    102|   for(size_t j = start; j <= end; ++j) {
  ------------------
  |  Branch (222:26): [True: 102, False: 0]
  ------------------
  223|    102|      if(j % 2 != 0) {
  ------------------
  |  Branch (223:10): [True: 37, False: 65]
  ------------------
  224|     37|         continue;
  225|     37|      }
  226|       |
  227|     65|      if(2 * j > z_size) {
  ------------------
  |  Branch (227:10): [True: 0, False: 65]
  ------------------
  228|      0|         return 0;
  229|      0|      }
  230|       |
  231|     65|      if(x_sw <= j && j <= x_size && y_sw <= j && j <= y_size) {
  ------------------
  |  Branch (231:10): [True: 65, False: 0]
  |  Branch (231:23): [True: 65, False: 0]
  |  Branch (231:38): [True: 65, False: 0]
  |  Branch (231:51): [True: 65, False: 0]
  ------------------
  232|     65|         if(j % 4 == 2 && (j + 2) <= x_size && (j + 2) <= y_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (232:13): [True: 41, False: 24]
  |  Branch (232:27): [True: 41, False: 0]
  |  Branch (232:48): [True: 41, False: 0]
  |  Branch (232:69): [True: 41, False: 0]
  ------------------
  233|     41|            return j + 2;
  234|     41|         }
  235|     24|         return j;
  236|     65|      }
  237|     65|   }
  238|       |
  239|      0|   return 0;
  240|     65|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_mulEPmPKmS3_mS1_:
   80|    975|void karatsuba_mul(word z[], const word x[], const word y[], size_t N, word workspace[]) {
   81|    975|   if(N < KARATSUBA_MULTIPLY_THRESHOLD || N % 2 != 0) {
  ------------------
  |  Branch (81:7): [True: 678, False: 297]
  |  Branch (81:43): [True: 0, False: 297]
  ------------------
   82|    678|      switch(N) {
   83|      0|         case 6:
  ------------------
  |  Branch (83:10): [True: 0, False: 678]
  ------------------
   84|      0|            return bigint_comba_mul6(z, x, y);
   85|      0|         case 8:
  ------------------
  |  Branch (85:10): [True: 0, False: 678]
  ------------------
   86|      0|            return bigint_comba_mul8(z, x, y);
   87|      0|         case 9:
  ------------------
  |  Branch (87:10): [True: 0, False: 678]
  ------------------
   88|      0|            return bigint_comba_mul9(z, x, y);
   89|    276|         case 16:
  ------------------
  |  Branch (89:10): [True: 276, False: 402]
  ------------------
   90|    276|            return bigint_comba_mul16(z, x, y);
   91|     42|         case 24:
  ------------------
  |  Branch (91:10): [True: 42, False: 636]
  ------------------
   92|     42|            return bigint_comba_mul24(z, x, y);
   93|    360|         default:
  ------------------
  |  Branch (93:10): [True: 360, False: 318]
  ------------------
   94|    360|            return basecase_mul(z, 2 * N, x, N, y, N);
   95|    678|      }
   96|    678|   }
   97|       |
   98|    297|   const size_t N2 = N / 2;
   99|       |
  100|    297|   const word* x0 = x;
  101|    297|   const word* x1 = x + N2;
  102|    297|   const word* y0 = y;
  103|    297|   const word* y1 = y + N2;
  104|    297|   word* z0 = z;
  105|    297|   word* z1 = z + N;
  106|       |
  107|    297|   word* ws0 = workspace;
  108|    297|   word* ws1 = workspace + N;
  109|       |
  110|    297|   zeroize_buffer(workspace, 2 * N);
  111|       |
  112|       |   /*
  113|       |   * If either of cmp0 or cmp1 is zero then z0 or z1 resp is zero here,
  114|       |   * resulting in a no-op - z0*z1 will be equal to zero so we don't need to do
  115|       |   * anything, zeroize_buffer above already set the correct result.
  116|       |   *
  117|       |   * However we ignore the result of the comparisons and always perform the
  118|       |   * subtractions and recursively multiply to avoid the timing channel.
  119|       |   */
  120|       |
  121|       |   // First compute (X_lo - X_hi)*(Y_hi - Y_lo)
  122|    297|   const auto cmp0 = bigint_sub_abs(z0, x0, x1, N2, workspace);
  123|    297|   const auto cmp1 = bigint_sub_abs(z1, y1, y0, N2, workspace);
  124|    297|   const auto neg_mask = ~(cmp0 ^ cmp1);
  125|       |
  126|    297|   karatsuba_mul(ws0, z0, z1, N2, ws1);
  127|       |
  128|       |   // Compute X_lo * Y_lo
  129|    297|   karatsuba_mul(z0, x0, y0, N2, ws1);
  130|       |
  131|       |   // Compute X_hi * Y_hi
  132|    297|   karatsuba_mul(z1, x1, y1, N2, ws1);
  133|       |
  134|    297|   const word ws_carry = bigint_add3(ws1, z0, N, z1, N);
  135|    297|   word z_carry = bigint_add2(z + N2, N, ws1, N);
  136|       |
  137|    297|   z_carry += bigint_add2(z + N + N2, N2, &ws_carry, 1);
  138|    297|   bigint_add2(z + N + N2, N2, &z_carry, 1);
  139|       |
  140|    297|   zeroize_buffer(workspace + N, N2);
  141|       |
  142|    297|   bigint_cnd_add(neg_mask.value(), z + N2, workspace, 2 * N - N2);
  143|    297|   bigint_cnd_sub((~neg_mask).value(), z + N2, workspace, 2 * N - N2);
  144|    297|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmm:
  245|    118|size_t karatsuba_size(size_t z_size, size_t x_size, size_t x_sw) {
  246|    118|   if(x_sw == x_size) {
  ------------------
  |  Branch (246:7): [True: 19, False: 99]
  ------------------
  247|     19|      if(x_sw % 2 != 0) {
  ------------------
  |  Branch (247:10): [True: 0, False: 19]
  ------------------
  248|      0|         return 0;
  249|      0|      }
  250|     19|      return x_sw;
  251|     19|   }
  252|       |
  253|    152|   for(size_t j = x_sw; j <= x_size; ++j) {
  ------------------
  |  Branch (253:25): [True: 152, False: 0]
  ------------------
  254|    152|      if(j % 2 != 0) {
  ------------------
  |  Branch (254:10): [True: 53, False: 99]
  ------------------
  255|     53|         continue;
  256|     53|      }
  257|       |
  258|     99|      if(2 * j > z_size) {
  ------------------
  |  Branch (258:10): [True: 53, False: 46]
  ------------------
  259|     53|         return 0;
  260|     53|      }
  261|       |
  262|     46|      if(j % 4 == 2 && (j + 2) <= x_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (262:10): [True: 30, False: 16]
  |  Branch (262:24): [True: 30, False: 0]
  |  Branch (262:45): [True: 0, False: 30]
  ------------------
  263|      0|         return j + 2;
  264|      0|      }
  265|     46|      return j;
  266|     46|   }
  267|       |
  268|      0|   return 0;
  269|     99|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_sqrEPmPKmmS1_:
  149|    431|void karatsuba_sqr(word z[], const word x[], size_t N, word workspace[]) {
  150|    431|   if(N < KARATSUBA_SQUARE_THRESHOLD || N % 2 != 0) {
  ------------------
  |  Branch (150:7): [True: 276, False: 155]
  |  Branch (150:41): [True: 33, False: 122]
  ------------------
  151|    309|      switch(N) {
  152|      0|         case 6:
  ------------------
  |  Branch (152:10): [True: 0, False: 309]
  ------------------
  153|      0|            return bigint_comba_sqr6(z, x);
  154|      0|         case 8:
  ------------------
  |  Branch (154:10): [True: 0, False: 309]
  ------------------
  155|      0|            return bigint_comba_sqr8(z, x);
  156|      0|         case 9:
  ------------------
  |  Branch (156:10): [True: 0, False: 309]
  ------------------
  157|      0|            return bigint_comba_sqr9(z, x);
  158|    132|         case 16:
  ------------------
  |  Branch (158:10): [True: 132, False: 177]
  ------------------
  159|    132|            return bigint_comba_sqr16(z, x);
  160|     12|         case 24:
  ------------------
  |  Branch (160:10): [True: 12, False: 297]
  ------------------
  161|     12|            return bigint_comba_sqr24(z, x);
  162|    165|         default:
  ------------------
  |  Branch (162:10): [True: 165, False: 144]
  ------------------
  163|    165|            return basecase_sqr(z, 2 * N, x, N);
  164|    309|      }
  165|    309|   }
  166|       |
  167|    122|   const size_t N2 = N / 2;
  168|       |
  169|    122|   const word* x0 = x;
  170|    122|   const word* x1 = x + N2;
  171|    122|   word* z0 = z;
  172|    122|   word* z1 = z + N;
  173|       |
  174|    122|   word* ws0 = workspace;
  175|    122|   word* ws1 = workspace + N;
  176|       |
  177|    122|   zeroize_buffer(workspace, 2 * N);
  178|       |
  179|       |   // See comment in karatsuba_mul
  180|    122|   bigint_sub_abs(z0, x0, x1, N2, workspace);
  181|    122|   karatsuba_sqr(ws0, z0, N2, ws1);
  182|       |
  183|    122|   karatsuba_sqr(z0, x0, N2, ws1);
  184|    122|   karatsuba_sqr(z1, x1, N2, ws1);
  185|       |
  186|    122|   const word ws_carry = bigint_add3(ws1, z0, N, z1, N);
  187|    122|   word z_carry = bigint_add2(z + N2, N, ws1, N);
  188|       |
  189|    122|   z_carry += bigint_add2(z + N + N2, N2, &ws_carry, 1);
  190|    122|   bigint_add2(z + N + N2, N2, &z_carry, 1);
  191|       |
  192|       |   /*
  193|       |   * This is only actually required if cmp (result of bigint_sub_abs) is != 0,
  194|       |   * however if cmp==0 then ws0[0:N] == 0 and avoiding the jump hides a
  195|       |   * timing channel.
  196|       |   */
  197|    122|   bigint_sub2(z + N2, 2 * N - N2, ws0, N);
  198|    122|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm4EEEbmmmmm:
  272|    171|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    171|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 20, False: 151]
  |  Branch (273:26): [True: 20, False: 0]
  |  Branch (273:42): [True: 20, False: 0]
  |  Branch (273:56): [True: 20, False: 0]
  |  Branch (273:72): [True: 20, False: 0]
  ------------------
  274|    171|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm6EEEbmmmmm:
  272|    151|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    151|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 8, False: 143]
  |  Branch (273:26): [True: 8, False: 0]
  |  Branch (273:42): [True: 8, False: 0]
  |  Branch (273:56): [True: 8, False: 0]
  |  Branch (273:72): [True: 8, False: 0]
  ------------------
  274|    151|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm8EEEbmmmmm:
  272|    143|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    143|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 10, False: 133]
  |  Branch (273:26): [True: 10, False: 0]
  |  Branch (273:42): [True: 10, False: 0]
  |  Branch (273:56): [True: 10, False: 0]
  |  Branch (273:72): [True: 10, False: 0]
  ------------------
  274|    143|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm9EEEbmmmmm:
  272|    133|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    133|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 5, False: 128]
  |  Branch (273:26): [True: 5, False: 0]
  |  Branch (273:42): [True: 5, False: 0]
  |  Branch (273:56): [True: 5, False: 0]
  |  Branch (273:72): [True: 5, False: 0]
  ------------------
  274|    133|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm16EEEbmmmmm:
  272|    128|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    128|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 14, False: 114]
  |  Branch (273:26): [True: 14, False: 0]
  |  Branch (273:42): [True: 14, False: 0]
  |  Branch (273:56): [True: 14, False: 0]
  |  Branch (273:72): [True: 14, False: 0]
  ------------------
  274|    128|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm24EEEbmmmmm:
  272|    114|inline bool sized_for_comba_mul(size_t x_sw, size_t x_size, size_t y_sw, size_t y_size, size_t z_size) {
  273|    114|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (273:12): [True: 15, False: 99]
  |  Branch (273:26): [True: 15, False: 0]
  |  Branch (273:42): [True: 15, False: 0]
  |  Branch (273:56): [True: 15, False: 0]
  |  Branch (273:72): [True: 15, False: 0]
  ------------------
  274|    114|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm4EEEbmmm:
  277|    175|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    175|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 24, False: 151]
  |  Branch (278:26): [True: 24, False: 0]
  |  Branch (278:42): [True: 4, False: 20]
  ------------------
  279|    175|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm6EEEbmmm:
  277|    171|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    171|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 28, False: 143]
  |  Branch (278:26): [True: 28, False: 0]
  |  Branch (278:42): [True: 2, False: 26]
  ------------------
  279|    171|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm8EEEbmmm:
  277|    169|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    169|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 36, False: 133]
  |  Branch (278:26): [True: 36, False: 0]
  |  Branch (278:42): [True: 5, False: 31]
  ------------------
  279|    169|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm9EEEbmmm:
  277|    164|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    164|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 36, False: 128]
  |  Branch (278:26): [True: 22, False: 14]
  |  Branch (278:42): [True: 5, False: 17]
  ------------------
  279|    164|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm16EEEbmmm:
  277|    159|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    159|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 45, False: 114]
  |  Branch (278:26): [True: 31, False: 14]
  |  Branch (278:42): [True: 2, False: 29]
  ------------------
  279|    159|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm24EEEbmmm:
  277|    157|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  278|    157|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (278:12): [True: 58, False: 99]
  |  Branch (278:26): [True: 33, False: 25]
  |  Branch (278:42): [True: 1, False: 32]
  ------------------
  279|    157|}

_ZN5Botan16bigint_mulx_sqr4EPmPKm:
   27|      4|void bigint_mulx_sqr4(word z[8], const word x[4]) {
   28|       |   // clang-format off
   29|      4|   asm(
   30|      4|      "xorl %%r9d, %%r9d\n\t"
   31|      4|      "xorl %%r10d, %%r10d\n\t"
   32|      4|      "xorl %%r8d, %%r8d\n\t"
   33|       |
   34|      4|      "movq 0(%[x]), %%rdx\n\t"  // x[0] * x[1..3]
   35|      4|      "xorl %%eax, %%eax\n\t"
   36|      4|      "mulx 8(%[x]), %%rax, %%rcx\n\t"
   37|      4|      "adcx %%rax, %%r9\n\t"
   38|      4|      "movq %%r9, 8(%[z])\n\t"
   39|      4|      "mulx 16(%[x]), %%rax, %%r9\n\t"
   40|      4|      "adox %%rcx, %%rax\n\t"
   41|      4|      "adcx %%rax, %%r10\n\t"
   42|      4|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
   43|      4|      "adox %%r9, %%rax\n\t"
   44|      4|      "adcx %%rax, %%r8\n\t"
   45|      4|      "movl $0, %%eax\n\t"
   46|      4|      "adox %%rax, %%rcx\n\t"
   47|      4|      "adcx %%rax, %%rcx\n\t"
   48|      4|      "movq %%rcx, %%r9\n\t"
   49|      4|      "movq %%r10, 16(%[z])\n\t"
   50|       |
   51|      4|      "movq 8(%[x]), %%rdx\n\t"  // x[1] * x[2..3]
   52|      4|      "xorl %%eax, %%eax\n\t"
   53|      4|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
   54|      4|      "adcx %%rax, %%r8\n\t"
   55|      4|      "movq %%r8, 24(%[z])\n\t"
   56|      4|      "mulx 24(%[x]), %%rax, %%r10\n\t"
   57|      4|      "adox %%rcx, %%rax\n\t"
   58|      4|      "adcx %%rax, %%r9\n\t"
   59|      4|      "movl $0, %%eax\n\t"
   60|      4|      "adox %%rax, %%r10\n\t"
   61|      4|      "adcx %%rax, %%r10\n\t"
   62|      4|      "movq %%r9, 32(%[z])\n\t"
   63|       |
   64|      4|      "movq 16(%[x]), %%rdx\n\t"  // x[2] * x[3..3]
   65|      4|      "xorl %%eax, %%eax\n\t"
   66|      4|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
   67|      4|      "adcx %%rax, %%r10\n\t"
   68|      4|      "movq %%r10, 40(%[z])\n\t"
   69|      4|      "movl $0, %%eax\n\t"
   70|      4|      "adox %%rax, %%rcx\n\t"
   71|      4|      "adcx %%rax, %%rcx\n\t"
   72|      4|      "movq %%rcx, %%r8\n\t"
   73|      4|      "movq %%r8, 48(%[z])\n\t"
   74|       |
   75|      4|      "movq $0, 56(%[z])\n\t"
   76|      4|      "xorl %%eax, %%eax\n\t"  // double the cross products and add the squares
   77|      4|      "movq 0(%[x]), %%rdx\n\t"
   78|      4|      "mulx %%rdx, %%rax, %%rcx\n\t"
   79|      4|      "movq %%rax, 0(%[z])\n\t"
   80|      4|      "movq 8(%[z]), %%r8\n\t"
   81|      4|      "adcx %%r8, %%r8\n\t"
   82|      4|      "adox %%rcx, %%r8\n\t"
   83|      4|      "movq %%r8, 8(%[z])\n\t"
   84|      4|      "movq 8(%[x]), %%rdx\n\t"
   85|      4|      "mulx %%rdx, %%rax, %%rcx\n\t"
   86|      4|      "movq 16(%[z]), %%r8\n\t"
   87|      4|      "adcx %%r8, %%r8\n\t"
   88|      4|      "adox %%rax, %%r8\n\t"
   89|      4|      "movq %%r8, 16(%[z])\n\t"
   90|      4|      "movq 24(%[z]), %%r8\n\t"
   91|      4|      "adcx %%r8, %%r8\n\t"
   92|      4|      "adox %%rcx, %%r8\n\t"
   93|      4|      "movq %%r8, 24(%[z])\n\t"
   94|      4|      "movq 16(%[x]), %%rdx\n\t"
   95|      4|      "mulx %%rdx, %%rax, %%rcx\n\t"
   96|      4|      "movq 32(%[z]), %%r8\n\t"
   97|      4|      "adcx %%r8, %%r8\n\t"
   98|      4|      "adox %%rax, %%r8\n\t"
   99|      4|      "movq %%r8, 32(%[z])\n\t"
  100|      4|      "movq 40(%[z]), %%r8\n\t"
  101|      4|      "adcx %%r8, %%r8\n\t"
  102|      4|      "adox %%rcx, %%r8\n\t"
  103|      4|      "movq %%r8, 40(%[z])\n\t"
  104|      4|      "movq 24(%[x]), %%rdx\n\t"
  105|      4|      "mulx %%rdx, %%rax, %%rcx\n\t"
  106|      4|      "movq 48(%[z]), %%r8\n\t"
  107|      4|      "adcx %%r8, %%r8\n\t"
  108|      4|      "adox %%rax, %%r8\n\t"
  109|      4|      "movq %%r8, 48(%[z])\n\t"
  110|      4|      "movq 56(%[z]), %%r8\n\t"
  111|      4|      "adcx %%r8, %%r8\n\t"
  112|      4|      "adox %%rcx, %%r8\n\t"
  113|      4|      "movq %%r8, 56(%[z])\n\t"
  114|      4|      :
  115|      4|      : [z] "r"(z), [x] "r"(x)
  116|      4|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "cc", "memory");
  117|       |   // clang-format on
  118|      4|}
_ZN5Botan16bigint_mulx_mul4EPmPKmS2_:
  120|     20|void bigint_mulx_mul4(word z[8], const word x[4], const word y[4]) {
  121|       |   // clang-format off
  122|     20|   asm(
  123|     20|      "xorl %%r8d, %%r8d\n\t"
  124|     20|      "xorl %%r9d, %%r9d\n\t"
  125|     20|      "xorl %%r10d, %%r10d\n\t"
  126|     20|      "xorl %%r11d, %%r11d\n\t"
  127|       |
  128|     20|      "movq 0(%[y]), %%rdx\n\t"  // row 0: x * y[0]
  129|     20|      "xorl %%eax, %%eax\n\t"
  130|     20|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  131|     20|      "adcx %%rax, %%r8\n\t"
  132|     20|      "movq %%r8, 0(%[z])\n\t"
  133|     20|      "mulx 8(%[x]), %%rax, %%r8\n\t"
  134|     20|      "adox %%rcx, %%rax\n\t"
  135|     20|      "adcx %%rax, %%r9\n\t"
  136|     20|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  137|     20|      "adox %%r8, %%rax\n\t"
  138|     20|      "adcx %%rax, %%r10\n\t"
  139|     20|      "mulx 24(%[x]), %%rax, %%r8\n\t"
  140|     20|      "adox %%rcx, %%rax\n\t"
  141|     20|      "adcx %%rax, %%r11\n\t"
  142|     20|      "movl $0, %%eax\n\t"
  143|     20|      "adox %%rax, %%r8\n\t"
  144|     20|      "adcx %%rax, %%r8\n\t"
  145|       |
  146|     20|      "movq 8(%[y]), %%rdx\n\t"  // row 1: x * y[1]
  147|     20|      "xorl %%eax, %%eax\n\t"
  148|     20|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  149|     20|      "adcx %%rax, %%r9\n\t"
  150|     20|      "movq %%r9, 8(%[z])\n\t"
  151|     20|      "mulx 8(%[x]), %%rax, %%r9\n\t"
  152|     20|      "adox %%rcx, %%rax\n\t"
  153|     20|      "adcx %%rax, %%r10\n\t"
  154|     20|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  155|     20|      "adox %%r9, %%rax\n\t"
  156|     20|      "adcx %%rax, %%r11\n\t"
  157|     20|      "mulx 24(%[x]), %%rax, %%r9\n\t"
  158|     20|      "adox %%rcx, %%rax\n\t"
  159|     20|      "adcx %%rax, %%r8\n\t"
  160|     20|      "movl $0, %%eax\n\t"
  161|     20|      "adox %%rax, %%r9\n\t"
  162|     20|      "adcx %%rax, %%r9\n\t"
  163|       |
  164|     20|      "movq 16(%[y]), %%rdx\n\t"  // row 2: x * y[2]
  165|     20|      "xorl %%eax, %%eax\n\t"
  166|     20|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  167|     20|      "adcx %%rax, %%r10\n\t"
  168|     20|      "movq %%r10, 16(%[z])\n\t"
  169|     20|      "mulx 8(%[x]), %%rax, %%r10\n\t"
  170|     20|      "adox %%rcx, %%rax\n\t"
  171|     20|      "adcx %%rax, %%r11\n\t"
  172|     20|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  173|     20|      "adox %%r10, %%rax\n\t"
  174|     20|      "adcx %%rax, %%r8\n\t"
  175|     20|      "mulx 24(%[x]), %%rax, %%r10\n\t"
  176|     20|      "adox %%rcx, %%rax\n\t"
  177|     20|      "adcx %%rax, %%r9\n\t"
  178|     20|      "movl $0, %%eax\n\t"
  179|     20|      "adox %%rax, %%r10\n\t"
  180|     20|      "adcx %%rax, %%r10\n\t"
  181|       |
  182|     20|      "movq 24(%[y]), %%rdx\n\t"  // row 3: x * y[3]
  183|     20|      "xorl %%eax, %%eax\n\t"
  184|     20|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  185|     20|      "adcx %%rax, %%r11\n\t"
  186|     20|      "movq %%r11, 24(%[z])\n\t"
  187|     20|      "mulx 8(%[x]), %%rax, %%r11\n\t"
  188|     20|      "adox %%rcx, %%rax\n\t"
  189|     20|      "adcx %%rax, %%r8\n\t"
  190|     20|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  191|     20|      "adox %%r11, %%rax\n\t"
  192|     20|      "adcx %%rax, %%r9\n\t"
  193|     20|      "mulx 24(%[x]), %%rax, %%r11\n\t"
  194|     20|      "adox %%rcx, %%rax\n\t"
  195|     20|      "adcx %%rax, %%r10\n\t"
  196|     20|      "movl $0, %%eax\n\t"
  197|     20|      "adox %%rax, %%r11\n\t"
  198|     20|      "adcx %%rax, %%r11\n\t"
  199|       |
  200|     20|      "movq %%r8, 32(%[z])\n\t"
  201|     20|      "movq %%r9, 40(%[z])\n\t"
  202|     20|      "movq %%r10, 48(%[z])\n\t"
  203|     20|      "movq %%r11, 56(%[z])\n\t"
  204|     20|      :
  205|     20|      : [z] "r"(z), [x] "r"(x), [y] "r"(y)
  206|     20|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "cc", "memory");
  207|       |   // clang-format on
  208|     20|}
_ZN5Botan16bigint_mulx_sqr6EPmPKm:
  210|      2|void bigint_mulx_sqr6(word z[12], const word x[6]) {
  211|       |   // clang-format off
  212|      2|   asm(
  213|      2|      "xorl %%r9d, %%r9d\n\t"
  214|      2|      "xorl %%r10d, %%r10d\n\t"
  215|      2|      "xorl %%r11d, %%r11d\n\t"
  216|      2|      "xorl %%r12d, %%r12d\n\t"
  217|      2|      "xorl %%r8d, %%r8d\n\t"
  218|       |
  219|      2|      "movq 0(%[x]), %%rdx\n\t"  // x[0] * x[1..5]
  220|      2|      "xorl %%eax, %%eax\n\t"
  221|      2|      "mulx 8(%[x]), %%rax, %%rcx\n\t"
  222|      2|      "adcx %%rax, %%r9\n\t"
  223|      2|      "movq %%r9, 8(%[z])\n\t"
  224|      2|      "mulx 16(%[x]), %%rax, %%r9\n\t"
  225|      2|      "adox %%rcx, %%rax\n\t"
  226|      2|      "adcx %%rax, %%r10\n\t"
  227|      2|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
  228|      2|      "adox %%r9, %%rax\n\t"
  229|      2|      "adcx %%rax, %%r11\n\t"
  230|      2|      "mulx 32(%[x]), %%rax, %%r9\n\t"
  231|      2|      "adox %%rcx, %%rax\n\t"
  232|      2|      "adcx %%rax, %%r12\n\t"
  233|      2|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  234|      2|      "adox %%r9, %%rax\n\t"
  235|      2|      "adcx %%rax, %%r8\n\t"
  236|      2|      "movl $0, %%eax\n\t"
  237|      2|      "adox %%rax, %%rcx\n\t"
  238|      2|      "adcx %%rax, %%rcx\n\t"
  239|      2|      "movq %%rcx, %%r9\n\t"
  240|      2|      "movq %%r10, 16(%[z])\n\t"
  241|       |
  242|      2|      "movq 8(%[x]), %%rdx\n\t"  // x[1] * x[2..5]
  243|      2|      "xorl %%eax, %%eax\n\t"
  244|      2|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  245|      2|      "adcx %%rax, %%r11\n\t"
  246|      2|      "movq %%r11, 24(%[z])\n\t"
  247|      2|      "mulx 24(%[x]), %%rax, %%r10\n\t"
  248|      2|      "adox %%rcx, %%rax\n\t"
  249|      2|      "adcx %%rax, %%r12\n\t"
  250|      2|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  251|      2|      "adox %%r10, %%rax\n\t"
  252|      2|      "adcx %%rax, %%r8\n\t"
  253|      2|      "mulx 40(%[x]), %%rax, %%r10\n\t"
  254|      2|      "adox %%rcx, %%rax\n\t"
  255|      2|      "adcx %%rax, %%r9\n\t"
  256|      2|      "movl $0, %%eax\n\t"
  257|      2|      "adox %%rax, %%r10\n\t"
  258|      2|      "adcx %%rax, %%r10\n\t"
  259|      2|      "movq %%r12, 32(%[z])\n\t"
  260|       |
  261|      2|      "movq 16(%[x]), %%rdx\n\t"  // x[2] * x[3..5]
  262|      2|      "xorl %%eax, %%eax\n\t"
  263|      2|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
  264|      2|      "adcx %%rax, %%r8\n\t"
  265|      2|      "movq %%r8, 40(%[z])\n\t"
  266|      2|      "mulx 32(%[x]), %%rax, %%r11\n\t"
  267|      2|      "adox %%rcx, %%rax\n\t"
  268|      2|      "adcx %%rax, %%r9\n\t"
  269|      2|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  270|      2|      "adox %%r11, %%rax\n\t"
  271|      2|      "adcx %%rax, %%r10\n\t"
  272|      2|      "movl $0, %%eax\n\t"
  273|      2|      "adox %%rax, %%rcx\n\t"
  274|      2|      "adcx %%rax, %%rcx\n\t"
  275|      2|      "movq %%rcx, %%r11\n\t"
  276|      2|      "movq %%r9, 48(%[z])\n\t"
  277|       |
  278|      2|      "movq 24(%[x]), %%rdx\n\t"  // x[3] * x[4..5]
  279|      2|      "xorl %%eax, %%eax\n\t"
  280|      2|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  281|      2|      "adcx %%rax, %%r10\n\t"
  282|      2|      "movq %%r10, 56(%[z])\n\t"
  283|      2|      "mulx 40(%[x]), %%rax, %%r12\n\t"
  284|      2|      "adox %%rcx, %%rax\n\t"
  285|      2|      "adcx %%rax, %%r11\n\t"
  286|      2|      "movl $0, %%eax\n\t"
  287|      2|      "adox %%rax, %%r12\n\t"
  288|      2|      "adcx %%rax, %%r12\n\t"
  289|      2|      "movq %%r11, 64(%[z])\n\t"
  290|       |
  291|      2|      "movq 32(%[x]), %%rdx\n\t"  // x[4] * x[5..5]
  292|      2|      "xorl %%eax, %%eax\n\t"
  293|      2|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  294|      2|      "adcx %%rax, %%r12\n\t"
  295|      2|      "movq %%r12, 72(%[z])\n\t"
  296|      2|      "movl $0, %%eax\n\t"
  297|      2|      "adox %%rax, %%rcx\n\t"
  298|      2|      "adcx %%rax, %%rcx\n\t"
  299|      2|      "movq %%rcx, %%r8\n\t"
  300|      2|      "movq %%r8, 80(%[z])\n\t"
  301|       |
  302|      2|      "movq $0, 88(%[z])\n\t"
  303|      2|      "xorl %%eax, %%eax\n\t"  // double the cross products and add the squares
  304|      2|      "movq 0(%[x]), %%rdx\n\t"
  305|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  306|      2|      "movq %%rax, 0(%[z])\n\t"
  307|      2|      "movq 8(%[z]), %%r8\n\t"
  308|      2|      "adcx %%r8, %%r8\n\t"
  309|      2|      "adox %%rcx, %%r8\n\t"
  310|      2|      "movq %%r8, 8(%[z])\n\t"
  311|      2|      "movq 8(%[x]), %%rdx\n\t"
  312|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  313|      2|      "movq 16(%[z]), %%r8\n\t"
  314|      2|      "adcx %%r8, %%r8\n\t"
  315|      2|      "adox %%rax, %%r8\n\t"
  316|      2|      "movq %%r8, 16(%[z])\n\t"
  317|      2|      "movq 24(%[z]), %%r8\n\t"
  318|      2|      "adcx %%r8, %%r8\n\t"
  319|      2|      "adox %%rcx, %%r8\n\t"
  320|      2|      "movq %%r8, 24(%[z])\n\t"
  321|      2|      "movq 16(%[x]), %%rdx\n\t"
  322|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  323|      2|      "movq 32(%[z]), %%r8\n\t"
  324|      2|      "adcx %%r8, %%r8\n\t"
  325|      2|      "adox %%rax, %%r8\n\t"
  326|      2|      "movq %%r8, 32(%[z])\n\t"
  327|      2|      "movq 40(%[z]), %%r8\n\t"
  328|      2|      "adcx %%r8, %%r8\n\t"
  329|      2|      "adox %%rcx, %%r8\n\t"
  330|      2|      "movq %%r8, 40(%[z])\n\t"
  331|      2|      "movq 24(%[x]), %%rdx\n\t"
  332|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  333|      2|      "movq 48(%[z]), %%r8\n\t"
  334|      2|      "adcx %%r8, %%r8\n\t"
  335|      2|      "adox %%rax, %%r8\n\t"
  336|      2|      "movq %%r8, 48(%[z])\n\t"
  337|      2|      "movq 56(%[z]), %%r8\n\t"
  338|      2|      "adcx %%r8, %%r8\n\t"
  339|      2|      "adox %%rcx, %%r8\n\t"
  340|      2|      "movq %%r8, 56(%[z])\n\t"
  341|      2|      "movq 32(%[x]), %%rdx\n\t"
  342|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  343|      2|      "movq 64(%[z]), %%r8\n\t"
  344|      2|      "adcx %%r8, %%r8\n\t"
  345|      2|      "adox %%rax, %%r8\n\t"
  346|      2|      "movq %%r8, 64(%[z])\n\t"
  347|      2|      "movq 72(%[z]), %%r8\n\t"
  348|      2|      "adcx %%r8, %%r8\n\t"
  349|      2|      "adox %%rcx, %%r8\n\t"
  350|      2|      "movq %%r8, 72(%[z])\n\t"
  351|      2|      "movq 40(%[x]), %%rdx\n\t"
  352|      2|      "mulx %%rdx, %%rax, %%rcx\n\t"
  353|      2|      "movq 80(%[z]), %%r8\n\t"
  354|      2|      "adcx %%r8, %%r8\n\t"
  355|      2|      "adox %%rax, %%r8\n\t"
  356|      2|      "movq %%r8, 80(%[z])\n\t"
  357|      2|      "movq 88(%[z]), %%r8\n\t"
  358|      2|      "adcx %%r8, %%r8\n\t"
  359|      2|      "adox %%rcx, %%r8\n\t"
  360|      2|      "movq %%r8, 88(%[z])\n\t"
  361|      2|      :
  362|      2|      : [z] "r"(z), [x] "r"(x)
  363|      2|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "cc", "memory");
  364|       |   // clang-format on
  365|      2|}
_ZN5Botan16bigint_mulx_mul6EPmPKmS2_:
  367|      8|void bigint_mulx_mul6(word z[12], const word x[6], const word y[6]) {
  368|       |   // clang-format off
  369|      8|   asm(
  370|      8|      "xorl %%r8d, %%r8d\n\t"
  371|      8|      "xorl %%r9d, %%r9d\n\t"
  372|      8|      "xorl %%r10d, %%r10d\n\t"
  373|      8|      "xorl %%r11d, %%r11d\n\t"
  374|      8|      "xorl %%r12d, %%r12d\n\t"
  375|      8|      "xorl %%r13d, %%r13d\n\t"
  376|       |
  377|      8|      "movq 0(%[y]), %%rdx\n\t"  // row 0: x * y[0]
  378|      8|      "xorl %%eax, %%eax\n\t"
  379|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  380|      8|      "adcx %%rax, %%r8\n\t"
  381|      8|      "movq %%r8, 0(%[z])\n\t"
  382|      8|      "mulx 8(%[x]), %%rax, %%r8\n\t"
  383|      8|      "adox %%rcx, %%rax\n\t"
  384|      8|      "adcx %%rax, %%r9\n\t"
  385|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  386|      8|      "adox %%r8, %%rax\n\t"
  387|      8|      "adcx %%rax, %%r10\n\t"
  388|      8|      "mulx 24(%[x]), %%rax, %%r8\n\t"
  389|      8|      "adox %%rcx, %%rax\n\t"
  390|      8|      "adcx %%rax, %%r11\n\t"
  391|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  392|      8|      "adox %%r8, %%rax\n\t"
  393|      8|      "adcx %%rax, %%r12\n\t"
  394|      8|      "mulx 40(%[x]), %%rax, %%r8\n\t"
  395|      8|      "adox %%rcx, %%rax\n\t"
  396|      8|      "adcx %%rax, %%r13\n\t"
  397|      8|      "movl $0, %%eax\n\t"
  398|      8|      "adox %%rax, %%r8\n\t"
  399|      8|      "adcx %%rax, %%r8\n\t"
  400|       |
  401|      8|      "movq 8(%[y]), %%rdx\n\t"  // row 1: x * y[1]
  402|      8|      "xorl %%eax, %%eax\n\t"
  403|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  404|      8|      "adcx %%rax, %%r9\n\t"
  405|      8|      "movq %%r9, 8(%[z])\n\t"
  406|      8|      "mulx 8(%[x]), %%rax, %%r9\n\t"
  407|      8|      "adox %%rcx, %%rax\n\t"
  408|      8|      "adcx %%rax, %%r10\n\t"
  409|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  410|      8|      "adox %%r9, %%rax\n\t"
  411|      8|      "adcx %%rax, %%r11\n\t"
  412|      8|      "mulx 24(%[x]), %%rax, %%r9\n\t"
  413|      8|      "adox %%rcx, %%rax\n\t"
  414|      8|      "adcx %%rax, %%r12\n\t"
  415|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  416|      8|      "adox %%r9, %%rax\n\t"
  417|      8|      "adcx %%rax, %%r13\n\t"
  418|      8|      "mulx 40(%[x]), %%rax, %%r9\n\t"
  419|      8|      "adox %%rcx, %%rax\n\t"
  420|      8|      "adcx %%rax, %%r8\n\t"
  421|      8|      "movl $0, %%eax\n\t"
  422|      8|      "adox %%rax, %%r9\n\t"
  423|      8|      "adcx %%rax, %%r9\n\t"
  424|       |
  425|      8|      "movq 16(%[y]), %%rdx\n\t"  // row 2: x * y[2]
  426|      8|      "xorl %%eax, %%eax\n\t"
  427|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  428|      8|      "adcx %%rax, %%r10\n\t"
  429|      8|      "movq %%r10, 16(%[z])\n\t"
  430|      8|      "mulx 8(%[x]), %%rax, %%r10\n\t"
  431|      8|      "adox %%rcx, %%rax\n\t"
  432|      8|      "adcx %%rax, %%r11\n\t"
  433|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  434|      8|      "adox %%r10, %%rax\n\t"
  435|      8|      "adcx %%rax, %%r12\n\t"
  436|      8|      "mulx 24(%[x]), %%rax, %%r10\n\t"
  437|      8|      "adox %%rcx, %%rax\n\t"
  438|      8|      "adcx %%rax, %%r13\n\t"
  439|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  440|      8|      "adox %%r10, %%rax\n\t"
  441|      8|      "adcx %%rax, %%r8\n\t"
  442|      8|      "mulx 40(%[x]), %%rax, %%r10\n\t"
  443|      8|      "adox %%rcx, %%rax\n\t"
  444|      8|      "adcx %%rax, %%r9\n\t"
  445|      8|      "movl $0, %%eax\n\t"
  446|      8|      "adox %%rax, %%r10\n\t"
  447|      8|      "adcx %%rax, %%r10\n\t"
  448|       |
  449|      8|      "movq 24(%[y]), %%rdx\n\t"  // row 3: x * y[3]
  450|      8|      "xorl %%eax, %%eax\n\t"
  451|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  452|      8|      "adcx %%rax, %%r11\n\t"
  453|      8|      "movq %%r11, 24(%[z])\n\t"
  454|      8|      "mulx 8(%[x]), %%rax, %%r11\n\t"
  455|      8|      "adox %%rcx, %%rax\n\t"
  456|      8|      "adcx %%rax, %%r12\n\t"
  457|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  458|      8|      "adox %%r11, %%rax\n\t"
  459|      8|      "adcx %%rax, %%r13\n\t"
  460|      8|      "mulx 24(%[x]), %%rax, %%r11\n\t"
  461|      8|      "adox %%rcx, %%rax\n\t"
  462|      8|      "adcx %%rax, %%r8\n\t"
  463|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  464|      8|      "adox %%r11, %%rax\n\t"
  465|      8|      "adcx %%rax, %%r9\n\t"
  466|      8|      "mulx 40(%[x]), %%rax, %%r11\n\t"
  467|      8|      "adox %%rcx, %%rax\n\t"
  468|      8|      "adcx %%rax, %%r10\n\t"
  469|      8|      "movl $0, %%eax\n\t"
  470|      8|      "adox %%rax, %%r11\n\t"
  471|      8|      "adcx %%rax, %%r11\n\t"
  472|       |
  473|      8|      "movq 32(%[y]), %%rdx\n\t"  // row 4: x * y[4]
  474|      8|      "xorl %%eax, %%eax\n\t"
  475|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  476|      8|      "adcx %%rax, %%r12\n\t"
  477|      8|      "movq %%r12, 32(%[z])\n\t"
  478|      8|      "mulx 8(%[x]), %%rax, %%r12\n\t"
  479|      8|      "adox %%rcx, %%rax\n\t"
  480|      8|      "adcx %%rax, %%r13\n\t"
  481|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  482|      8|      "adox %%r12, %%rax\n\t"
  483|      8|      "adcx %%rax, %%r8\n\t"
  484|      8|      "mulx 24(%[x]), %%rax, %%r12\n\t"
  485|      8|      "adox %%rcx, %%rax\n\t"
  486|      8|      "adcx %%rax, %%r9\n\t"
  487|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  488|      8|      "adox %%r12, %%rax\n\t"
  489|      8|      "adcx %%rax, %%r10\n\t"
  490|      8|      "mulx 40(%[x]), %%rax, %%r12\n\t"
  491|      8|      "adox %%rcx, %%rax\n\t"
  492|      8|      "adcx %%rax, %%r11\n\t"
  493|      8|      "movl $0, %%eax\n\t"
  494|      8|      "adox %%rax, %%r12\n\t"
  495|      8|      "adcx %%rax, %%r12\n\t"
  496|       |
  497|      8|      "movq 40(%[y]), %%rdx\n\t"  // row 5: x * y[5]
  498|      8|      "xorl %%eax, %%eax\n\t"
  499|      8|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  500|      8|      "adcx %%rax, %%r13\n\t"
  501|      8|      "movq %%r13, 40(%[z])\n\t"
  502|      8|      "mulx 8(%[x]), %%rax, %%r13\n\t"
  503|      8|      "adox %%rcx, %%rax\n\t"
  504|      8|      "adcx %%rax, %%r8\n\t"
  505|      8|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  506|      8|      "adox %%r13, %%rax\n\t"
  507|      8|      "adcx %%rax, %%r9\n\t"
  508|      8|      "mulx 24(%[x]), %%rax, %%r13\n\t"
  509|      8|      "adox %%rcx, %%rax\n\t"
  510|      8|      "adcx %%rax, %%r10\n\t"
  511|      8|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  512|      8|      "adox %%r13, %%rax\n\t"
  513|      8|      "adcx %%rax, %%r11\n\t"
  514|      8|      "mulx 40(%[x]), %%rax, %%r13\n\t"
  515|      8|      "adox %%rcx, %%rax\n\t"
  516|      8|      "adcx %%rax, %%r12\n\t"
  517|      8|      "movl $0, %%eax\n\t"
  518|      8|      "adox %%rax, %%r13\n\t"
  519|      8|      "adcx %%rax, %%r13\n\t"
  520|       |
  521|      8|      "movq %%r8, 48(%[z])\n\t"
  522|      8|      "movq %%r9, 56(%[z])\n\t"
  523|      8|      "movq %%r10, 64(%[z])\n\t"
  524|      8|      "movq %%r11, 72(%[z])\n\t"
  525|      8|      "movq %%r12, 80(%[z])\n\t"
  526|      8|      "movq %%r13, 88(%[z])\n\t"
  527|      8|      :
  528|      8|      : [z] "r"(z), [x] "r"(x), [y] "r"(y)
  529|      8|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "cc", "memory");
  530|       |   // clang-format on
  531|      8|}
_ZN5Botan16bigint_mulx_sqr8EPmPKm:
  533|      5|void bigint_mulx_sqr8(word z[16], const word x[8]) {
  534|       |   // clang-format off
  535|      5|   asm(
  536|      5|      "xorl %%r9d, %%r9d\n\t"
  537|      5|      "xorl %%r10d, %%r10d\n\t"
  538|      5|      "xorl %%r11d, %%r11d\n\t"
  539|      5|      "xorl %%r12d, %%r12d\n\t"
  540|      5|      "xorl %%r13d, %%r13d\n\t"
  541|      5|      "xorl %%r14d, %%r14d\n\t"
  542|      5|      "xorl %%r8d, %%r8d\n\t"
  543|       |
  544|      5|      "movq 0(%[x]), %%rdx\n\t"  // x[0] * x[1..7]
  545|      5|      "xorl %%eax, %%eax\n\t"
  546|      5|      "mulx 8(%[x]), %%rax, %%rcx\n\t"
  547|      5|      "adcx %%rax, %%r9\n\t"
  548|      5|      "movq %%r9, 8(%[z])\n\t"
  549|      5|      "mulx 16(%[x]), %%rax, %%r9\n\t"
  550|      5|      "adox %%rcx, %%rax\n\t"
  551|      5|      "adcx %%rax, %%r10\n\t"
  552|      5|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
  553|      5|      "adox %%r9, %%rax\n\t"
  554|      5|      "adcx %%rax, %%r11\n\t"
  555|      5|      "mulx 32(%[x]), %%rax, %%r9\n\t"
  556|      5|      "adox %%rcx, %%rax\n\t"
  557|      5|      "adcx %%rax, %%r12\n\t"
  558|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  559|      5|      "adox %%r9, %%rax\n\t"
  560|      5|      "adcx %%rax, %%r13\n\t"
  561|      5|      "mulx 48(%[x]), %%rax, %%r9\n\t"
  562|      5|      "adox %%rcx, %%rax\n\t"
  563|      5|      "adcx %%rax, %%r14\n\t"
  564|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
  565|      5|      "adox %%r9, %%rax\n\t"
  566|      5|      "adcx %%rax, %%r8\n\t"
  567|      5|      "movl $0, %%eax\n\t"
  568|      5|      "adox %%rax, %%rcx\n\t"
  569|      5|      "adcx %%rax, %%rcx\n\t"
  570|      5|      "movq %%rcx, %%r9\n\t"
  571|      5|      "movq %%r10, 16(%[z])\n\t"
  572|       |
  573|      5|      "movq 8(%[x]), %%rdx\n\t"  // x[1] * x[2..7]
  574|      5|      "xorl %%eax, %%eax\n\t"
  575|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  576|      5|      "adcx %%rax, %%r11\n\t"
  577|      5|      "movq %%r11, 24(%[z])\n\t"
  578|      5|      "mulx 24(%[x]), %%rax, %%r10\n\t"
  579|      5|      "adox %%rcx, %%rax\n\t"
  580|      5|      "adcx %%rax, %%r12\n\t"
  581|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  582|      5|      "adox %%r10, %%rax\n\t"
  583|      5|      "adcx %%rax, %%r13\n\t"
  584|      5|      "mulx 40(%[x]), %%rax, %%r10\n\t"
  585|      5|      "adox %%rcx, %%rax\n\t"
  586|      5|      "adcx %%rax, %%r14\n\t"
  587|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  588|      5|      "adox %%r10, %%rax\n\t"
  589|      5|      "adcx %%rax, %%r8\n\t"
  590|      5|      "mulx 56(%[x]), %%rax, %%r10\n\t"
  591|      5|      "adox %%rcx, %%rax\n\t"
  592|      5|      "adcx %%rax, %%r9\n\t"
  593|      5|      "movl $0, %%eax\n\t"
  594|      5|      "adox %%rax, %%r10\n\t"
  595|      5|      "adcx %%rax, %%r10\n\t"
  596|      5|      "movq %%r12, 32(%[z])\n\t"
  597|       |
  598|      5|      "movq 16(%[x]), %%rdx\n\t"  // x[2] * x[3..7]
  599|      5|      "xorl %%eax, %%eax\n\t"
  600|      5|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
  601|      5|      "adcx %%rax, %%r13\n\t"
  602|      5|      "movq %%r13, 40(%[z])\n\t"
  603|      5|      "mulx 32(%[x]), %%rax, %%r11\n\t"
  604|      5|      "adox %%rcx, %%rax\n\t"
  605|      5|      "adcx %%rax, %%r14\n\t"
  606|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  607|      5|      "adox %%r11, %%rax\n\t"
  608|      5|      "adcx %%rax, %%r8\n\t"
  609|      5|      "mulx 48(%[x]), %%rax, %%r11\n\t"
  610|      5|      "adox %%rcx, %%rax\n\t"
  611|      5|      "adcx %%rax, %%r9\n\t"
  612|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
  613|      5|      "adox %%r11, %%rax\n\t"
  614|      5|      "adcx %%rax, %%r10\n\t"
  615|      5|      "movl $0, %%eax\n\t"
  616|      5|      "adox %%rax, %%rcx\n\t"
  617|      5|      "adcx %%rax, %%rcx\n\t"
  618|      5|      "movq %%rcx, %%r11\n\t"
  619|      5|      "movq %%r14, 48(%[z])\n\t"
  620|       |
  621|      5|      "movq 24(%[x]), %%rdx\n\t"  // x[3] * x[4..7]
  622|      5|      "xorl %%eax, %%eax\n\t"
  623|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  624|      5|      "adcx %%rax, %%r8\n\t"
  625|      5|      "movq %%r8, 56(%[z])\n\t"
  626|      5|      "mulx 40(%[x]), %%rax, %%r12\n\t"
  627|      5|      "adox %%rcx, %%rax\n\t"
  628|      5|      "adcx %%rax, %%r9\n\t"
  629|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  630|      5|      "adox %%r12, %%rax\n\t"
  631|      5|      "adcx %%rax, %%r10\n\t"
  632|      5|      "mulx 56(%[x]), %%rax, %%r12\n\t"
  633|      5|      "adox %%rcx, %%rax\n\t"
  634|      5|      "adcx %%rax, %%r11\n\t"
  635|      5|      "movl $0, %%eax\n\t"
  636|      5|      "adox %%rax, %%r12\n\t"
  637|      5|      "adcx %%rax, %%r12\n\t"
  638|      5|      "movq %%r9, 64(%[z])\n\t"
  639|       |
  640|      5|      "movq 32(%[x]), %%rdx\n\t"  // x[4] * x[5..7]
  641|      5|      "xorl %%eax, %%eax\n\t"
  642|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
  643|      5|      "adcx %%rax, %%r10\n\t"
  644|      5|      "movq %%r10, 72(%[z])\n\t"
  645|      5|      "mulx 48(%[x]), %%rax, %%r13\n\t"
  646|      5|      "adox %%rcx, %%rax\n\t"
  647|      5|      "adcx %%rax, %%r11\n\t"
  648|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
  649|      5|      "adox %%r13, %%rax\n\t"
  650|      5|      "adcx %%rax, %%r12\n\t"
  651|      5|      "movl $0, %%eax\n\t"
  652|      5|      "adox %%rax, %%rcx\n\t"
  653|      5|      "adcx %%rax, %%rcx\n\t"
  654|      5|      "movq %%rcx, %%r13\n\t"
  655|      5|      "movq %%r11, 80(%[z])\n\t"
  656|       |
  657|      5|      "movq 40(%[x]), %%rdx\n\t"  // x[5] * x[6..7]
  658|      5|      "xorl %%eax, %%eax\n\t"
  659|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  660|      5|      "adcx %%rax, %%r12\n\t"
  661|      5|      "movq %%r12, 88(%[z])\n\t"
  662|      5|      "mulx 56(%[x]), %%rax, %%r14\n\t"
  663|      5|      "adox %%rcx, %%rax\n\t"
  664|      5|      "adcx %%rax, %%r13\n\t"
  665|      5|      "movl $0, %%eax\n\t"
  666|      5|      "adox %%rax, %%r14\n\t"
  667|      5|      "adcx %%rax, %%r14\n\t"
  668|      5|      "movq %%r13, 96(%[z])\n\t"
  669|       |
  670|      5|      "movq 48(%[x]), %%rdx\n\t"  // x[6] * x[7..7]
  671|      5|      "xorl %%eax, %%eax\n\t"
  672|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
  673|      5|      "adcx %%rax, %%r14\n\t"
  674|      5|      "movq %%r14, 104(%[z])\n\t"
  675|      5|      "movl $0, %%eax\n\t"
  676|      5|      "adox %%rax, %%rcx\n\t"
  677|      5|      "adcx %%rax, %%rcx\n\t"
  678|      5|      "movq %%rcx, %%r8\n\t"
  679|      5|      "movq %%r8, 112(%[z])\n\t"
  680|       |
  681|      5|      "movq $0, 120(%[z])\n\t"
  682|      5|      "xorl %%eax, %%eax\n\t"  // double the cross products and add the squares
  683|      5|      "movq 0(%[x]), %%rdx\n\t"
  684|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  685|      5|      "movq %%rax, 0(%[z])\n\t"
  686|      5|      "movq 8(%[z]), %%r8\n\t"
  687|      5|      "adcx %%r8, %%r8\n\t"
  688|      5|      "adox %%rcx, %%r8\n\t"
  689|      5|      "movq %%r8, 8(%[z])\n\t"
  690|      5|      "movq 8(%[x]), %%rdx\n\t"
  691|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  692|      5|      "movq 16(%[z]), %%r8\n\t"
  693|      5|      "adcx %%r8, %%r8\n\t"
  694|      5|      "adox %%rax, %%r8\n\t"
  695|      5|      "movq %%r8, 16(%[z])\n\t"
  696|      5|      "movq 24(%[z]), %%r8\n\t"
  697|      5|      "adcx %%r8, %%r8\n\t"
  698|      5|      "adox %%rcx, %%r8\n\t"
  699|      5|      "movq %%r8, 24(%[z])\n\t"
  700|      5|      "movq 16(%[x]), %%rdx\n\t"
  701|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  702|      5|      "movq 32(%[z]), %%r8\n\t"
  703|      5|      "adcx %%r8, %%r8\n\t"
  704|      5|      "adox %%rax, %%r8\n\t"
  705|      5|      "movq %%r8, 32(%[z])\n\t"
  706|      5|      "movq 40(%[z]), %%r8\n\t"
  707|      5|      "adcx %%r8, %%r8\n\t"
  708|      5|      "adox %%rcx, %%r8\n\t"
  709|      5|      "movq %%r8, 40(%[z])\n\t"
  710|      5|      "movq 24(%[x]), %%rdx\n\t"
  711|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  712|      5|      "movq 48(%[z]), %%r8\n\t"
  713|      5|      "adcx %%r8, %%r8\n\t"
  714|      5|      "adox %%rax, %%r8\n\t"
  715|      5|      "movq %%r8, 48(%[z])\n\t"
  716|      5|      "movq 56(%[z]), %%r8\n\t"
  717|      5|      "adcx %%r8, %%r8\n\t"
  718|      5|      "adox %%rcx, %%r8\n\t"
  719|      5|      "movq %%r8, 56(%[z])\n\t"
  720|      5|      "movq 32(%[x]), %%rdx\n\t"
  721|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  722|      5|      "movq 64(%[z]), %%r8\n\t"
  723|      5|      "adcx %%r8, %%r8\n\t"
  724|      5|      "adox %%rax, %%r8\n\t"
  725|      5|      "movq %%r8, 64(%[z])\n\t"
  726|      5|      "movq 72(%[z]), %%r8\n\t"
  727|      5|      "adcx %%r8, %%r8\n\t"
  728|      5|      "adox %%rcx, %%r8\n\t"
  729|      5|      "movq %%r8, 72(%[z])\n\t"
  730|      5|      "movq 40(%[x]), %%rdx\n\t"
  731|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  732|      5|      "movq 80(%[z]), %%r8\n\t"
  733|      5|      "adcx %%r8, %%r8\n\t"
  734|      5|      "adox %%rax, %%r8\n\t"
  735|      5|      "movq %%r8, 80(%[z])\n\t"
  736|      5|      "movq 88(%[z]), %%r8\n\t"
  737|      5|      "adcx %%r8, %%r8\n\t"
  738|      5|      "adox %%rcx, %%r8\n\t"
  739|      5|      "movq %%r8, 88(%[z])\n\t"
  740|      5|      "movq 48(%[x]), %%rdx\n\t"
  741|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  742|      5|      "movq 96(%[z]), %%r8\n\t"
  743|      5|      "adcx %%r8, %%r8\n\t"
  744|      5|      "adox %%rax, %%r8\n\t"
  745|      5|      "movq %%r8, 96(%[z])\n\t"
  746|      5|      "movq 104(%[z]), %%r8\n\t"
  747|      5|      "adcx %%r8, %%r8\n\t"
  748|      5|      "adox %%rcx, %%r8\n\t"
  749|      5|      "movq %%r8, 104(%[z])\n\t"
  750|      5|      "movq 56(%[x]), %%rdx\n\t"
  751|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
  752|      5|      "movq 112(%[z]), %%r8\n\t"
  753|      5|      "adcx %%r8, %%r8\n\t"
  754|      5|      "adox %%rax, %%r8\n\t"
  755|      5|      "movq %%r8, 112(%[z])\n\t"
  756|      5|      "movq 120(%[z]), %%r8\n\t"
  757|      5|      "adcx %%r8, %%r8\n\t"
  758|      5|      "adox %%rcx, %%r8\n\t"
  759|      5|      "movq %%r8, 120(%[z])\n\t"
  760|      5|      :
  761|      5|      : [z] "r"(z), [x] "r"(x)
  762|      5|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc", "memory");
  763|       |   // clang-format on
  764|      5|}
_ZN5Botan16bigint_mulx_mul8EPmPKmS2_:
  766|     10|void bigint_mulx_mul8(word z[16], const word x[8], const word y[8]) {
  767|       |   // clang-format off
  768|     10|   asm(
  769|     10|      "xorl %%r8d, %%r8d\n\t"
  770|     10|      "xorl %%r9d, %%r9d\n\t"
  771|     10|      "xorl %%r10d, %%r10d\n\t"
  772|     10|      "xorl %%r11d, %%r11d\n\t"
  773|     10|      "xorl %%r12d, %%r12d\n\t"
  774|     10|      "xorl %%r13d, %%r13d\n\t"
  775|     10|      "xorl %%r14d, %%r14d\n\t"
  776|     10|      "xorl %%r15d, %%r15d\n\t"
  777|       |
  778|     10|      "movq 0(%[y]), %%rdx\n\t"  // row 0: x * y[0]
  779|     10|      "xorl %%eax, %%eax\n\t"
  780|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  781|     10|      "adcx %%rax, %%r8\n\t"
  782|     10|      "movq %%r8, 0(%[z])\n\t"
  783|     10|      "mulx 8(%[x]), %%rax, %%r8\n\t"
  784|     10|      "adox %%rcx, %%rax\n\t"
  785|     10|      "adcx %%rax, %%r9\n\t"
  786|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  787|     10|      "adox %%r8, %%rax\n\t"
  788|     10|      "adcx %%rax, %%r10\n\t"
  789|     10|      "mulx 24(%[x]), %%rax, %%r8\n\t"
  790|     10|      "adox %%rcx, %%rax\n\t"
  791|     10|      "adcx %%rax, %%r11\n\t"
  792|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  793|     10|      "adox %%r8, %%rax\n\t"
  794|     10|      "adcx %%rax, %%r12\n\t"
  795|     10|      "mulx 40(%[x]), %%rax, %%r8\n\t"
  796|     10|      "adox %%rcx, %%rax\n\t"
  797|     10|      "adcx %%rax, %%r13\n\t"
  798|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  799|     10|      "adox %%r8, %%rax\n\t"
  800|     10|      "adcx %%rax, %%r14\n\t"
  801|     10|      "mulx 56(%[x]), %%rax, %%r8\n\t"
  802|     10|      "adox %%rcx, %%rax\n\t"
  803|     10|      "adcx %%rax, %%r15\n\t"
  804|     10|      "movl $0, %%eax\n\t"
  805|     10|      "adox %%rax, %%r8\n\t"
  806|     10|      "adcx %%rax, %%r8\n\t"
  807|       |
  808|     10|      "movq 8(%[y]), %%rdx\n\t"  // row 1: x * y[1]
  809|     10|      "xorl %%eax, %%eax\n\t"
  810|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  811|     10|      "adcx %%rax, %%r9\n\t"
  812|     10|      "movq %%r9, 8(%[z])\n\t"
  813|     10|      "mulx 8(%[x]), %%rax, %%r9\n\t"
  814|     10|      "adox %%rcx, %%rax\n\t"
  815|     10|      "adcx %%rax, %%r10\n\t"
  816|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  817|     10|      "adox %%r9, %%rax\n\t"
  818|     10|      "adcx %%rax, %%r11\n\t"
  819|     10|      "mulx 24(%[x]), %%rax, %%r9\n\t"
  820|     10|      "adox %%rcx, %%rax\n\t"
  821|     10|      "adcx %%rax, %%r12\n\t"
  822|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  823|     10|      "adox %%r9, %%rax\n\t"
  824|     10|      "adcx %%rax, %%r13\n\t"
  825|     10|      "mulx 40(%[x]), %%rax, %%r9\n\t"
  826|     10|      "adox %%rcx, %%rax\n\t"
  827|     10|      "adcx %%rax, %%r14\n\t"
  828|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  829|     10|      "adox %%r9, %%rax\n\t"
  830|     10|      "adcx %%rax, %%r15\n\t"
  831|     10|      "mulx 56(%[x]), %%rax, %%r9\n\t"
  832|     10|      "adox %%rcx, %%rax\n\t"
  833|     10|      "adcx %%rax, %%r8\n\t"
  834|     10|      "movl $0, %%eax\n\t"
  835|     10|      "adox %%rax, %%r9\n\t"
  836|     10|      "adcx %%rax, %%r9\n\t"
  837|       |
  838|     10|      "movq 16(%[y]), %%rdx\n\t"  // row 2: x * y[2]
  839|     10|      "xorl %%eax, %%eax\n\t"
  840|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  841|     10|      "adcx %%rax, %%r10\n\t"
  842|     10|      "movq %%r10, 16(%[z])\n\t"
  843|     10|      "mulx 8(%[x]), %%rax, %%r10\n\t"
  844|     10|      "adox %%rcx, %%rax\n\t"
  845|     10|      "adcx %%rax, %%r11\n\t"
  846|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  847|     10|      "adox %%r10, %%rax\n\t"
  848|     10|      "adcx %%rax, %%r12\n\t"
  849|     10|      "mulx 24(%[x]), %%rax, %%r10\n\t"
  850|     10|      "adox %%rcx, %%rax\n\t"
  851|     10|      "adcx %%rax, %%r13\n\t"
  852|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  853|     10|      "adox %%r10, %%rax\n\t"
  854|     10|      "adcx %%rax, %%r14\n\t"
  855|     10|      "mulx 40(%[x]), %%rax, %%r10\n\t"
  856|     10|      "adox %%rcx, %%rax\n\t"
  857|     10|      "adcx %%rax, %%r15\n\t"
  858|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  859|     10|      "adox %%r10, %%rax\n\t"
  860|     10|      "adcx %%rax, %%r8\n\t"
  861|     10|      "mulx 56(%[x]), %%rax, %%r10\n\t"
  862|     10|      "adox %%rcx, %%rax\n\t"
  863|     10|      "adcx %%rax, %%r9\n\t"
  864|     10|      "movl $0, %%eax\n\t"
  865|     10|      "adox %%rax, %%r10\n\t"
  866|     10|      "adcx %%rax, %%r10\n\t"
  867|       |
  868|     10|      "movq 24(%[y]), %%rdx\n\t"  // row 3: x * y[3]
  869|     10|      "xorl %%eax, %%eax\n\t"
  870|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  871|     10|      "adcx %%rax, %%r11\n\t"
  872|     10|      "movq %%r11, 24(%[z])\n\t"
  873|     10|      "mulx 8(%[x]), %%rax, %%r11\n\t"
  874|     10|      "adox %%rcx, %%rax\n\t"
  875|     10|      "adcx %%rax, %%r12\n\t"
  876|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  877|     10|      "adox %%r11, %%rax\n\t"
  878|     10|      "adcx %%rax, %%r13\n\t"
  879|     10|      "mulx 24(%[x]), %%rax, %%r11\n\t"
  880|     10|      "adox %%rcx, %%rax\n\t"
  881|     10|      "adcx %%rax, %%r14\n\t"
  882|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  883|     10|      "adox %%r11, %%rax\n\t"
  884|     10|      "adcx %%rax, %%r15\n\t"
  885|     10|      "mulx 40(%[x]), %%rax, %%r11\n\t"
  886|     10|      "adox %%rcx, %%rax\n\t"
  887|     10|      "adcx %%rax, %%r8\n\t"
  888|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  889|     10|      "adox %%r11, %%rax\n\t"
  890|     10|      "adcx %%rax, %%r9\n\t"
  891|     10|      "mulx 56(%[x]), %%rax, %%r11\n\t"
  892|     10|      "adox %%rcx, %%rax\n\t"
  893|     10|      "adcx %%rax, %%r10\n\t"
  894|     10|      "movl $0, %%eax\n\t"
  895|     10|      "adox %%rax, %%r11\n\t"
  896|     10|      "adcx %%rax, %%r11\n\t"
  897|       |
  898|     10|      "movq 32(%[y]), %%rdx\n\t"  // row 4: x * y[4]
  899|     10|      "xorl %%eax, %%eax\n\t"
  900|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  901|     10|      "adcx %%rax, %%r12\n\t"
  902|     10|      "movq %%r12, 32(%[z])\n\t"
  903|     10|      "mulx 8(%[x]), %%rax, %%r12\n\t"
  904|     10|      "adox %%rcx, %%rax\n\t"
  905|     10|      "adcx %%rax, %%r13\n\t"
  906|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  907|     10|      "adox %%r12, %%rax\n\t"
  908|     10|      "adcx %%rax, %%r14\n\t"
  909|     10|      "mulx 24(%[x]), %%rax, %%r12\n\t"
  910|     10|      "adox %%rcx, %%rax\n\t"
  911|     10|      "adcx %%rax, %%r15\n\t"
  912|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  913|     10|      "adox %%r12, %%rax\n\t"
  914|     10|      "adcx %%rax, %%r8\n\t"
  915|     10|      "mulx 40(%[x]), %%rax, %%r12\n\t"
  916|     10|      "adox %%rcx, %%rax\n\t"
  917|     10|      "adcx %%rax, %%r9\n\t"
  918|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  919|     10|      "adox %%r12, %%rax\n\t"
  920|     10|      "adcx %%rax, %%r10\n\t"
  921|     10|      "mulx 56(%[x]), %%rax, %%r12\n\t"
  922|     10|      "adox %%rcx, %%rax\n\t"
  923|     10|      "adcx %%rax, %%r11\n\t"
  924|     10|      "movl $0, %%eax\n\t"
  925|     10|      "adox %%rax, %%r12\n\t"
  926|     10|      "adcx %%rax, %%r12\n\t"
  927|       |
  928|     10|      "movq 40(%[y]), %%rdx\n\t"  // row 5: x * y[5]
  929|     10|      "xorl %%eax, %%eax\n\t"
  930|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  931|     10|      "adcx %%rax, %%r13\n\t"
  932|     10|      "movq %%r13, 40(%[z])\n\t"
  933|     10|      "mulx 8(%[x]), %%rax, %%r13\n\t"
  934|     10|      "adox %%rcx, %%rax\n\t"
  935|     10|      "adcx %%rax, %%r14\n\t"
  936|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  937|     10|      "adox %%r13, %%rax\n\t"
  938|     10|      "adcx %%rax, %%r15\n\t"
  939|     10|      "mulx 24(%[x]), %%rax, %%r13\n\t"
  940|     10|      "adox %%rcx, %%rax\n\t"
  941|     10|      "adcx %%rax, %%r8\n\t"
  942|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  943|     10|      "adox %%r13, %%rax\n\t"
  944|     10|      "adcx %%rax, %%r9\n\t"
  945|     10|      "mulx 40(%[x]), %%rax, %%r13\n\t"
  946|     10|      "adox %%rcx, %%rax\n\t"
  947|     10|      "adcx %%rax, %%r10\n\t"
  948|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  949|     10|      "adox %%r13, %%rax\n\t"
  950|     10|      "adcx %%rax, %%r11\n\t"
  951|     10|      "mulx 56(%[x]), %%rax, %%r13\n\t"
  952|     10|      "adox %%rcx, %%rax\n\t"
  953|     10|      "adcx %%rax, %%r12\n\t"
  954|     10|      "movl $0, %%eax\n\t"
  955|     10|      "adox %%rax, %%r13\n\t"
  956|     10|      "adcx %%rax, %%r13\n\t"
  957|       |
  958|     10|      "movq 48(%[y]), %%rdx\n\t"  // row 6: x * y[6]
  959|     10|      "xorl %%eax, %%eax\n\t"
  960|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  961|     10|      "adcx %%rax, %%r14\n\t"
  962|     10|      "movq %%r14, 48(%[z])\n\t"
  963|     10|      "mulx 8(%[x]), %%rax, %%r14\n\t"
  964|     10|      "adox %%rcx, %%rax\n\t"
  965|     10|      "adcx %%rax, %%r15\n\t"
  966|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  967|     10|      "adox %%r14, %%rax\n\t"
  968|     10|      "adcx %%rax, %%r8\n\t"
  969|     10|      "mulx 24(%[x]), %%rax, %%r14\n\t"
  970|     10|      "adox %%rcx, %%rax\n\t"
  971|     10|      "adcx %%rax, %%r9\n\t"
  972|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
  973|     10|      "adox %%r14, %%rax\n\t"
  974|     10|      "adcx %%rax, %%r10\n\t"
  975|     10|      "mulx 40(%[x]), %%rax, %%r14\n\t"
  976|     10|      "adox %%rcx, %%rax\n\t"
  977|     10|      "adcx %%rax, %%r11\n\t"
  978|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
  979|     10|      "adox %%r14, %%rax\n\t"
  980|     10|      "adcx %%rax, %%r12\n\t"
  981|     10|      "mulx 56(%[x]), %%rax, %%r14\n\t"
  982|     10|      "adox %%rcx, %%rax\n\t"
  983|     10|      "adcx %%rax, %%r13\n\t"
  984|     10|      "movl $0, %%eax\n\t"
  985|     10|      "adox %%rax, %%r14\n\t"
  986|     10|      "adcx %%rax, %%r14\n\t"
  987|       |
  988|     10|      "movq 56(%[y]), %%rdx\n\t"  // row 7: x * y[7]
  989|     10|      "xorl %%eax, %%eax\n\t"
  990|     10|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
  991|     10|      "adcx %%rax, %%r15\n\t"
  992|     10|      "movq %%r15, 56(%[z])\n\t"
  993|     10|      "mulx 8(%[x]), %%rax, %%r15\n\t"
  994|     10|      "adox %%rcx, %%rax\n\t"
  995|     10|      "adcx %%rax, %%r8\n\t"
  996|     10|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
  997|     10|      "adox %%r15, %%rax\n\t"
  998|     10|      "adcx %%rax, %%r9\n\t"
  999|     10|      "mulx 24(%[x]), %%rax, %%r15\n\t"
 1000|     10|      "adox %%rcx, %%rax\n\t"
 1001|     10|      "adcx %%rax, %%r10\n\t"
 1002|     10|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1003|     10|      "adox %%r15, %%rax\n\t"
 1004|     10|      "adcx %%rax, %%r11\n\t"
 1005|     10|      "mulx 40(%[x]), %%rax, %%r15\n\t"
 1006|     10|      "adox %%rcx, %%rax\n\t"
 1007|     10|      "adcx %%rax, %%r12\n\t"
 1008|     10|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1009|     10|      "adox %%r15, %%rax\n\t"
 1010|     10|      "adcx %%rax, %%r13\n\t"
 1011|     10|      "mulx 56(%[x]), %%rax, %%r15\n\t"
 1012|     10|      "adox %%rcx, %%rax\n\t"
 1013|     10|      "adcx %%rax, %%r14\n\t"
 1014|     10|      "movl $0, %%eax\n\t"
 1015|     10|      "adox %%rax, %%r15\n\t"
 1016|     10|      "adcx %%rax, %%r15\n\t"
 1017|       |
 1018|     10|      "movq %%r8, 64(%[z])\n\t"
 1019|     10|      "movq %%r9, 72(%[z])\n\t"
 1020|     10|      "movq %%r10, 80(%[z])\n\t"
 1021|     10|      "movq %%r11, 88(%[z])\n\t"
 1022|     10|      "movq %%r12, 96(%[z])\n\t"
 1023|     10|      "movq %%r13, 104(%[z])\n\t"
 1024|     10|      "movq %%r14, 112(%[z])\n\t"
 1025|     10|      "movq %%r15, 120(%[z])\n\t"
 1026|     10|      :
 1027|     10|      : [z] "r"(z), [x] "r"(x), [y] "r"(y)
 1028|     10|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "cc", "memory");
 1029|       |   // clang-format on
 1030|     10|}
_ZN5Botan16bigint_mulx_sqr9EPmPKm:
 1032|      5|void bigint_mulx_sqr9(word z[18], const word x[9]) {
 1033|       |   // clang-format off
 1034|      5|   asm(
 1035|      5|      "xorl %%r9d, %%r9d\n\t"
 1036|      5|      "xorl %%r10d, %%r10d\n\t"
 1037|      5|      "xorl %%r11d, %%r11d\n\t"
 1038|      5|      "xorl %%r12d, %%r12d\n\t"
 1039|      5|      "xorl %%r13d, %%r13d\n\t"
 1040|      5|      "xorl %%r14d, %%r14d\n\t"
 1041|      5|      "xorl %%r15d, %%r15d\n\t"
 1042|      5|      "xorl %%r8d, %%r8d\n\t"
 1043|       |
 1044|      5|      "movq 0(%[x]), %%rdx\n\t"  // x[0] * x[1..8]
 1045|      5|      "xorl %%eax, %%eax\n\t"
 1046|      5|      "mulx 8(%[x]), %%rax, %%rcx\n\t"
 1047|      5|      "adcx %%rax, %%r9\n\t"
 1048|      5|      "movq %%r9, 8(%[z])\n\t"
 1049|      5|      "mulx 16(%[x]), %%rax, %%r9\n\t"
 1050|      5|      "adox %%rcx, %%rax\n\t"
 1051|      5|      "adcx %%rax, %%r10\n\t"
 1052|      5|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
 1053|      5|      "adox %%r9, %%rax\n\t"
 1054|      5|      "adcx %%rax, %%r11\n\t"
 1055|      5|      "mulx 32(%[x]), %%rax, %%r9\n\t"
 1056|      5|      "adox %%rcx, %%rax\n\t"
 1057|      5|      "adcx %%rax, %%r12\n\t"
 1058|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
 1059|      5|      "adox %%r9, %%rax\n\t"
 1060|      5|      "adcx %%rax, %%r13\n\t"
 1061|      5|      "mulx 48(%[x]), %%rax, %%r9\n\t"
 1062|      5|      "adox %%rcx, %%rax\n\t"
 1063|      5|      "adcx %%rax, %%r14\n\t"
 1064|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
 1065|      5|      "adox %%r9, %%rax\n\t"
 1066|      5|      "adcx %%rax, %%r15\n\t"
 1067|      5|      "mulx 64(%[x]), %%rax, %%r9\n\t"
 1068|      5|      "adox %%rcx, %%rax\n\t"
 1069|      5|      "adcx %%rax, %%r8\n\t"
 1070|      5|      "movl $0, %%eax\n\t"
 1071|      5|      "adox %%rax, %%r9\n\t"
 1072|      5|      "adcx %%rax, %%r9\n\t"
 1073|      5|      "movq %%r10, 16(%[z])\n\t"
 1074|       |
 1075|      5|      "movq 8(%[x]), %%rdx\n\t"  // x[1] * x[2..8]
 1076|      5|      "xorl %%eax, %%eax\n\t"
 1077|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1078|      5|      "adcx %%rax, %%r11\n\t"
 1079|      5|      "movq %%r11, 24(%[z])\n\t"
 1080|      5|      "mulx 24(%[x]), %%rax, %%r10\n\t"
 1081|      5|      "adox %%rcx, %%rax\n\t"
 1082|      5|      "adcx %%rax, %%r12\n\t"
 1083|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1084|      5|      "adox %%r10, %%rax\n\t"
 1085|      5|      "adcx %%rax, %%r13\n\t"
 1086|      5|      "mulx 40(%[x]), %%rax, %%r10\n\t"
 1087|      5|      "adox %%rcx, %%rax\n\t"
 1088|      5|      "adcx %%rax, %%r14\n\t"
 1089|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1090|      5|      "adox %%r10, %%rax\n\t"
 1091|      5|      "adcx %%rax, %%r15\n\t"
 1092|      5|      "mulx 56(%[x]), %%rax, %%r10\n\t"
 1093|      5|      "adox %%rcx, %%rax\n\t"
 1094|      5|      "adcx %%rax, %%r8\n\t"
 1095|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1096|      5|      "adox %%r10, %%rax\n\t"
 1097|      5|      "adcx %%rax, %%r9\n\t"
 1098|      5|      "movl $0, %%eax\n\t"
 1099|      5|      "adox %%rax, %%rcx\n\t"
 1100|      5|      "adcx %%rax, %%rcx\n\t"
 1101|      5|      "movq %%rcx, %%r10\n\t"
 1102|      5|      "movq %%r12, 32(%[z])\n\t"
 1103|       |
 1104|      5|      "movq 16(%[x]), %%rdx\n\t"  // x[2] * x[3..8]
 1105|      5|      "xorl %%eax, %%eax\n\t"
 1106|      5|      "mulx 24(%[x]), %%rax, %%rcx\n\t"
 1107|      5|      "adcx %%rax, %%r13\n\t"
 1108|      5|      "movq %%r13, 40(%[z])\n\t"
 1109|      5|      "mulx 32(%[x]), %%rax, %%r11\n\t"
 1110|      5|      "adox %%rcx, %%rax\n\t"
 1111|      5|      "adcx %%rax, %%r14\n\t"
 1112|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
 1113|      5|      "adox %%r11, %%rax\n\t"
 1114|      5|      "adcx %%rax, %%r15\n\t"
 1115|      5|      "mulx 48(%[x]), %%rax, %%r11\n\t"
 1116|      5|      "adox %%rcx, %%rax\n\t"
 1117|      5|      "adcx %%rax, %%r8\n\t"
 1118|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
 1119|      5|      "adox %%r11, %%rax\n\t"
 1120|      5|      "adcx %%rax, %%r9\n\t"
 1121|      5|      "mulx 64(%[x]), %%rax, %%r11\n\t"
 1122|      5|      "adox %%rcx, %%rax\n\t"
 1123|      5|      "adcx %%rax, %%r10\n\t"
 1124|      5|      "movl $0, %%eax\n\t"
 1125|      5|      "adox %%rax, %%r11\n\t"
 1126|      5|      "adcx %%rax, %%r11\n\t"
 1127|      5|      "movq %%r14, 48(%[z])\n\t"
 1128|       |
 1129|      5|      "movq 24(%[x]), %%rdx\n\t"  // x[3] * x[4..8]
 1130|      5|      "xorl %%eax, %%eax\n\t"
 1131|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1132|      5|      "adcx %%rax, %%r15\n\t"
 1133|      5|      "movq %%r15, 56(%[z])\n\t"
 1134|      5|      "mulx 40(%[x]), %%rax, %%r12\n\t"
 1135|      5|      "adox %%rcx, %%rax\n\t"
 1136|      5|      "adcx %%rax, %%r8\n\t"
 1137|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1138|      5|      "adox %%r12, %%rax\n\t"
 1139|      5|      "adcx %%rax, %%r9\n\t"
 1140|      5|      "mulx 56(%[x]), %%rax, %%r12\n\t"
 1141|      5|      "adox %%rcx, %%rax\n\t"
 1142|      5|      "adcx %%rax, %%r10\n\t"
 1143|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1144|      5|      "adox %%r12, %%rax\n\t"
 1145|      5|      "adcx %%rax, %%r11\n\t"
 1146|      5|      "movl $0, %%eax\n\t"
 1147|      5|      "adox %%rax, %%rcx\n\t"
 1148|      5|      "adcx %%rax, %%rcx\n\t"
 1149|      5|      "movq %%rcx, %%r12\n\t"
 1150|      5|      "movq %%r8, 64(%[z])\n\t"
 1151|       |
 1152|      5|      "movq 32(%[x]), %%rdx\n\t"  // x[4] * x[5..8]
 1153|      5|      "xorl %%eax, %%eax\n\t"
 1154|      5|      "mulx 40(%[x]), %%rax, %%rcx\n\t"
 1155|      5|      "adcx %%rax, %%r9\n\t"
 1156|      5|      "movq %%r9, 72(%[z])\n\t"
 1157|      5|      "mulx 48(%[x]), %%rax, %%r13\n\t"
 1158|      5|      "adox %%rcx, %%rax\n\t"
 1159|      5|      "adcx %%rax, %%r10\n\t"
 1160|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
 1161|      5|      "adox %%r13, %%rax\n\t"
 1162|      5|      "adcx %%rax, %%r11\n\t"
 1163|      5|      "mulx 64(%[x]), %%rax, %%r13\n\t"
 1164|      5|      "adox %%rcx, %%rax\n\t"
 1165|      5|      "adcx %%rax, %%r12\n\t"
 1166|      5|      "movl $0, %%eax\n\t"
 1167|      5|      "adox %%rax, %%r13\n\t"
 1168|      5|      "adcx %%rax, %%r13\n\t"
 1169|      5|      "movq %%r10, 80(%[z])\n\t"
 1170|       |
 1171|      5|      "movq 40(%[x]), %%rdx\n\t"  // x[5] * x[6..8]
 1172|      5|      "xorl %%eax, %%eax\n\t"
 1173|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1174|      5|      "adcx %%rax, %%r11\n\t"
 1175|      5|      "movq %%r11, 88(%[z])\n\t"
 1176|      5|      "mulx 56(%[x]), %%rax, %%r14\n\t"
 1177|      5|      "adox %%rcx, %%rax\n\t"
 1178|      5|      "adcx %%rax, %%r12\n\t"
 1179|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1180|      5|      "adox %%r14, %%rax\n\t"
 1181|      5|      "adcx %%rax, %%r13\n\t"
 1182|      5|      "movl $0, %%eax\n\t"
 1183|      5|      "adox %%rax, %%rcx\n\t"
 1184|      5|      "adcx %%rax, %%rcx\n\t"
 1185|      5|      "movq %%rcx, %%r14\n\t"
 1186|      5|      "movq %%r12, 96(%[z])\n\t"
 1187|       |
 1188|      5|      "movq 48(%[x]), %%rdx\n\t"  // x[6] * x[7..8]
 1189|      5|      "xorl %%eax, %%eax\n\t"
 1190|      5|      "mulx 56(%[x]), %%rax, %%rcx\n\t"
 1191|      5|      "adcx %%rax, %%r13\n\t"
 1192|      5|      "movq %%r13, 104(%[z])\n\t"
 1193|      5|      "mulx 64(%[x]), %%rax, %%r15\n\t"
 1194|      5|      "adox %%rcx, %%rax\n\t"
 1195|      5|      "adcx %%rax, %%r14\n\t"
 1196|      5|      "movl $0, %%eax\n\t"
 1197|      5|      "adox %%rax, %%r15\n\t"
 1198|      5|      "adcx %%rax, %%r15\n\t"
 1199|      5|      "movq %%r14, 112(%[z])\n\t"
 1200|       |
 1201|      5|      "movq 56(%[x]), %%rdx\n\t"  // x[7] * x[8..8]
 1202|      5|      "xorl %%eax, %%eax\n\t"
 1203|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1204|      5|      "adcx %%rax, %%r15\n\t"
 1205|      5|      "movq %%r15, 120(%[z])\n\t"
 1206|      5|      "movl $0, %%eax\n\t"
 1207|      5|      "adox %%rax, %%rcx\n\t"
 1208|      5|      "adcx %%rax, %%rcx\n\t"
 1209|      5|      "movq %%rcx, %%r8\n\t"
 1210|      5|      "movq %%r8, 128(%[z])\n\t"
 1211|       |
 1212|      5|      "movq $0, 136(%[z])\n\t"
 1213|      5|      "xorl %%eax, %%eax\n\t"  // double the cross products and add the squares
 1214|      5|      "movq 0(%[x]), %%rdx\n\t"
 1215|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1216|      5|      "movq %%rax, 0(%[z])\n\t"
 1217|      5|      "movq 8(%[z]), %%r8\n\t"
 1218|      5|      "adcx %%r8, %%r8\n\t"
 1219|      5|      "adox %%rcx, %%r8\n\t"
 1220|      5|      "movq %%r8, 8(%[z])\n\t"
 1221|      5|      "movq 8(%[x]), %%rdx\n\t"
 1222|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1223|      5|      "movq 16(%[z]), %%r8\n\t"
 1224|      5|      "adcx %%r8, %%r8\n\t"
 1225|      5|      "adox %%rax, %%r8\n\t"
 1226|      5|      "movq %%r8, 16(%[z])\n\t"
 1227|      5|      "movq 24(%[z]), %%r8\n\t"
 1228|      5|      "adcx %%r8, %%r8\n\t"
 1229|      5|      "adox %%rcx, %%r8\n\t"
 1230|      5|      "movq %%r8, 24(%[z])\n\t"
 1231|      5|      "movq 16(%[x]), %%rdx\n\t"
 1232|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1233|      5|      "movq 32(%[z]), %%r8\n\t"
 1234|      5|      "adcx %%r8, %%r8\n\t"
 1235|      5|      "adox %%rax, %%r8\n\t"
 1236|      5|      "movq %%r8, 32(%[z])\n\t"
 1237|      5|      "movq 40(%[z]), %%r8\n\t"
 1238|      5|      "adcx %%r8, %%r8\n\t"
 1239|      5|      "adox %%rcx, %%r8\n\t"
 1240|      5|      "movq %%r8, 40(%[z])\n\t"
 1241|      5|      "movq 24(%[x]), %%rdx\n\t"
 1242|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1243|      5|      "movq 48(%[z]), %%r8\n\t"
 1244|      5|      "adcx %%r8, %%r8\n\t"
 1245|      5|      "adox %%rax, %%r8\n\t"
 1246|      5|      "movq %%r8, 48(%[z])\n\t"
 1247|      5|      "movq 56(%[z]), %%r8\n\t"
 1248|      5|      "adcx %%r8, %%r8\n\t"
 1249|      5|      "adox %%rcx, %%r8\n\t"
 1250|      5|      "movq %%r8, 56(%[z])\n\t"
 1251|      5|      "movq 32(%[x]), %%rdx\n\t"
 1252|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1253|      5|      "movq 64(%[z]), %%r8\n\t"
 1254|      5|      "adcx %%r8, %%r8\n\t"
 1255|      5|      "adox %%rax, %%r8\n\t"
 1256|      5|      "movq %%r8, 64(%[z])\n\t"
 1257|      5|      "movq 72(%[z]), %%r8\n\t"
 1258|      5|      "adcx %%r8, %%r8\n\t"
 1259|      5|      "adox %%rcx, %%r8\n\t"
 1260|      5|      "movq %%r8, 72(%[z])\n\t"
 1261|      5|      "movq 40(%[x]), %%rdx\n\t"
 1262|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1263|      5|      "movq 80(%[z]), %%r8\n\t"
 1264|      5|      "adcx %%r8, %%r8\n\t"
 1265|      5|      "adox %%rax, %%r8\n\t"
 1266|      5|      "movq %%r8, 80(%[z])\n\t"
 1267|      5|      "movq 88(%[z]), %%r8\n\t"
 1268|      5|      "adcx %%r8, %%r8\n\t"
 1269|      5|      "adox %%rcx, %%r8\n\t"
 1270|      5|      "movq %%r8, 88(%[z])\n\t"
 1271|      5|      "movq 48(%[x]), %%rdx\n\t"
 1272|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1273|      5|      "movq 96(%[z]), %%r8\n\t"
 1274|      5|      "adcx %%r8, %%r8\n\t"
 1275|      5|      "adox %%rax, %%r8\n\t"
 1276|      5|      "movq %%r8, 96(%[z])\n\t"
 1277|      5|      "movq 104(%[z]), %%r8\n\t"
 1278|      5|      "adcx %%r8, %%r8\n\t"
 1279|      5|      "adox %%rcx, %%r8\n\t"
 1280|      5|      "movq %%r8, 104(%[z])\n\t"
 1281|      5|      "movq 56(%[x]), %%rdx\n\t"
 1282|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1283|      5|      "movq 112(%[z]), %%r8\n\t"
 1284|      5|      "adcx %%r8, %%r8\n\t"
 1285|      5|      "adox %%rax, %%r8\n\t"
 1286|      5|      "movq %%r8, 112(%[z])\n\t"
 1287|      5|      "movq 120(%[z]), %%r8\n\t"
 1288|      5|      "adcx %%r8, %%r8\n\t"
 1289|      5|      "adox %%rcx, %%r8\n\t"
 1290|      5|      "movq %%r8, 120(%[z])\n\t"
 1291|      5|      "movq 64(%[x]), %%rdx\n\t"
 1292|      5|      "mulx %%rdx, %%rax, %%rcx\n\t"
 1293|      5|      "movq 128(%[z]), %%r8\n\t"
 1294|      5|      "adcx %%r8, %%r8\n\t"
 1295|      5|      "adox %%rax, %%r8\n\t"
 1296|      5|      "movq %%r8, 128(%[z])\n\t"
 1297|      5|      "movq 136(%[z]), %%r8\n\t"
 1298|      5|      "adcx %%r8, %%r8\n\t"
 1299|      5|      "adox %%rcx, %%r8\n\t"
 1300|      5|      "movq %%r8, 136(%[z])\n\t"
 1301|      5|      :
 1302|      5|      : [z] "r"(z), [x] "r"(x)
 1303|      5|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "cc", "memory");
 1304|       |   // clang-format on
 1305|      5|}
_ZN5Botan16bigint_mulx_mul9EPmPKmS2_:
 1307|      5|void bigint_mulx_mul9(word z[18], const word x[9], const word y[9]) {
 1308|      5|   copy_mem(z + 9, y, 9);
 1309|       |   // clang-format off
 1310|      5|   asm(
 1311|      5|      "xorl %%r8d, %%r8d\n\t"
 1312|      5|      "xorl %%r9d, %%r9d\n\t"
 1313|      5|      "xorl %%r10d, %%r10d\n\t"
 1314|      5|      "xorl %%r11d, %%r11d\n\t"
 1315|      5|      "xorl %%r12d, %%r12d\n\t"
 1316|      5|      "xorl %%r13d, %%r13d\n\t"
 1317|      5|      "xorl %%r14d, %%r14d\n\t"
 1318|      5|      "xorl %%r15d, %%r15d\n\t"
 1319|      5|      "xorl %%ebx, %%ebx\n\t"
 1320|       |
 1321|      5|      "movq 72(%[z]), %%rdx\n\t"  // row 0: x * y[0]
 1322|      5|      "xorl %%eax, %%eax\n\t"
 1323|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1324|      5|      "adcx %%rax, %%r8\n\t"
 1325|      5|      "movq %%r8, 0(%[z])\n\t"
 1326|      5|      "mulx 8(%[x]), %%rax, %%r8\n\t"
 1327|      5|      "adox %%rcx, %%rax\n\t"
 1328|      5|      "adcx %%rax, %%r9\n\t"
 1329|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1330|      5|      "adox %%r8, %%rax\n\t"
 1331|      5|      "adcx %%rax, %%r10\n\t"
 1332|      5|      "mulx 24(%[x]), %%rax, %%r8\n\t"
 1333|      5|      "adox %%rcx, %%rax\n\t"
 1334|      5|      "adcx %%rax, %%r11\n\t"
 1335|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1336|      5|      "adox %%r8, %%rax\n\t"
 1337|      5|      "adcx %%rax, %%r12\n\t"
 1338|      5|      "mulx 40(%[x]), %%rax, %%r8\n\t"
 1339|      5|      "adox %%rcx, %%rax\n\t"
 1340|      5|      "adcx %%rax, %%r13\n\t"
 1341|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1342|      5|      "adox %%r8, %%rax\n\t"
 1343|      5|      "adcx %%rax, %%r14\n\t"
 1344|      5|      "mulx 56(%[x]), %%rax, %%r8\n\t"
 1345|      5|      "adox %%rcx, %%rax\n\t"
 1346|      5|      "adcx %%rax, %%r15\n\t"
 1347|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1348|      5|      "adox %%r8, %%rax\n\t"
 1349|      5|      "adcx %%rax, %%rbx\n\t"
 1350|      5|      "movl $0, %%eax\n\t"
 1351|      5|      "adox %%rax, %%rcx\n\t"
 1352|      5|      "adcx %%rax, %%rcx\n\t"
 1353|      5|      "movq %%rcx, %%r8\n\t"
 1354|       |
 1355|      5|      "movq 80(%[z]), %%rdx\n\t"  // row 1: x * y[1]
 1356|      5|      "xorl %%eax, %%eax\n\t"
 1357|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1358|      5|      "adcx %%rax, %%r9\n\t"
 1359|      5|      "movq %%r9, 8(%[z])\n\t"
 1360|      5|      "mulx 8(%[x]), %%rax, %%r9\n\t"
 1361|      5|      "adox %%rcx, %%rax\n\t"
 1362|      5|      "adcx %%rax, %%r10\n\t"
 1363|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1364|      5|      "adox %%r9, %%rax\n\t"
 1365|      5|      "adcx %%rax, %%r11\n\t"
 1366|      5|      "mulx 24(%[x]), %%rax, %%r9\n\t"
 1367|      5|      "adox %%rcx, %%rax\n\t"
 1368|      5|      "adcx %%rax, %%r12\n\t"
 1369|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1370|      5|      "adox %%r9, %%rax\n\t"
 1371|      5|      "adcx %%rax, %%r13\n\t"
 1372|      5|      "mulx 40(%[x]), %%rax, %%r9\n\t"
 1373|      5|      "adox %%rcx, %%rax\n\t"
 1374|      5|      "adcx %%rax, %%r14\n\t"
 1375|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1376|      5|      "adox %%r9, %%rax\n\t"
 1377|      5|      "adcx %%rax, %%r15\n\t"
 1378|      5|      "mulx 56(%[x]), %%rax, %%r9\n\t"
 1379|      5|      "adox %%rcx, %%rax\n\t"
 1380|      5|      "adcx %%rax, %%rbx\n\t"
 1381|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1382|      5|      "adox %%r9, %%rax\n\t"
 1383|      5|      "adcx %%rax, %%r8\n\t"
 1384|      5|      "movl $0, %%eax\n\t"
 1385|      5|      "adox %%rax, %%rcx\n\t"
 1386|      5|      "adcx %%rax, %%rcx\n\t"
 1387|      5|      "movq %%rcx, %%r9\n\t"
 1388|       |
 1389|      5|      "movq 88(%[z]), %%rdx\n\t"  // row 2: x * y[2]
 1390|      5|      "xorl %%eax, %%eax\n\t"
 1391|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1392|      5|      "adcx %%rax, %%r10\n\t"
 1393|      5|      "movq %%r10, 16(%[z])\n\t"
 1394|      5|      "mulx 8(%[x]), %%rax, %%r10\n\t"
 1395|      5|      "adox %%rcx, %%rax\n\t"
 1396|      5|      "adcx %%rax, %%r11\n\t"
 1397|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1398|      5|      "adox %%r10, %%rax\n\t"
 1399|      5|      "adcx %%rax, %%r12\n\t"
 1400|      5|      "mulx 24(%[x]), %%rax, %%r10\n\t"
 1401|      5|      "adox %%rcx, %%rax\n\t"
 1402|      5|      "adcx %%rax, %%r13\n\t"
 1403|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1404|      5|      "adox %%r10, %%rax\n\t"
 1405|      5|      "adcx %%rax, %%r14\n\t"
 1406|      5|      "mulx 40(%[x]), %%rax, %%r10\n\t"
 1407|      5|      "adox %%rcx, %%rax\n\t"
 1408|      5|      "adcx %%rax, %%r15\n\t"
 1409|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1410|      5|      "adox %%r10, %%rax\n\t"
 1411|      5|      "adcx %%rax, %%rbx\n\t"
 1412|      5|      "mulx 56(%[x]), %%rax, %%r10\n\t"
 1413|      5|      "adox %%rcx, %%rax\n\t"
 1414|      5|      "adcx %%rax, %%r8\n\t"
 1415|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1416|      5|      "adox %%r10, %%rax\n\t"
 1417|      5|      "adcx %%rax, %%r9\n\t"
 1418|      5|      "movl $0, %%eax\n\t"
 1419|      5|      "adox %%rax, %%rcx\n\t"
 1420|      5|      "adcx %%rax, %%rcx\n\t"
 1421|      5|      "movq %%rcx, %%r10\n\t"
 1422|       |
 1423|      5|      "movq 96(%[z]), %%rdx\n\t"  // row 3: x * y[3]
 1424|      5|      "xorl %%eax, %%eax\n\t"
 1425|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1426|      5|      "adcx %%rax, %%r11\n\t"
 1427|      5|      "movq %%r11, 24(%[z])\n\t"
 1428|      5|      "mulx 8(%[x]), %%rax, %%r11\n\t"
 1429|      5|      "adox %%rcx, %%rax\n\t"
 1430|      5|      "adcx %%rax, %%r12\n\t"
 1431|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1432|      5|      "adox %%r11, %%rax\n\t"
 1433|      5|      "adcx %%rax, %%r13\n\t"
 1434|      5|      "mulx 24(%[x]), %%rax, %%r11\n\t"
 1435|      5|      "adox %%rcx, %%rax\n\t"
 1436|      5|      "adcx %%rax, %%r14\n\t"
 1437|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1438|      5|      "adox %%r11, %%rax\n\t"
 1439|      5|      "adcx %%rax, %%r15\n\t"
 1440|      5|      "mulx 40(%[x]), %%rax, %%r11\n\t"
 1441|      5|      "adox %%rcx, %%rax\n\t"
 1442|      5|      "adcx %%rax, %%rbx\n\t"
 1443|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1444|      5|      "adox %%r11, %%rax\n\t"
 1445|      5|      "adcx %%rax, %%r8\n\t"
 1446|      5|      "mulx 56(%[x]), %%rax, %%r11\n\t"
 1447|      5|      "adox %%rcx, %%rax\n\t"
 1448|      5|      "adcx %%rax, %%r9\n\t"
 1449|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1450|      5|      "adox %%r11, %%rax\n\t"
 1451|      5|      "adcx %%rax, %%r10\n\t"
 1452|      5|      "movl $0, %%eax\n\t"
 1453|      5|      "adox %%rax, %%rcx\n\t"
 1454|      5|      "adcx %%rax, %%rcx\n\t"
 1455|      5|      "movq %%rcx, %%r11\n\t"
 1456|       |
 1457|      5|      "movq 104(%[z]), %%rdx\n\t"  // row 4: x * y[4]
 1458|      5|      "xorl %%eax, %%eax\n\t"
 1459|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1460|      5|      "adcx %%rax, %%r12\n\t"
 1461|      5|      "movq %%r12, 32(%[z])\n\t"
 1462|      5|      "mulx 8(%[x]), %%rax, %%r12\n\t"
 1463|      5|      "adox %%rcx, %%rax\n\t"
 1464|      5|      "adcx %%rax, %%r13\n\t"
 1465|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1466|      5|      "adox %%r12, %%rax\n\t"
 1467|      5|      "adcx %%rax, %%r14\n\t"
 1468|      5|      "mulx 24(%[x]), %%rax, %%r12\n\t"
 1469|      5|      "adox %%rcx, %%rax\n\t"
 1470|      5|      "adcx %%rax, %%r15\n\t"
 1471|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1472|      5|      "adox %%r12, %%rax\n\t"
 1473|      5|      "adcx %%rax, %%rbx\n\t"
 1474|      5|      "mulx 40(%[x]), %%rax, %%r12\n\t"
 1475|      5|      "adox %%rcx, %%rax\n\t"
 1476|      5|      "adcx %%rax, %%r8\n\t"
 1477|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1478|      5|      "adox %%r12, %%rax\n\t"
 1479|      5|      "adcx %%rax, %%r9\n\t"
 1480|      5|      "mulx 56(%[x]), %%rax, %%r12\n\t"
 1481|      5|      "adox %%rcx, %%rax\n\t"
 1482|      5|      "adcx %%rax, %%r10\n\t"
 1483|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1484|      5|      "adox %%r12, %%rax\n\t"
 1485|      5|      "adcx %%rax, %%r11\n\t"
 1486|      5|      "movl $0, %%eax\n\t"
 1487|      5|      "adox %%rax, %%rcx\n\t"
 1488|      5|      "adcx %%rax, %%rcx\n\t"
 1489|      5|      "movq %%rcx, %%r12\n\t"
 1490|       |
 1491|      5|      "movq 112(%[z]), %%rdx\n\t"  // row 5: x * y[5]
 1492|      5|      "xorl %%eax, %%eax\n\t"
 1493|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1494|      5|      "adcx %%rax, %%r13\n\t"
 1495|      5|      "movq %%r13, 40(%[z])\n\t"
 1496|      5|      "mulx 8(%[x]), %%rax, %%r13\n\t"
 1497|      5|      "adox %%rcx, %%rax\n\t"
 1498|      5|      "adcx %%rax, %%r14\n\t"
 1499|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1500|      5|      "adox %%r13, %%rax\n\t"
 1501|      5|      "adcx %%rax, %%r15\n\t"
 1502|      5|      "mulx 24(%[x]), %%rax, %%r13\n\t"
 1503|      5|      "adox %%rcx, %%rax\n\t"
 1504|      5|      "adcx %%rax, %%rbx\n\t"
 1505|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1506|      5|      "adox %%r13, %%rax\n\t"
 1507|      5|      "adcx %%rax, %%r8\n\t"
 1508|      5|      "mulx 40(%[x]), %%rax, %%r13\n\t"
 1509|      5|      "adox %%rcx, %%rax\n\t"
 1510|      5|      "adcx %%rax, %%r9\n\t"
 1511|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1512|      5|      "adox %%r13, %%rax\n\t"
 1513|      5|      "adcx %%rax, %%r10\n\t"
 1514|      5|      "mulx 56(%[x]), %%rax, %%r13\n\t"
 1515|      5|      "adox %%rcx, %%rax\n\t"
 1516|      5|      "adcx %%rax, %%r11\n\t"
 1517|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1518|      5|      "adox %%r13, %%rax\n\t"
 1519|      5|      "adcx %%rax, %%r12\n\t"
 1520|      5|      "movl $0, %%eax\n\t"
 1521|      5|      "adox %%rax, %%rcx\n\t"
 1522|      5|      "adcx %%rax, %%rcx\n\t"
 1523|      5|      "movq %%rcx, %%r13\n\t"
 1524|       |
 1525|      5|      "movq 120(%[z]), %%rdx\n\t"  // row 6: x * y[6]
 1526|      5|      "xorl %%eax, %%eax\n\t"
 1527|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1528|      5|      "adcx %%rax, %%r14\n\t"
 1529|      5|      "movq %%r14, 48(%[z])\n\t"
 1530|      5|      "mulx 8(%[x]), %%rax, %%r14\n\t"
 1531|      5|      "adox %%rcx, %%rax\n\t"
 1532|      5|      "adcx %%rax, %%r15\n\t"
 1533|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1534|      5|      "adox %%r14, %%rax\n\t"
 1535|      5|      "adcx %%rax, %%rbx\n\t"
 1536|      5|      "mulx 24(%[x]), %%rax, %%r14\n\t"
 1537|      5|      "adox %%rcx, %%rax\n\t"
 1538|      5|      "adcx %%rax, %%r8\n\t"
 1539|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1540|      5|      "adox %%r14, %%rax\n\t"
 1541|      5|      "adcx %%rax, %%r9\n\t"
 1542|      5|      "mulx 40(%[x]), %%rax, %%r14\n\t"
 1543|      5|      "adox %%rcx, %%rax\n\t"
 1544|      5|      "adcx %%rax, %%r10\n\t"
 1545|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1546|      5|      "adox %%r14, %%rax\n\t"
 1547|      5|      "adcx %%rax, %%r11\n\t"
 1548|      5|      "mulx 56(%[x]), %%rax, %%r14\n\t"
 1549|      5|      "adox %%rcx, %%rax\n\t"
 1550|      5|      "adcx %%rax, %%r12\n\t"
 1551|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1552|      5|      "adox %%r14, %%rax\n\t"
 1553|      5|      "adcx %%rax, %%r13\n\t"
 1554|      5|      "movl $0, %%eax\n\t"
 1555|      5|      "adox %%rax, %%rcx\n\t"
 1556|      5|      "adcx %%rax, %%rcx\n\t"
 1557|      5|      "movq %%rcx, %%r14\n\t"
 1558|       |
 1559|      5|      "movq 128(%[z]), %%rdx\n\t"  // row 7: x * y[7]
 1560|      5|      "xorl %%eax, %%eax\n\t"
 1561|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1562|      5|      "adcx %%rax, %%r15\n\t"
 1563|      5|      "movq %%r15, 56(%[z])\n\t"
 1564|      5|      "mulx 8(%[x]), %%rax, %%r15\n\t"
 1565|      5|      "adox %%rcx, %%rax\n\t"
 1566|      5|      "adcx %%rax, %%rbx\n\t"
 1567|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1568|      5|      "adox %%r15, %%rax\n\t"
 1569|      5|      "adcx %%rax, %%r8\n\t"
 1570|      5|      "mulx 24(%[x]), %%rax, %%r15\n\t"
 1571|      5|      "adox %%rcx, %%rax\n\t"
 1572|      5|      "adcx %%rax, %%r9\n\t"
 1573|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1574|      5|      "adox %%r15, %%rax\n\t"
 1575|      5|      "adcx %%rax, %%r10\n\t"
 1576|      5|      "mulx 40(%[x]), %%rax, %%r15\n\t"
 1577|      5|      "adox %%rcx, %%rax\n\t"
 1578|      5|      "adcx %%rax, %%r11\n\t"
 1579|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1580|      5|      "adox %%r15, %%rax\n\t"
 1581|      5|      "adcx %%rax, %%r12\n\t"
 1582|      5|      "mulx 56(%[x]), %%rax, %%r15\n\t"
 1583|      5|      "adox %%rcx, %%rax\n\t"
 1584|      5|      "adcx %%rax, %%r13\n\t"
 1585|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1586|      5|      "adox %%r15, %%rax\n\t"
 1587|      5|      "adcx %%rax, %%r14\n\t"
 1588|      5|      "movl $0, %%eax\n\t"
 1589|      5|      "adox %%rax, %%rcx\n\t"
 1590|      5|      "adcx %%rax, %%rcx\n\t"
 1591|      5|      "movq %%rcx, %%r15\n\t"
 1592|       |
 1593|      5|      "movq 136(%[z]), %%rdx\n\t"  // row 8: x * y[8]
 1594|      5|      "xorl %%eax, %%eax\n\t"
 1595|      5|      "mulx 0(%[x]), %%rax, %%rcx\n\t"
 1596|      5|      "adcx %%rax, %%rbx\n\t"
 1597|      5|      "movq %%rbx, 64(%[z])\n\t"
 1598|      5|      "mulx 8(%[x]), %%rax, %%rbx\n\t"
 1599|      5|      "adox %%rcx, %%rax\n\t"
 1600|      5|      "adcx %%rax, %%r8\n\t"
 1601|      5|      "mulx 16(%[x]), %%rax, %%rcx\n\t"
 1602|      5|      "adox %%rbx, %%rax\n\t"
 1603|      5|      "adcx %%rax, %%r9\n\t"
 1604|      5|      "mulx 24(%[x]), %%rax, %%rbx\n\t"
 1605|      5|      "adox %%rcx, %%rax\n\t"
 1606|      5|      "adcx %%rax, %%r10\n\t"
 1607|      5|      "mulx 32(%[x]), %%rax, %%rcx\n\t"
 1608|      5|      "adox %%rbx, %%rax\n\t"
 1609|      5|      "adcx %%rax, %%r11\n\t"
 1610|      5|      "mulx 40(%[x]), %%rax, %%rbx\n\t"
 1611|      5|      "adox %%rcx, %%rax\n\t"
 1612|      5|      "adcx %%rax, %%r12\n\t"
 1613|      5|      "mulx 48(%[x]), %%rax, %%rcx\n\t"
 1614|      5|      "adox %%rbx, %%rax\n\t"
 1615|      5|      "adcx %%rax, %%r13\n\t"
 1616|      5|      "mulx 56(%[x]), %%rax, %%rbx\n\t"
 1617|      5|      "adox %%rcx, %%rax\n\t"
 1618|      5|      "adcx %%rax, %%r14\n\t"
 1619|      5|      "mulx 64(%[x]), %%rax, %%rcx\n\t"
 1620|      5|      "adox %%rbx, %%rax\n\t"
 1621|      5|      "adcx %%rax, %%r15\n\t"
 1622|      5|      "movl $0, %%eax\n\t"
 1623|      5|      "adox %%rax, %%rcx\n\t"
 1624|      5|      "adcx %%rax, %%rcx\n\t"
 1625|      5|      "movq %%rcx, %%rbx\n\t"
 1626|       |
 1627|      5|      "movq %%r8, 72(%[z])\n\t"
 1628|      5|      "movq %%r9, 80(%[z])\n\t"
 1629|      5|      "movq %%r10, 88(%[z])\n\t"
 1630|      5|      "movq %%r11, 96(%[z])\n\t"
 1631|      5|      "movq %%r12, 104(%[z])\n\t"
 1632|      5|      "movq %%r13, 112(%[z])\n\t"
 1633|      5|      "movq %%r14, 120(%[z])\n\t"
 1634|      5|      "movq %%r15, 128(%[z])\n\t"
 1635|      5|      "movq %%rbx, 136(%[z])\n\t"
 1636|      5|      :
 1637|      5|      : [z] "r"(z), [x] "r"(x)
 1638|      5|      : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "rbx", "cc", "memory");
 1639|       |   // clang-format on
 1640|      5|}

_ZN5Botan6squareERKNS_6BigIntE:
  184|    296|BigInt square(const BigInt& x) {
  185|    296|   BigInt z = x;
  186|    296|   secure_vector<word> ws;
  187|    296|   z.square(ws);
  188|    296|   return z;
  189|    296|}

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

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

_ZN5Botan19secure_scrub_memoryEPvm:
   24|  1.64k|void secure_scrub_memory(void* ptr, size_t n) {
   25|  1.64k|   return secure_zeroize_buffer(ptr, n);
   26|  1.64k|}
_ZN5Botan21secure_zeroize_bufferEPvm:
   28|  1.64k|void secure_zeroize_buffer(void* ptr, size_t n) {
   29|  1.64k|   if(n == 0) {
  ------------------
  |  Branch (29:7): [True: 0, False: 1.64k]
  ------------------
   30|      0|      return;
   31|      0|   }
   32|       |
   33|       |#if defined(BOTAN_TARGET_OS_HAS_RTLSECUREZEROMEMORY)
   34|       |   ::RtlSecureZeroMemory(ptr, n);
   35|       |
   36|       |#elif defined(BOTAN_TARGET_OS_HAS_EXPLICIT_BZERO)
   37|  1.64k|   ::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|  1.64k|}

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

