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

_ZN5Botan10ct_is_zeroIjEET_S1_:
   35|  85.2k|{
   36|  85.2k|   return expand_top_bit<T>(~x & (x - 1));
   37|  85.2k|}
_ZN5Botan14expand_top_bitIjEET_S1_:
   25|  85.2k|{
   26|  85.2k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  85.2k|}
_ZN5Botan8high_bitIjEEmT_:
   60|  17.0k|{
   61|  17.0k|   size_t hb = 0;
   62|       |
   63|   102k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 85.2k, False: 17.0k]
  ------------------
   64|  85.2k|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|  85.2k|      hb += z;
   66|  85.2k|      n >>= z;
   67|  85.2k|   }
   68|       |
   69|  17.0k|   hb += n;
   70|       |
   71|  17.0k|   return hb;
   72|  17.0k|}
_ZN5Botan14expand_top_bitIhEET_S1_:
   25|   657k|{
   26|   657k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|   657k|}
_ZN5Botan17significant_bytesImEEmT_:
   82|  13.1k|{
   83|  13.1k|   size_t b = 0;
   84|       |
   85|  52.6k|   for(size_t s = 8 * sizeof(n) / 2; s >= 8; s /= 2) {
  ------------------
  |  Branch (85:38): [True: 39.5k, False: 13.1k]
  ------------------
   86|  39.5k|      const size_t z = s * (~ct_is_zero(n >> s) & 1);
   87|  39.5k|      b += z / 8;
   88|  39.5k|      n >>= z;
   89|  39.5k|   }
   90|       |
   91|  13.1k|   b += (n != 0);
   92|       |
   93|  13.1k|   return b;
   94|  13.1k|}
_ZN5Botan10ct_is_zeroImEET_S1_:
   35|  6.28M|{
   36|  6.28M|   return expand_top_bit<T>(~x & (x - 1));
   37|  6.28M|}
_ZN5Botan14expand_top_bitImEET_S1_:
   25|  6.48M|{
   26|  6.48M|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  6.48M|}
_ZN5Botan10ct_is_zeroIhEET_S1_:
   35|   137k|{
   36|   137k|   return expand_top_bit<T>(~x & (x - 1));
   37|   137k|}
_ZN5Botan6chooseIhEET_S1_S1_S1_:
  180|   657k|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   657k|   return (b ^ (mask & (a ^ b)));
  183|   657k|}
_ZN5Botan6chooseIjEET_S1_S1_S1_:
  180|  10.9M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|  10.9M|   return (b ^ (mask & (a ^ b)));
  183|  10.9M|}
_ZN5Botan8majorityIjEET_S1_S1_S1_:
  186|  5.23M|inline constexpr T majority(T a, T b, T c) {
  187|       |   /*
  188|       |   Considering each bit of a, b, c individually
  189|       |
  190|       |   If a xor b is set, then c is the deciding vote.
  191|       |
  192|       |   If a xor b is not set then either a and b are both set or both unset.
  193|       |   In either case the value of c doesn't matter, and examining b (or a)
  194|       |   allows us to determine which case we are in.
  195|       |   */
  196|  5.23M|   return choose(a ^ b, c, b);
  197|  5.23M|}
_ZN5Botan6chooseImEET_S1_S1_S1_:
  180|   274M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   274M|   return (b ^ (mask & (a ^ b)));
  183|   274M|}
_ZN5Botan8majorityImEET_S1_S1_S1_:
  186|  28.8k|inline constexpr T majority(T a, T b, T c) {
  187|       |   /*
  188|       |   Considering each bit of a, b, c individually
  189|       |
  190|       |   If a xor b is set, then c is the deciding vote.
  191|       |
  192|       |   If a xor b is not set then either a and b are both set or both unset.
  193|       |   In either case the value of c doesn't matter, and examining b (or a)
  194|       |   allows us to determine which case we are in.
  195|       |   */
  196|  28.8k|   return choose(a ^ b, c, b);
  197|  28.8k|}
_ZN5Botan8high_bitImEEmT_:
   60|  18.0k|{
   61|  18.0k|   size_t hb = 0;
   62|       |
   63|   126k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 108k, False: 18.0k]
  ------------------
   64|   108k|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|   108k|      hb += z;
   66|   108k|      n >>= z;
   67|   108k|   }
   68|       |
   69|  18.0k|   hb += n;
   70|       |
   71|  18.0k|   return hb;
   72|  18.0k|}

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

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

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

_ZN5Botan2CT4MaskIhE3setEv:
   99|  2.93k|      static Mask<T> set() { return Mask<T>(static_cast<T>(~0)); }
_ZN5Botan2CT4MaskIhEC2Eh:
  280|   797k|      Mask(T m) : m_mask(m) {}
_ZN5Botan2CT4MaskIhE15is_within_rangeEhhh:
  150|   125k|      static Mask<T> is_within_range(T v, T l, T u) {
  151|       |         //return Mask<T>::is_gte(v, l) & Mask<T>::is_lte(v, u);
  152|       |
  153|   125k|         const T v_lt_l = v ^ ((v ^ l) | ((v - l) ^ v));
  154|   125k|         const T v_gt_u = u ^ ((u ^ v) | ((u - v) ^ u));
  155|   125k|         const T either = v_lt_l | v_gt_u;
  156|   125k|         return ~Mask<T>(expand_top_bit(either));
  157|   125k|      }
_ZNK5Botan2CT4MaskIhEcoEv:
  213|   137k|      Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskIhE5valueEv:
  277|   797k|      T value() const { return m_mask; }
_ZN5Botan2CT4MaskIhE9is_any_ofEhSt16initializer_listIhE:
  159|  41.9k|      static Mask<T> is_any_of(T v, std::initializer_list<T> accepted) {
  160|  41.9k|         T accept = 0;
  161|       |
  162|   167k|         for(auto a : accepted) {
  ------------------
  |  Branch (162:21): [True: 167k, False: 41.9k]
  ------------------
  163|   167k|            const T diff = a ^ v;
  164|   167k|            const T eq_zero = ~diff & (diff - 1);
  165|   167k|            accept |= eq_zero;
  166|   167k|         }
  167|       |
  168|  41.9k|         return Mask<T>(expand_top_bit(accept));
  169|  41.9k|      }
_ZNK5Botan2CT4MaskIhE7as_boolEv:
  272|  2.93k|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskIhE16unpoisoned_valueEv:
  263|  2.93k|      T unpoisoned_value() const {
  264|  2.93k|         T r = value();
  265|  2.93k|         CT::unpoison(r);
  266|  2.93k|         return r;
  267|  2.93k|      }
_ZN5Botan2CT8unpoisonIhEEvRT_:
   64|  2.93k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  2.93k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  2.93k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  2.93k|#endif
   70|  2.93k|}
_ZN5Botan2CT4MaskIhE5is_ltEhh:
  133|   352k|      static Mask<T> is_lt(T x, T y) { return Mask<T>(expand_top_bit<T>(x ^ ((x ^ y) | ((x - y) ^ x)))); }
_ZN5Botan2CT4MaskIhE8is_equalEhh:
  128|   125k|      static Mask<T> is_equal(T x, T y) { return Mask<T>::is_zero(static_cast<T>(x ^ y)); }
_ZN5Botan2CT4MaskIhE7is_zeroEh:
  123|   137k|      static Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(x)); }
_ZNK5Botan2CT4MaskIhE6selectEhh:
  228|   657k|      T select(T x, T y) const { return choose(value(), x, y); }
_ZN5Botan2CT4MaskImE8is_equalEmm:
  128|   200k|      static Mask<T> is_equal(T x, T y) { return Mask<T>::is_zero(static_cast<T>(x ^ y)); }
_ZN5Botan2CT4MaskImE5is_ltEmm:
  133|   200k|      static Mask<T> is_lt(T x, T y) { return Mask<T>(expand_top_bit<T>(x ^ ((x ^ y) | ((x - y) ^ x)))); }
_ZN5Botan2CT4MaskImEC2Em:
  280|  9.30M|      Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskImE11select_maskES2_S2_:
  239|  5.24k|      Mask<T> select_mask(Mask<T> x, Mask<T> y) const { return Mask<T>(select(x.value(), y.value())); }
_ZNK5Botan2CT4MaskImE5valueEv:
  277|   279M|      T value() const { return m_mask; }
_ZN5Botan2CT4MaskImEoRES2_:
  190|  2.58k|      Mask<T>& operator|=(Mask<T> o) {
  191|  2.58k|         m_mask |= o.value();
  192|  2.58k|         return (*this);
  193|  2.58k|      }
_ZNK5Botan2CT4MaskImE13if_set_returnEm:
  218|   183k|      T if_set_return(T x) const { return m_mask & x; }
_ZN5Botan2CT4MaskImE6expandEm:
  109|  4.43M|      static Mask<T> expand(T v) { return ~Mask<T>::is_zero(v); }
_ZNK5Botan2CT4MaskImEcoEv:
  213|  4.44M|      Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskImE6selectEmm:
  228|   274M|      T select(T x, T y) const { return choose(value(), x, y); }
_ZNK5Botan2CT4MaskImE8select_nEPmPKmS5_m:
  245|   474k|      void select_n(T output[], const T x[], const T y[], size_t len) const {
  246|  5.34M|         for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (246:28): [True: 4.87M, False: 474k]
  ------------------
  247|  4.87M|            output[i] = this->select(x[i], y[i]);
  248|  4.87M|         }
  249|   474k|      }
_ZN5Botan2CT4MaskImE7is_zeroEm:
  123|  4.65M|      static Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(x)); }
_ZN5Botan2CT8unpoisonImEEvRT_:
   64|  62.1k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  62.1k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  62.1k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  62.1k|#endif
   70|  62.1k|}
_ZNK5Botan2CT4MaskImE7as_boolEv:
  272|  2.73k|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskImE16unpoisoned_valueEv:
  263|  2.73k|      T unpoisoned_value() const {
  264|  2.73k|         T r = value();
  265|  2.73k|         CT::unpoison(r);
  266|  2.73k|         return r;
  267|  2.73k|      }
_ZN5Botan2CT8unpoisonIKmEEvRT_:
   64|  18.0k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  18.0k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  18.0k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  18.0k|#endif
   70|  18.0k|}
_ZN5Botan2CT4MaskIhE6expandEh:
  109|  11.6k|      static Mask<T> expand(T v) { return ~Mask<T>::is_zero(v); }
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES3_PS3_PKS3_S7_m:
  292|  15.7k|inline Mask<T> conditional_copy_mem(T cnd, T* to, const T* from0, const T* from1, size_t elems) {
  293|  15.7k|   const auto mask = CT::Mask<T>::expand(cnd);
  294|  15.7k|   return CT::conditional_copy_mem(mask, to, from0, from1, elems);
  295|  15.7k|}
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES4_PS3_PKS3_S7_m:
  286|  15.7k|inline Mask<T> conditional_copy_mem(Mask<T> mask, T* to, const T* from0, const T* from1, size_t elems) {
  287|  15.7k|   mask.select_n(to, from0, from1, elems);
  288|  15.7k|   return mask;
  289|  15.7k|}
_ZN5Botan2CT20conditional_swap_ptrIPKmEEvbRT_S5_:
  315|  8.74k|inline void conditional_swap_ptr(bool cnd, T& x, T& y) {
  316|  8.74k|   uintptr_t xp = reinterpret_cast<uintptr_t>(x);
  317|  8.74k|   uintptr_t yp = reinterpret_cast<uintptr_t>(y);
  318|       |
  319|  8.74k|   conditional_swap<uintptr_t>(cnd, xp, yp);
  320|       |
  321|  8.74k|   x = reinterpret_cast<T>(xp);
  322|  8.74k|   y = reinterpret_cast<T>(yp);
  323|  8.74k|}
_ZN5Botan2CT16conditional_swapImEEvbRT_S3_:
  305|  17.4k|inline void conditional_swap(bool cnd, T& x, T& y) {
  306|  17.4k|   const auto swap = CT::Mask<T>::expand(cnd);
  307|       |
  308|  17.4k|   T t0 = swap.select(y, x);
  309|  17.4k|   T t1 = swap.select(x, y);
  310|  17.4k|   x = t0;
  311|  17.4k|   y = t1;
  312|  17.4k|}
_ZN5Botan2CTeoENS0_4MaskImEES2_:
  203|  4.76k|      friend Mask<T> operator^(Mask<T> x, Mask<T> y) { return Mask<T>(x.value() ^ y.value()); }
_ZN5Botan2CT22conditional_assign_memImEENS0_4MaskIT_EES3_PS3_PKS3_m:
  298|   450k|inline Mask<T> conditional_assign_mem(T cnd, T* sink, const T* src, size_t elems) {
  299|   450k|   const auto mask = CT::Mask<T>::expand(cnd);
  300|   450k|   mask.select_n(sink, src, sink, elems);
  301|   450k|   return mask;
  302|   450k|}

_ZN5Botan9ct_divideERKNS_6BigIntES2_:
   49|  1.45k|inline BigInt ct_divide(const BigInt& x, const BigInt& y) {
   50|  1.45k|   BigInt q, r;
   51|  1.45k|   ct_divide(x, y, q, r);
   52|  1.45k|   return q;
   53|  1.45k|}

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

_ZN5Botan4EMSAD2Ev:
   25|  1.44k|      virtual ~EMSA() = default;

_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  20.1k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  20.1k|   oss << format;
   22|  20.1k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  15.3k|std::string fmt(std::string_view format, const T&... args) {
   54|  15.3k|   std::ostringstream oss;
   55|  15.3k|   oss.imbue(std::locale::classic());
   56|  15.3k|   fmt_detail::do_fmt(oss, format, args...);
   57|  15.3k|   return oss.str();
   58|  15.3k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  15.7k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  15.7k|   size_t i = 0;
   27|       |
   28|   171k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 171k, False: 0]
  ------------------
   29|   171k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 15.7k, False: 156k]
  |  Branch (29:30): [True: 15.7k, False: 0]
  |  Branch (29:59): [True: 15.7k, False: 0]
  ------------------
   30|  15.7k|         oss << val;
   31|  15.7k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|   156k|      } else {
   33|   156k|         oss << format[i];
   34|   156k|      }
   35|       |
   36|   156k|      i += 1;
   37|   156k|   }
   38|  15.7k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|    375|std::string fmt(std::string_view format, const T&... args) {
   54|    375|   std::ostringstream oss;
   55|    375|   oss.imbue(std::locale::classic());
   56|    375|   fmt_detail::do_fmt(oss, format, args...);
   57|    375|   return oss.str();
   58|    375|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|    375|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    375|   size_t i = 0;
   27|       |
   28|    375|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 375, False: 0]
  ------------------
   29|    375|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 375, False: 0]
  |  Branch (29:30): [True: 375, False: 0]
  |  Branch (29:59): [True: 375, False: 0]
  ------------------
   30|    375|         oss << val;
   31|    375|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    375|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    375|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    473|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    473|   size_t i = 0;
   27|       |
   28|  4.45k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.45k, False: 0]
  ------------------
   29|  4.45k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 473, False: 3.98k]
  |  Branch (29:30): [True: 473, False: 0]
  |  Branch (29:59): [True: 473, False: 0]
  ------------------
   30|    473|         oss << val;
   31|    473|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.98k|      } else {
   33|  3.98k|         oss << format[i];
   34|  3.98k|      }
   35|       |
   36|  3.98k|      i += 1;
   37|  3.98k|   }
   38|    473|}
_ZN5Botan3fmtIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|     98|std::string fmt(std::string_view format, const T&... args) {
   54|     98|   std::ostringstream oss;
   55|     98|   oss.imbue(std::locale::classic());
   56|     98|   fmt_detail::do_fmt(oss, format, args...);
   57|     98|   return oss.str();
   58|     98|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    215|std::string fmt(std::string_view format, const T&... args) {
   54|    215|   std::ostringstream oss;
   55|    215|   oss.imbue(std::locale::classic());
   56|    215|   fmt_detail::do_fmt(oss, format, args...);
   57|    215|   return oss.str();
   58|    215|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    215|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    215|   size_t i = 0;
   27|       |
   28|  3.10k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.10k, False: 0]
  ------------------
   29|  3.10k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 215, False: 2.88k]
  |  Branch (29:30): [True: 215, False: 0]
  |  Branch (29:59): [True: 215, False: 0]
  ------------------
   30|    215|         oss << val;
   31|    215|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  2.88k|      } else {
   33|  2.88k|         oss << format[i];
   34|  2.88k|      }
   35|       |
   36|  2.88k|      i += 1;
   37|  2.88k|   }
   38|    215|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|  1.58k|std::string fmt(std::string_view format, const T&... args) {
   54|  1.58k|   std::ostringstream oss;
   55|  1.58k|   oss.imbue(std::locale::classic());
   56|  1.58k|   fmt_detail::do_fmt(oss, format, args...);
   57|  1.58k|   return oss.str();
   58|  1.58k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  1.58k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.58k|   size_t i = 0;
   27|       |
   28|  1.58k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.58k, False: 0]
  ------------------
   29|  1.58k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.58k, False: 0]
  |  Branch (29:30): [True: 1.58k, False: 0]
  |  Branch (29:59): [True: 1.58k, False: 0]
  ------------------
   30|  1.58k|         oss << val;
   31|  1.58k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  1.58k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  1.58k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  1.58k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  1.58k|   size_t i = 0;
   27|       |
   28|  7.93k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 7.93k, False: 0]
  ------------------
   29|  7.93k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1.58k, False: 6.34k]
  |  Branch (29:30): [True: 1.58k, False: 0]
  |  Branch (29:59): [True: 1.58k, False: 0]
  ------------------
   30|  1.58k|         oss << val;
   31|  1.58k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  6.34k|      } else {
   33|  6.34k|         oss << format[i];
   34|  6.34k|      }
   35|       |
   36|  6.34k|      i += 1;
   37|  6.34k|   }
   38|  1.58k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  3.70k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.70k|   size_t i = 0;
   27|       |
   28|  32.8k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 32.8k, False: 0]
  ------------------
   29|  32.8k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.70k, False: 29.1k]
  |  Branch (29:30): [True: 3.70k, False: 0]
  |  Branch (29:59): [True: 3.70k, False: 0]
  ------------------
   30|  3.70k|         oss << val;
   31|  3.70k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  29.1k|      } else {
   33|  29.1k|         oss << format[i];
   34|  29.1k|      }
   35|       |
   36|  29.1k|      i += 1;
   37|  29.1k|   }
   38|  3.70k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKcEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  2.11k|std::string fmt(std::string_view format, const T&... args) {
   54|  2.11k|   std::ostringstream oss;
   55|  2.11k|   oss.imbue(std::locale::classic());
   56|  2.11k|   fmt_detail::do_fmt(oss, format, args...);
   57|  2.11k|   return oss.str();
   58|  2.11k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJPKcEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  2.11k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  2.11k|   size_t i = 0;
   27|       |
   28|  2.11k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 2.11k, False: 0]
  ------------------
   29|  2.11k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 2.11k, False: 0]
  |  Branch (29:30): [True: 2.11k, False: 0]
  |  Branch (29:59): [True: 2.11k, False: 0]
  ------------------
   30|  2.11k|         oss << val;
   31|  2.11k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  2.11k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  2.11k|}
_ZN5Botan3fmtIJPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEENS3_12basic_stringIcS6_NS3_9allocatorIcEEEES7_DpRKT_:
   53|    383|std::string fmt(std::string_view format, const T&... args) {
   54|    383|   std::ostringstream oss;
   55|    383|   oss.imbue(std::locale::classic());
   56|    383|   fmt_detail::do_fmt(oss, format, args...);
   57|    383|   return oss.str();
   58|    383|}
_ZN5Botan10fmt_detail6do_fmtIPKcJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEvRNS4_19basic_ostringstreamIcS7_NS4_9allocatorIcEEEES8_RKT_DpRKT0_:
   25|    383|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    383|   size_t i = 0;
   27|       |
   28|    383|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 383, False: 0]
  ------------------
   29|    383|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 383, False: 0]
  |  Branch (29:30): [True: 383, False: 0]
  |  Branch (29:59): [True: 383, False: 0]
  ------------------
   30|    383|         oss << val;
   31|    383|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    383|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    383|}

_ZN5Botan11make_uint16Ehh:
   50|     48|inline constexpr uint16_t make_uint16(uint8_t i0, uint8_t i1) {
   51|     48|   return static_cast<uint16_t>((static_cast<uint16_t>(i0) << 8) | i1);
   52|     48|}
_ZN5Botan8get_byteILm0EmEEhT0_:
   39|   116k|{
   40|   116k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|   116k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|   116k|}
_ZN5Botan12get_byte_varImEEhmT_:
   27|  63.4k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   28|  63.4k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   29|  63.4k|}
_ZN5Botan8store_leImEEvT_Ph:
  418|  1.21k|inline constexpr void store_le(T in, uint8_t out[sizeof(T)]) {
  419|  1.21k|   store_le(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  420|  1.21k|}
_ZN5Botan8store_leImNSt3__14spanIhLm8EEEEEvT_OT0_:
  383|  1.21k|inline constexpr void store_le(T in, OutR&& out_range) {
  384|  1.21k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  385|  1.21k|   std::span out{out_range};
  386|  1.21k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (386:17): [Folded - Ignored]
  ------------------
  387|  1.21k|      out[0] = static_cast<uint8_t>(in);
  388|  1.21k|   } else {
  389|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  390|       |      typecast_copy(out, reverse_bytes(in));
  391|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  392|  1.21k|      typecast_copy(out, in);
  393|       |#else
  394|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  395|       |         ((out[i] = get_byte<sizeof(T) - i - 1>(in)), ...);
  396|       |      }
  397|       |      (std::make_index_sequence<sizeof(T)>());
  398|       |#endif
  399|  1.21k|   }
  400|  1.21k|}
_ZN5Botan15copy_out_vec_leIjNS_16secure_allocatorIjEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  540|  1.21k|void copy_out_vec_le(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  541|  1.21k|   copy_out_le(out, out_bytes, in.data());
  542|  1.21k|}
_ZN5Botan11copy_out_leIjEEvPhmPKT_:
  526|  1.21k|void copy_out_le(uint8_t out[], size_t out_bytes, const T in[]) {
  527|  6.07k|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (527:10): [True: 4.85k, False: 1.21k]
  ------------------
  528|  4.85k|      store_le(in[0], out);
  529|  4.85k|      out += sizeof(T);
  530|  4.85k|      out_bytes -= sizeof(T);
  531|  4.85k|      in += 1;
  532|  4.85k|   }
  533|       |
  534|  1.21k|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (534:22): [True: 0, False: 1.21k]
  ------------------
  535|      0|      out[i] = get_byte_var(sizeof(T) - 1 - (i % 8), in[0]);
  536|      0|   }
  537|  1.21k|}
_ZN5Botan8store_leIjEEvT_Ph:
  418|  4.85k|inline constexpr void store_le(T in, uint8_t out[sizeof(T)]) {
  419|  4.85k|   store_le(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  420|  4.85k|}
_ZN5Botan8store_leIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  383|  4.85k|inline constexpr void store_le(T in, OutR&& out_range) {
  384|  4.85k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  385|  4.85k|   std::span out{out_range};
  386|  4.85k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (386:17): [Folded - Ignored]
  ------------------
  387|  4.85k|      out[0] = static_cast<uint8_t>(in);
  388|  4.85k|   } else {
  389|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  390|       |      typecast_copy(out, reverse_bytes(in));
  391|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  392|  4.85k|      typecast_copy(out, in);
  393|       |#else
  394|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  395|       |         ((out[i] = get_byte<sizeof(T) - i - 1>(in)), ...);
  396|       |      }
  397|       |      (std::make_index_sequence<sizeof(T)>());
  398|       |#endif
  399|  4.85k|   }
  400|  4.85k|}
_ZN5Botan7load_leIjEEvPT_PKhm:
  310|  15.6k|inline constexpr void load_le(T out[], const uint8_t in[], size_t count) {
  311|  15.6k|   if(count > 0) {
  ------------------
  |  Branch (311:7): [True: 15.6k, False: 0]
  ------------------
  312|  15.6k|#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  313|  15.6k|      typecast_copy(out, in, count);
  314|       |
  315|       |#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  316|       |      typecast_copy(out, in, count);
  317|       |
  318|       |      for(size_t i = 0; i != count; ++i)
  319|       |         out[i] = reverse_bytes(out[i]);
  320|       |#else
  321|       |      for(size_t i = 0; i != count; ++i)
  322|       |         out[i] = load_le<T>(in, i);
  323|       |#endif
  324|  15.6k|   }
  325|  15.6k|}
_ZN5Botan8store_beImEEvT_Ph:
  408|  44.8k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|  44.8k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|  44.8k|}
_ZN5Botan8store_beImNSt3__14spanIhLm8EEEEEvT_OT0_:
  358|  44.8k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|  44.8k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|  44.8k|   std::span out{out_range};
  361|  44.8k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|  44.8k|      out[0] = static_cast<uint8_t>(in);
  363|  44.8k|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|  44.8k|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|  44.8k|   }
  375|  44.8k|}
_ZN5Botan15copy_out_vec_beIjNS_16secure_allocatorIjEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  521|  17.1k|void copy_out_vec_be(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  522|  17.1k|   copy_out_be(out, out_bytes, in.data());
  523|  17.1k|}
_ZN5Botan11copy_out_beIjEEvPhmPKT_:
  507|  17.1k|void copy_out_be(uint8_t out[], size_t out_bytes, const T in[]) {
  508|   133k|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (508:10): [True: 116k, False: 17.1k]
  ------------------
  509|   116k|      store_be(in[0], out);
  510|   116k|      out += sizeof(T);
  511|   116k|      out_bytes -= sizeof(T);
  512|   116k|      in += 1;
  513|   116k|   }
  514|       |
  515|  17.1k|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (515:22): [True: 0, False: 17.1k]
  ------------------
  516|      0|      out[i] = get_byte_var(i % 8, in[0]);
  517|      0|   }
  518|  17.1k|}
_ZN5Botan8store_beIjEEvT_Ph:
  408|   117k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|   117k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|   117k|}
_ZN5Botan8store_beIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  358|   117k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|   117k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|   117k|   std::span out{out_range};
  361|   117k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|   117k|      out[0] = static_cast<uint8_t>(in);
  363|   117k|   } else {
  364|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  365|       |      typecast_copy(out, in);
  366|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  367|   117k|      typecast_copy(out, reverse_bytes(in));
  368|       |#else
  369|       |      [&]<size_t... i>(std::index_sequence<i...>) {
  370|       |         ((out[i] = get_byte<i>(in)), ...);
  371|       |      }
  372|       |      (std::make_index_sequence<sizeof(T)>());
  373|       |#endif
  374|   117k|   }
  375|   117k|}
_ZN5Botan7load_beIjEET_PKhm:
  226|   982k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|   982k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|   982k|}
_ZN5Botan7load_beIjNSt3__14spanIKhLm4EEEEET_OT0_:
   92|   982k|inline constexpr T load_be(InR&& in_range) {
   93|   982k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|   982k|   std::span in{in_range};
   95|   982k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|   982k|      return static_cast<T>(in[0]);
   97|   982k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|   982k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|   982k|   }
  109|   982k|}
_ZN5Botan7load_beImEET_PKhm:
  226|  73.0k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  73.0k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  73.0k|}
_ZN5Botan7load_beImNSt3__14spanIKhLm8EEEEET_OT0_:
   92|  73.0k|inline constexpr T load_be(InR&& in_range) {
   93|  73.0k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  73.0k|   std::span in{in_range};
   95|  73.0k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  73.0k|      return static_cast<T>(in[0]);
   97|  73.0k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  73.0k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  73.0k|   }
  109|  73.0k|}
_ZN5Botan15copy_out_vec_beImNS_16secure_allocatorImEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  521|     53|void copy_out_vec_be(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  522|     53|   copy_out_be(out, out_bytes, in.data());
  523|     53|}
_ZN5Botan11copy_out_beImEEvPhmPKT_:
  507|     53|void copy_out_be(uint8_t out[], size_t out_bytes, const T in[]) {
  508|    385|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (508:10): [True: 332, False: 53]
  ------------------
  509|    332|      store_be(in[0], out);
  510|    332|      out += sizeof(T);
  511|    332|      out_bytes -= sizeof(T);
  512|    332|      in += 1;
  513|    332|   }
  514|       |
  515|     53|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (515:22): [True: 0, False: 53]
  ------------------
  516|      0|      out[i] = get_byte_var(i % 8, in[0]);
  517|      0|   }
  518|     53|}
_ZN5Botan7load_beItEET_PKhm:
  226|  1.22k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  1.22k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  1.22k|}
_ZN5Botan7load_beItNSt3__14spanIKhLm2EEEEET_OT0_:
   92|  1.22k|inline constexpr T load_be(InR&& in_range) {
   93|  1.22k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  1.22k|   std::span in{in_range};
   95|  1.22k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  1.22k|      return static_cast<T>(in[0]);
   97|  1.22k|   } else {
   98|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |      return typecast_copy<T>(in);
  100|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  101|  1.22k|      return reverse_bytes(typecast_copy<T>(in));
  102|       |#else
  103|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  104|       |         return ((static_cast<T>(in[i]) << ((sizeof(T) - i - 1) * 8)) | ...);
  105|       |      }
  106|       |      (std::make_index_sequence<sizeof(T)>());
  107|       |#endif
  108|  1.22k|   }
  109|  1.22k|}

_ZNK5Botan3MD54nameEv:
   32|  1.21k|      std::string name() const override { return "MD5"; }
_ZNK5Botan3MD513output_lengthEv:
   34|  2.42k|      size_t output_length() const override { return output_bytes; }

_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EEC2Ev:
   42|  6.77k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE5clearEv:
   70|  13.5k|      void clear() {
   71|  13.5k|         MD::init(m_digest);
   72|  13.5k|         m_buffer.clear();
   73|  13.5k|         m_count = 0;
   74|  13.5k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EEC2Ev:
   42|     32|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE5clearEv:
   70|     64|      void clear() {
   71|     64|         MD::init(m_digest);
   72|     64|         m_buffer.clear();
   73|     64|         m_count = 0;
   74|     64|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EEC2Ev:
   42|  6.91k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5clearEv:
   70|  17.2k|      void clear() {
   71|  17.2k|         MD::init(m_digest);
   72|  17.2k|         m_buffer.clear();
   73|  17.2k|         m_count = 0;
   74|  17.2k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EEC2Ev:
   42|     42|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE5clearEv:
   70|     84|      void clear() {
   71|     84|         MD::init(m_digest);
   72|     84|         m_buffer.clear();
   73|     84|         m_count = 0;
   74|     84|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EEC2Ev:
   42|      9|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE5clearEv:
   70|     18|      void clear() {
   71|     18|         MD::init(m_digest);
   72|     18|         m_buffer.clear();
   73|     18|         m_count = 0;
   74|     18|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EEC2Ev:
   42|      2|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE5clearEv:
   70|      4|      void clear() {
   71|      4|         MD::init(m_digest);
   72|      4|         m_buffer.clear();
   73|      4|         m_count = 0;
   74|      4|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EEC2Ev:
   42|  1.21k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5clearEv:
   70|  2.42k|      void clear() {
   71|  2.42k|         MD::init(m_digest);
   72|  2.42k|         m_buffer.clear();
   73|  2.42k|         m_count = 0;
   74|  2.42k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  1.21k|      void update(std::span<const uint8_t> input) {
   45|  1.21k|         BufferSlicer in(input);
   46|       |
   47|  3.63k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 2.42k, False: 1.21k]
  ------------------
   48|  2.42k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 2.42k]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|  2.42k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 1.21k, False: 1.20k]
  ------------------
   53|  1.21k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  1.21k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 1.21k, False: 0]
  ------------------
   55|  1.21k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  1.21k|               }
   57|  1.21k|            }
   58|  2.42k|         }
   59|       |
   60|  1.21k|         m_count += input.size();
   61|  1.21k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  1.21k|      void final(std::span<uint8_t> output) {
   64|  1.21k|         append_padding_bit();
   65|  1.21k|         append_counter_and_finalize();
   66|  1.21k|         copy_output(output);
   67|  1.21k|         clear();
   68|  1.21k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE18append_padding_bitEv:
   77|  1.21k|      void append_padding_bit() {
   78|  1.21k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  1.21k|   do {                                                                     \
  |  |   61|  1.21k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.21k]
  |  |  ------------------
  |  |   62|  1.21k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.21k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|  1.21k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|  1.21k|            const uint8_t final_byte = 0x80;
   81|  1.21k|            m_buffer.append({&final_byte, 1});
   82|  1.21k|         } else {
   83|  1.21k|            const uint8_t final_byte = 0x01;
   84|  1.21k|            m_buffer.append({&final_byte, 1});
   85|  1.21k|         }
   86|  1.21k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE27append_counter_and_finalizeEv:
   88|  1.21k|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|  1.21k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 34, False: 1.18k]
  ------------------
   92|     34|            m_buffer.fill_up_with_zeros();
   93|     34|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|     34|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  1.21k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  1.21k|   do {                                                                     \
  |  |   61|  1.21k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.21k]
  |  |  ------------------
  |  |   62|  1.21k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.21k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  1.21k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  1.21k|         const uint64_t bit_count = m_count * 8;
  102|  1.21k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  1.21k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|  1.21k|            store_be(bit_count, last_bytes.data());
  105|  1.21k|         } else {
  106|  1.21k|            store_le(bit_count, last_bytes.data());
  107|  1.21k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  1.21k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  1.21k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  1.21k|      void copy_output(std::span<uint8_t> output) {
  114|  1.21k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  1.21k|   do {                                                                     \
  |  |   61|  1.21k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.21k]
  |  |  ------------------
  |  |   62|  1.21k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.21k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  1.21k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|  1.21k|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|  1.21k|         } else {
  119|  1.21k|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|  1.21k|         }
  121|  1.21k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  6.77k|      void update(std::span<const uint8_t> input) {
   45|  6.77k|         BufferSlicer in(input);
   46|       |
   47|  19.7k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 12.9k, False: 6.77k]
  ------------------
   48|  12.9k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 12.9k]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|  12.9k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 6.29k, False: 6.68k]
  ------------------
   53|  6.29k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  6.29k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 6.29k, False: 0]
  ------------------
   55|  6.29k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  6.29k|               }
   57|  6.29k|            }
   58|  12.9k|         }
   59|       |
   60|  6.77k|         m_count += input.size();
   61|  6.77k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  6.77k|      void final(std::span<uint8_t> output) {
   64|  6.77k|         append_padding_bit();
   65|  6.77k|         append_counter_and_finalize();
   66|  6.77k|         copy_output(output);
   67|  6.77k|         clear();
   68|  6.77k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE18append_padding_bitEv:
   77|  6.77k|      void append_padding_bit() {
   78|  6.77k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  6.77k|   do {                                                                     \
  |  |   61|  6.77k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 6.77k]
  |  |  ------------------
  |  |   62|  6.77k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  6.77k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|  6.77k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|  6.77k|            const uint8_t final_byte = 0x80;
   81|  6.77k|            m_buffer.append({&final_byte, 1});
   82|  6.77k|         } else {
   83|  6.77k|            const uint8_t final_byte = 0x01;
   84|  6.77k|            m_buffer.append({&final_byte, 1});
   85|  6.77k|         }
   86|  6.77k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE27append_counter_and_finalizeEv:
   88|  6.77k|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|  6.77k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 806, False: 5.96k]
  ------------------
   92|    806|            m_buffer.fill_up_with_zeros();
   93|    806|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|    806|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  6.77k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  6.77k|   do {                                                                     \
  |  |   61|  6.77k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 6.77k]
  |  |  ------------------
  |  |   62|  6.77k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  6.77k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  6.77k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  6.77k|         const uint64_t bit_count = m_count * 8;
  102|  6.77k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  6.77k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|  6.77k|            store_be(bit_count, last_bytes.data());
  105|  6.77k|         } else {
  106|  6.77k|            store_le(bit_count, last_bytes.data());
  107|  6.77k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  6.77k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  6.77k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  6.77k|      void copy_output(std::span<uint8_t> output) {
  114|  6.77k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  6.77k|   do {                                                                     \
  |  |   61|  6.77k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 6.77k]
  |  |  ------------------
  |  |   62|  6.77k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  6.77k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  6.77k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|  6.77k|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|  6.77k|         } else {
  119|  6.77k|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|  6.77k|         }
  121|  6.77k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     32|      void update(std::span<const uint8_t> input) {
   45|     32|         BufferSlicer in(input);
   46|       |
   47|     96|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 64, False: 32]
  ------------------
   48|     64|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 64]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|     64|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 32, False: 32]
  ------------------
   53|     32|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     32|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 32, False: 0]
  ------------------
   55|     32|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     32|               }
   57|     32|            }
   58|     64|         }
   59|       |
   60|     32|         m_count += input.size();
   61|     32|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     32|      void final(std::span<uint8_t> output) {
   64|     32|         append_padding_bit();
   65|     32|         append_counter_and_finalize();
   66|     32|         copy_output(output);
   67|     32|         clear();
   68|     32|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE18append_padding_bitEv:
   77|     32|      void append_padding_bit() {
   78|     32|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     32|   do {                                                                     \
  |  |   61|     32|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 32]
  |  |  ------------------
  |  |   62|     32|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     32|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     32|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     32|            const uint8_t final_byte = 0x80;
   81|     32|            m_buffer.append({&final_byte, 1});
   82|     32|         } else {
   83|     32|            const uint8_t final_byte = 0x01;
   84|     32|            m_buffer.append({&final_byte, 1});
   85|     32|         }
   86|     32|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE27append_counter_and_finalizeEv:
   88|     32|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|     32|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 0, False: 32]
  ------------------
   92|      0|            m_buffer.fill_up_with_zeros();
   93|      0|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      0|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     32|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     32|   do {                                                                     \
  |  |   61|     32|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 32]
  |  |  ------------------
  |  |   62|     32|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     32|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     32|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     32|         const uint64_t bit_count = m_count * 8;
  102|     32|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     32|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     32|            store_be(bit_count, last_bytes.data());
  105|     32|         } else {
  106|     32|            store_le(bit_count, last_bytes.data());
  107|     32|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     32|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     32|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     32|      void copy_output(std::span<uint8_t> output) {
  114|     32|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     32|   do {                                                                     \
  |  |   61|     32|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 32]
  |  |  ------------------
  |  |   62|     32|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     32|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     32|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     32|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     32|         } else {
  119|     32|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     32|         }
  121|     32|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  10.3k|      void update(std::span<const uint8_t> input) {
   45|  10.3k|         BufferSlicer in(input);
   46|       |
   47|  24.4k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 14.1k, False: 10.3k]
  ------------------
   48|  14.1k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 14.1k]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|  14.1k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 3.88k, False: 10.3k]
  ------------------
   53|  3.88k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  3.88k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 3.88k, False: 0]
  ------------------
   55|  3.88k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  3.88k|               }
   57|  3.88k|            }
   58|  14.1k|         }
   59|       |
   60|  10.3k|         m_count += input.size();
   61|  10.3k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  10.3k|      void final(std::span<uint8_t> output) {
   64|  10.3k|         append_padding_bit();
   65|  10.3k|         append_counter_and_finalize();
   66|  10.3k|         copy_output(output);
   67|  10.3k|         clear();
   68|  10.3k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE18append_padding_bitEv:
   77|  10.3k|      void append_padding_bit() {
   78|  10.3k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  10.3k|   do {                                                                     \
  |  |   61|  10.3k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 10.3k]
  |  |  ------------------
  |  |   62|  10.3k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  10.3k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|  10.3k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|  10.3k|            const uint8_t final_byte = 0x80;
   81|  10.3k|            m_buffer.append({&final_byte, 1});
   82|  10.3k|         } else {
   83|  10.3k|            const uint8_t final_byte = 0x01;
   84|  10.3k|            m_buffer.append({&final_byte, 1});
   85|  10.3k|         }
   86|  10.3k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE27append_counter_and_finalizeEv:
   88|  10.3k|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|  10.3k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 1.11k, False: 9.18k]
  ------------------
   92|  1.11k|            m_buffer.fill_up_with_zeros();
   93|  1.11k|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|  1.11k|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  10.3k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  10.3k|   do {                                                                     \
  |  |   61|  10.3k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 10.3k]
  |  |  ------------------
  |  |   62|  10.3k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  10.3k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  10.3k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  10.3k|         const uint64_t bit_count = m_count * 8;
  102|  10.3k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  10.3k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|  10.3k|            store_be(bit_count, last_bytes.data());
  105|  10.3k|         } else {
  106|  10.3k|            store_le(bit_count, last_bytes.data());
  107|  10.3k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  10.3k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  10.3k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  10.3k|      void copy_output(std::span<uint8_t> output) {
  114|  10.3k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  10.3k|   do {                                                                     \
  |  |   61|  10.3k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 10.3k]
  |  |  ------------------
  |  |   62|  10.3k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  10.3k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  10.3k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|  10.3k|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|  10.3k|         } else {
  119|  10.3k|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|  10.3k|         }
  121|  10.3k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     42|      void update(std::span<const uint8_t> input) {
   45|     42|         BufferSlicer in(input);
   46|       |
   47|    126|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 84, False: 42]
  ------------------
   48|     84|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 84]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|     84|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 42, False: 42]
  ------------------
   53|     42|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     42|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 42, False: 0]
  ------------------
   55|     42|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     42|               }
   57|     42|            }
   58|     84|         }
   59|       |
   60|     42|         m_count += input.size();
   61|     42|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|      9|      void update(std::span<const uint8_t> input) {
   45|      9|         BufferSlicer in(input);
   46|       |
   47|     27|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 18, False: 9]
  ------------------
   48|     18|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 18]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|     18|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 9, False: 9]
  ------------------
   53|      9|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|      9|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 9, False: 0]
  ------------------
   55|      9|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|      9|               }
   57|      9|            }
   58|     18|         }
   59|       |
   60|      9|         m_count += input.size();
   61|      9|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|      2|      void update(std::span<const uint8_t> input) {
   45|      2|         BufferSlicer in(input);
   46|       |
   47|      6|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 4, False: 2]
  ------------------
   48|      4|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 4]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|      4|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 2, False: 2]
  ------------------
   53|      2|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|      2|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 2, False: 0]
  ------------------
   55|      2|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|      2|               }
   57|      2|            }
   58|      4|         }
   59|       |
   60|      2|         m_count += input.size();
   61|      2|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     42|      void final(std::span<uint8_t> output) {
   64|     42|         append_padding_bit();
   65|     42|         append_counter_and_finalize();
   66|     42|         copy_output(output);
   67|     42|         clear();
   68|     42|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE18append_padding_bitEv:
   77|     42|      void append_padding_bit() {
   78|     42|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     42|   do {                                                                     \
  |  |   61|     42|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 42]
  |  |  ------------------
  |  |   62|     42|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     42|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     42|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     42|            const uint8_t final_byte = 0x80;
   81|     42|            m_buffer.append({&final_byte, 1});
   82|     42|         } else {
   83|     42|            const uint8_t final_byte = 0x01;
   84|     42|            m_buffer.append({&final_byte, 1});
   85|     42|         }
   86|     42|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE27append_counter_and_finalizeEv:
   88|     42|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|     42|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 0, False: 42]
  ------------------
   92|      0|            m_buffer.fill_up_with_zeros();
   93|      0|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      0|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     42|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     42|   do {                                                                     \
  |  |   61|     42|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 42]
  |  |  ------------------
  |  |   62|     42|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     42|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     42|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     42|         const uint64_t bit_count = m_count * 8;
  102|     42|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     42|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     42|            store_be(bit_count, last_bytes.data());
  105|     42|         } else {
  106|     42|            store_le(bit_count, last_bytes.data());
  107|     42|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     42|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     42|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     42|      void copy_output(std::span<uint8_t> output) {
  114|     42|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     42|   do {                                                                     \
  |  |   61|     42|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 42]
  |  |  ------------------
  |  |   62|     42|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     42|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     42|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     42|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     42|         } else {
  119|     42|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     42|         }
  121|     42|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|      9|      void final(std::span<uint8_t> output) {
   64|      9|         append_padding_bit();
   65|      9|         append_counter_and_finalize();
   66|      9|         copy_output(output);
   67|      9|         clear();
   68|      9|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE18append_padding_bitEv:
   77|      9|      void append_padding_bit() {
   78|      9|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|      9|   do {                                                                     \
  |  |   61|      9|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 9]
  |  |  ------------------
  |  |   62|      9|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      9|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|      9|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|      9|            const uint8_t final_byte = 0x80;
   81|      9|            m_buffer.append({&final_byte, 1});
   82|      9|         } else {
   83|      9|            const uint8_t final_byte = 0x01;
   84|      9|            m_buffer.append({&final_byte, 1});
   85|      9|         }
   86|      9|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE27append_counter_and_finalizeEv:
   88|      9|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|      9|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 0, False: 9]
  ------------------
   92|      0|            m_buffer.fill_up_with_zeros();
   93|      0|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      0|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|      9|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|      9|   do {                                                                     \
  |  |   61|      9|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 9]
  |  |  ------------------
  |  |   62|      9|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      9|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|      9|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|      9|         const uint64_t bit_count = m_count * 8;
  102|      9|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|      9|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|      9|            store_be(bit_count, last_bytes.data());
  105|      9|         } else {
  106|      9|            store_le(bit_count, last_bytes.data());
  107|      9|         }
  108|       |
  109|       |         // Compress the very last block.
  110|      9|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|      9|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|      9|      void copy_output(std::span<uint8_t> output) {
  114|      9|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|      9|   do {                                                                     \
  |  |   61|      9|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 9]
  |  |  ------------------
  |  |   62|      9|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      9|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|      9|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|      9|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|      9|         } else {
  119|      9|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|      9|         }
  121|      9|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|      2|      void final(std::span<uint8_t> output) {
   64|      2|         append_padding_bit();
   65|      2|         append_counter_and_finalize();
   66|      2|         copy_output(output);
   67|      2|         clear();
   68|      2|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE18append_padding_bitEv:
   77|      2|      void append_padding_bit() {
   78|      2|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|      2|   do {                                                                     \
  |  |   61|      2|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 2]
  |  |  ------------------
  |  |   62|      2|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      2|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|      2|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|      2|            const uint8_t final_byte = 0x80;
   81|      2|            m_buffer.append({&final_byte, 1});
   82|      2|         } else {
   83|      2|            const uint8_t final_byte = 0x01;
   84|      2|            m_buffer.append({&final_byte, 1});
   85|      2|         }
   86|      2|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE27append_counter_and_finalizeEv:
   88|      2|      void append_counter_and_finalize() {
   89|       |         // Compress the remaining data if the final data block does not provide
   90|       |         // enough space for the counter bytes.
   91|      2|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 0, False: 2]
  ------------------
   92|      0|            m_buffer.fill_up_with_zeros();
   93|      0|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      0|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|      2|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|      2|   do {                                                                     \
  |  |   61|      2|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 2]
  |  |  ------------------
  |  |   62|      2|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      2|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|      2|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|      2|         const uint64_t bit_count = m_count * 8;
  102|      2|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|      2|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|      2|            store_be(bit_count, last_bytes.data());
  105|      2|         } else {
  106|      2|            store_le(bit_count, last_bytes.data());
  107|      2|         }
  108|       |
  109|       |         // Compress the very last block.
  110|      2|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|      2|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|      2|      void copy_output(std::span<uint8_t> output) {
  114|      2|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|      2|   do {                                                                     \
  |  |   61|      2|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 2]
  |  |  ------------------
  |  |   62|      2|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      2|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|      2|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|      2|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|      2|         } else {
  119|      2|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|      2|         }
  121|      2|      }

_ZNK5Botan14Montgomery_Int19const_time_unpoisonEv:
  124|  1.36k|      void const_time_unpoison() const { return m_v.const_time_unpoison(); }
_ZNK5Botan17Montgomery_Params1pEv:
  148|  2.73k|      const BigInt& p() const { return m_p; }
_ZNK5Botan17Montgomery_Params2R1Ev:
  150|  1.36k|      const BigInt& R1() const { return m_r1; }
_ZNK5Botan17Montgomery_Params2R2Ev:
  152|  1.36k|      const BigInt& R2() const { return m_r2; }
_ZNK5Botan17Montgomery_Params7p_wordsEv:
  158|  2.73k|      size_t p_words() const { return m_p_words; }

_ZN5Botan10word8_sub3EPmPKmS2_m:
  413|  13.4M|inline word word8_sub3(word z[8], const word x[8], const word y[8], word carry) {
  414|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  415|       |   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbl"))
  416|       |       : [carry] "=r"(carry)
  417|       |       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  418|       |       : "cc", "memory");
  419|       |
  420|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  421|  13.4M|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
  422|  13.4M|       : [carry] "=r"(carry)
  423|  13.4M|       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  424|  13.4M|       : "cc", "memory");
  425|       |
  426|       |#else
  427|       |   z[0] = word_sub(x[0], y[0], &carry);
  428|       |   z[1] = word_sub(x[1], y[1], &carry);
  429|       |   z[2] = word_sub(x[2], y[2], &carry);
  430|       |   z[3] = word_sub(x[3], y[3], &carry);
  431|       |   z[4] = word_sub(x[4], y[4], &carry);
  432|       |   z[5] = word_sub(x[5], y[5], &carry);
  433|       |   z[6] = word_sub(x[6], y[6], &carry);
  434|       |   z[7] = word_sub(x[7], y[7], &carry);
  435|       |#endif
  436|       |
  437|  13.4M|   return carry;
  438|  13.4M|}
_ZN5Botan8word_subEmmPm:
  326|  33.2M|inline word word_sub(word x, word y, word* carry) {
  327|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  328|       |   asm(ADD_OR_SUBTRACT(ASM("sbbl %[y],%[x]"))
  329|       |       : [x] "=r"(x), [carry] "=r"(*carry)
  330|       |       : "0"(x), [y] "rm"(y), "1"(*carry)
  331|       |       : "cc");
  332|       |   return x;
  333|       |
  334|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  335|  33.2M|   asm(ADD_OR_SUBTRACT(ASM("sbbq %[y],%[x]"))
  336|  33.2M|       : [x] "=r"(x), [carry] "=r"(*carry)
  337|  33.2M|       : "0"(x), [y] "rm"(y), "1"(*carry)
  338|  33.2M|       : "cc");
  339|  33.2M|   return x;
  340|       |
  341|       |#else
  342|       |   word t0 = x - y;
  343|       |   word c1 = (t0 > x);
  344|       |   word z = t0 - *carry;
  345|       |   *carry = c1 | (z > t0);
  346|       |   return z;
  347|       |#endif
  348|  33.2M|}
_ZN5Botan10word8_add3EPmPKmS2_m:
  296|  72.6k|inline word word8_add3(word z[8], const word x[8], const word y[8], word carry) {
  297|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  298|       |   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcl"))
  299|       |       : [carry] "=r"(carry)
  300|       |       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  301|       |       : "cc", "memory");
  302|       |
  303|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  304|  72.6k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcq"))
  305|  72.6k|       : [carry] "=r"(carry)
  306|  72.6k|       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  307|  72.6k|       : "cc", "memory");
  308|       |
  309|       |#else
  310|       |   z[0] = word_add(x[0], y[0], &carry);
  311|       |   z[1] = word_add(x[1], y[1], &carry);
  312|       |   z[2] = word_add(x[2], y[2], &carry);
  313|       |   z[3] = word_add(x[3], y[3], &carry);
  314|       |   z[4] = word_add(x[4], y[4], &carry);
  315|       |   z[5] = word_add(x[5], y[5], &carry);
  316|       |   z[6] = word_add(x[6], y[6], &carry);
  317|       |   z[7] = word_add(x[7], y[7], &carry);
  318|       |#endif
  319|       |
  320|  72.6k|   return carry;
  321|  72.6k|}
_ZN5Botan8word_addEmmPm:
  237|   371k|inline word word_add(word x, word y, word* carry) {
  238|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  239|       |   asm(ADD_OR_SUBTRACT(ASM("adcl %[y],%[x]"))
  240|       |       : [x] "=r"(x), [carry] "=r"(*carry)
  241|       |       : "0"(x), [y] "rm"(y), "1"(*carry)
  242|       |       : "cc");
  243|       |   return x;
  244|       |
  245|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  246|       |
  247|   371k|   asm(ADD_OR_SUBTRACT(ASM("adcq %[y],%[x]"))
  248|   371k|       : [x] "=r"(x), [carry] "=r"(*carry)
  249|   371k|       : "0"(x), [y] "rm"(y), "1"(*carry)
  250|   371k|       : "cc");
  251|   371k|   return x;
  252|       |
  253|       |#else
  254|       |   word z = x + y;
  255|       |   word c1 = (z < x);
  256|       |   z += *carry;
  257|       |   *carry = c1 | (z < *carry);
  258|       |   return z;
  259|       |#endif
  260|   371k|}
_ZN5Botan10word_madd2EmmPm:
   44|  99.4k|inline word word_madd2(word a, word b, word* c) {
   45|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
   46|       |   asm(R"(
   47|       |      mull %[b]
   48|       |      addl %[c],%[a]
   49|       |      adcl $0,%[carry]
   50|       |      )"
   51|       |       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*c)
   52|       |       : "0"(a), "1"(b), [c] "g"(*c)
   53|       |       : "cc");
   54|       |
   55|       |   return a;
   56|       |
   57|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
   58|  99.4k|   asm(R"(
   59|  99.4k|      mulq %[b]
   60|  99.4k|      addq %[c],%[a]
   61|  99.4k|      adcq $0,%[carry]
   62|  99.4k|      )"
   63|  99.4k|       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*c)
   64|  99.4k|       : "0"(a), "1"(b), [c] "g"(*c)
   65|  99.4k|       : "cc");
   66|       |
   67|  99.4k|   return a;
   68|       |
   69|       |#elif defined(BOTAN_MP_DWORD)
   70|       |   const BOTAN_MP_DWORD s = static_cast<BOTAN_MP_DWORD>(a) * b + *c;
   71|       |   *c = static_cast<word>(s >> BOTAN_MP_WORD_BITS);
   72|       |   return static_cast<word>(s);
   73|       |#else
   74|       |   static_assert(BOTAN_MP_WORD_BITS == 64, "Unexpected word size");
   75|       |
   76|       |   word hi = 0, lo = 0;
   77|       |
   78|       |   mul64x64_128(a, b, &lo, &hi);
   79|       |
   80|       |   lo += *c;
   81|       |   hi += (lo < *c);  // carry?
   82|       |
   83|       |   *c = hi;
   84|       |   return lo;
   85|       |#endif
   86|  99.4k|}
_ZN5Botan10word_madd3EmmmPm:
   91|  9.79M|inline word word_madd3(word a, word b, word c, word* d) {
   92|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
   93|       |   asm(R"(
   94|       |      mull %[b]
   95|       |
   96|       |      addl %[c],%[a]
   97|       |      adcl $0,%[carry]
   98|       |
   99|       |      addl %[d],%[a]
  100|       |      adcl $0,%[carry]
  101|       |      )"
  102|       |       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*d)
  103|       |       : "0"(a), "1"(b), [c] "g"(c), [d] "g"(*d)
  104|       |       : "cc");
  105|       |
  106|       |   return a;
  107|       |
  108|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  109|  9.79M|   asm(R"(
  110|  9.79M|      mulq %[b]
  111|  9.79M|
  112|  9.79M|      addq %[c],%[a]
  113|  9.79M|      adcq $0,%[carry]
  114|  9.79M|
  115|  9.79M|      addq %[d],%[a]
  116|  9.79M|      adcq $0,%[carry]
  117|  9.79M|      )"
  118|  9.79M|       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*d)
  119|  9.79M|       : "0"(a), "1"(b), [c] "g"(c), [d] "g"(*d)
  120|  9.79M|       : "cc");
  121|       |
  122|  9.79M|   return a;
  123|       |
  124|       |#elif defined(BOTAN_MP_DWORD)
  125|       |   const BOTAN_MP_DWORD s = static_cast<BOTAN_MP_DWORD>(a) * b + c + *d;
  126|       |   *d = static_cast<word>(s >> BOTAN_MP_WORD_BITS);
  127|       |   return static_cast<word>(s);
  128|       |#else
  129|       |   static_assert(BOTAN_MP_WORD_BITS == 64, "Unexpected word size");
  130|       |
  131|       |   word hi = 0, lo = 0;
  132|       |
  133|       |   mul64x64_128(a, b, &lo, &hi);
  134|       |
  135|       |   lo += c;
  136|       |   hi += (lo < c);  // carry?
  137|       |
  138|       |   lo += *d;
  139|       |   hi += (lo < *d);  // carry?
  140|       |
  141|       |   *d = hi;
  142|       |   return lo;
  143|       |#endif
  144|  9.79M|}
_ZN5Botan10word8_add2EPmPKmm:
  265|  54.4k|inline word word8_add2(word x[8], const word y[8], word carry) {
  266|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  267|       |   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcl"))
  268|       |       : [carry] "=r"(carry)
  269|       |       : [x] "r"(x), [y] "r"(y), "0"(carry)
  270|       |       : "cc", "memory");
  271|       |
  272|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  273|       |
  274|  54.4k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcq"))
  275|  54.4k|       : [carry] "=r"(carry)
  276|  54.4k|       : [x] "r"(x), [y] "r"(y), "0"(carry)
  277|  54.4k|       : "cc", "memory");
  278|       |
  279|       |#else
  280|       |   x[0] = word_add(x[0], y[0], &carry);
  281|       |   x[1] = word_add(x[1], y[1], &carry);
  282|       |   x[2] = word_add(x[2], y[2], &carry);
  283|       |   x[3] = word_add(x[3], y[3], &carry);
  284|       |   x[4] = word_add(x[4], y[4], &carry);
  285|       |   x[5] = word_add(x[5], y[5], &carry);
  286|       |   x[6] = word_add(x[6], y[6], &carry);
  287|       |   x[7] = word_add(x[7], y[7], &carry);
  288|       |#endif
  289|       |
  290|  54.4k|   return carry;
  291|  54.4k|}
_ZN5Botan10word8_sub2EPmPKmm:
  353|  24.9k|inline word word8_sub2(word x[8], const word y[8], word carry) {
  354|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  355|       |   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbl"))
  356|       |       : [carry] "=r"(carry)
  357|       |       : [x] "r"(x), [y] "r"(y), "0"(carry)
  358|       |       : "cc", "memory");
  359|       |
  360|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  361|  24.9k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbq"))
  362|  24.9k|       : [carry] "=r"(carry)
  363|  24.9k|       : [x] "r"(x), [y] "r"(y), "0"(carry)
  364|  24.9k|       : "cc", "memory");
  365|       |
  366|       |#else
  367|       |   x[0] = word_sub(x[0], y[0], &carry);
  368|       |   x[1] = word_sub(x[1], y[1], &carry);
  369|       |   x[2] = word_sub(x[2], y[2], &carry);
  370|       |   x[3] = word_sub(x[3], y[3], &carry);
  371|       |   x[4] = word_sub(x[4], y[4], &carry);
  372|       |   x[5] = word_sub(x[5], y[5], &carry);
  373|       |   x[6] = word_sub(x[6], y[6], &carry);
  374|       |   x[7] = word_sub(x[7], y[7], &carry);
  375|       |#endif
  376|       |
  377|  24.9k|   return carry;
  378|  24.9k|}
_ZN5Botan14word8_sub2_revEPmPKmm:
  383|    619|inline word word8_sub2_rev(word x[8], const word y[8], word carry) {
  384|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  385|       |   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbl"))
  386|       |       : [carry] "=r"(carry)
  387|       |       : [x] "r"(y), [y] "r"(x), [z] "r"(x), "0"(carry)
  388|       |       : "cc", "memory");
  389|       |
  390|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  391|    619|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
  392|    619|       : [carry] "=r"(carry)
  393|    619|       : [x] "r"(y), [y] "r"(x), [z] "r"(x), "0"(carry)
  394|    619|       : "cc", "memory");
  395|       |
  396|       |#else
  397|       |   x[0] = word_sub(y[0], x[0], &carry);
  398|       |   x[1] = word_sub(y[1], x[1], &carry);
  399|       |   x[2] = word_sub(y[2], x[2], &carry);
  400|       |   x[3] = word_sub(y[3], x[3], &carry);
  401|       |   x[4] = word_sub(y[4], x[4], &carry);
  402|       |   x[5] = word_sub(y[5], x[5], &carry);
  403|       |   x[6] = word_sub(y[6], x[6], &carry);
  404|       |   x[7] = word_sub(y[7], x[7], &carry);
  405|       |#endif
  406|       |
  407|    619|   return carry;
  408|    619|}
_ZN5Botan13word8_linmul2EPmmm:
  443|  16.8M|inline word word8_linmul2(word x[8], word y, word carry) {
  444|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  445|       |   asm(DO_8_TIMES(LINMUL_OP, "x") : [carry] "=r"(carry) : [x] "r"(x), [y] "rm"(y), "0"(carry) : "cc", "%eax", "%edx");
  446|       |
  447|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  448|  16.8M|   asm(DO_8_TIMES(LINMUL_OP, "x") : [carry] "=r"(carry) : [x] "r"(x), [y] "rm"(y), "0"(carry) : "cc", "%rax", "%rdx");
  449|       |
  450|       |#else
  451|       |   x[0] = word_madd2(x[0], y, &carry);
  452|       |   x[1] = word_madd2(x[1], y, &carry);
  453|       |   x[2] = word_madd2(x[2], y, &carry);
  454|       |   x[3] = word_madd2(x[3], y, &carry);
  455|       |   x[4] = word_madd2(x[4], y, &carry);
  456|       |   x[5] = word_madd2(x[5], y, &carry);
  457|       |   x[6] = word_madd2(x[6], y, &carry);
  458|       |   x[7] = word_madd2(x[7], y, &carry);
  459|       |#endif
  460|       |
  461|  16.8M|   return carry;
  462|  16.8M|}
_ZN5Botan13word8_linmul3EPmPKmmm:
  467|  3.88k|inline word word8_linmul3(word z[8], const word x[8], word y, word carry) {
  468|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  469|       |   asm(DO_8_TIMES(LINMUL_OP, "z")
  470|       |       : [carry] "=r"(carry)
  471|       |       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  472|       |       : "cc", "%eax", "%edx");
  473|       |
  474|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  475|  3.88k|   asm(DO_8_TIMES(LINMUL_OP, "z")
  476|  3.88k|       : [carry] "=r"(carry)
  477|  3.88k|       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  478|  3.88k|       : "cc", "%rax", "%rdx");
  479|       |
  480|       |#else
  481|       |   z[0] = word_madd2(x[0], y, &carry);
  482|       |   z[1] = word_madd2(x[1], y, &carry);
  483|       |   z[2] = word_madd2(x[2], y, &carry);
  484|       |   z[3] = word_madd2(x[3], y, &carry);
  485|       |   z[4] = word_madd2(x[4], y, &carry);
  486|       |   z[5] = word_madd2(x[5], y, &carry);
  487|       |   z[6] = word_madd2(x[6], y, &carry);
  488|       |   z[7] = word_madd2(x[7], y, &carry);
  489|       |#endif
  490|       |
  491|  3.88k|   return carry;
  492|  3.88k|}
_ZN5Botan11word8_madd3EPmPKmmm:
  497|  4.76M|inline word word8_madd3(word z[8], const word x[8], word y, word carry) {
  498|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  499|       |   asm(DO_8_TIMES(MULADD_OP, "")
  500|       |       : [carry] "=r"(carry)
  501|       |       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  502|       |       : "cc", "%eax", "%edx");
  503|       |
  504|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  505|  4.76M|   asm(DO_8_TIMES(MULADD_OP, "")
  506|  4.76M|       : [carry] "=r"(carry)
  507|  4.76M|       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  508|  4.76M|       : "cc", "%rax", "%rdx");
  509|       |
  510|       |#else
  511|       |   z[0] = word_madd3(x[0], y, z[0], &carry);
  512|       |   z[1] = word_madd3(x[1], y, z[1], &carry);
  513|       |   z[2] = word_madd3(x[2], y, z[2], &carry);
  514|       |   z[3] = word_madd3(x[3], y, z[3], &carry);
  515|       |   z[4] = word_madd3(x[4], y, z[4], &carry);
  516|       |   z[5] = word_madd3(x[5], y, z[5], &carry);
  517|       |   z[6] = word_madd3(x[6], y, z[6], &carry);
  518|       |   z[7] = word_madd3(x[7], y, z[7], &carry);
  519|       |#endif
  520|       |
  521|  4.76M|   return carry;
  522|  4.76M|}
_ZN5Botan12word3_muladdEPmS0_S0_mm:
  528|  90.0M|inline void word3_muladd(word* w2, word* w1, word* w0, word x, word y) {
  529|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  530|       |   word z0 = 0, z1 = 0;
  531|       |
  532|       |   asm("mull %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  533|       |
  534|       |   asm(R"(
  535|       |       addl %[z0],%[w0]
  536|       |       adcl %[z1],%[w1]
  537|       |       adcl $0,%[w2]
  538|       |       )"
  539|       |       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  540|       |       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  541|       |       : "cc");
  542|       |
  543|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  544|  90.0M|   word z0 = 0, z1 = 0;
  545|       |
  546|  90.0M|   asm("mulq %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  547|       |
  548|  90.0M|   asm(R"(
  549|  90.0M|       addq %[z0],%[w0]
  550|  90.0M|       adcq %[z1],%[w1]
  551|  90.0M|       adcq $0,%[w2]
  552|  90.0M|       )"
  553|  90.0M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  554|  90.0M|       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  555|  90.0M|       : "cc");
  556|       |
  557|       |#else
  558|       |   word carry = *w0;
  559|       |   *w0 = word_madd2(x, y, &carry);
  560|       |   *w1 += carry;
  561|       |   *w2 += (*w1 < carry);
  562|       |#endif
  563|  90.0M|}
_ZN5Botan9word3_addEPmS0_S0_m:
  569|  8.35M|inline void word3_add(word* w2, word* w1, word* w0, word x) {
  570|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  571|       |   asm(R"(
  572|       |      addl %[x],%[w0]
  573|       |      adcl $0,%[w1]
  574|       |      adcl $0,%[w2]
  575|       |      )"
  576|       |       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  577|       |       : [x] "r"(x), "0"(*w0), "1"(*w1), "2"(*w2)
  578|       |       : "cc");
  579|       |
  580|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  581|  8.35M|   asm(R"(
  582|  8.35M|      addq %[x],%[w0]
  583|  8.35M|      adcq $0,%[w1]
  584|  8.35M|      adcq $0,%[w2]
  585|  8.35M|      )"
  586|  8.35M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  587|  8.35M|       : [x] "r"(x), "0"(*w0), "1"(*w1), "2"(*w2)
  588|  8.35M|       : "cc");
  589|       |
  590|       |#else
  591|       |   *w0 += x;
  592|       |   word c1 = (*w0 < x);
  593|       |   *w1 += c1;
  594|       |   word c2 = (*w1 < c1);
  595|       |   *w2 += c2;
  596|       |#endif
  597|  8.35M|}
_ZN5Botan14word3_muladd_2EPmS0_S0_mm:
  603|  10.0M|inline void word3_muladd_2(word* w2, word* w1, word* w0, word x, word y) {
  604|       |#if defined(BOTAN_MP_USE_X86_32_ASM)
  605|       |   word z0 = 0, z1 = 0;
  606|       |
  607|       |   asm("mull %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  608|       |
  609|       |   asm(R"(
  610|       |      addl %[z0],%[w0]
  611|       |      adcl %[z1],%[w1]
  612|       |      adcl $0,%[w2]
  613|       |
  614|       |      addl %[z0],%[w0]
  615|       |      adcl %[z1],%[w1]
  616|       |      adcl $0,%[w2]
  617|       |      )"
  618|       |       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  619|       |       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  620|       |       : "cc");
  621|       |
  622|       |#elif defined(BOTAN_MP_USE_X86_64_ASM)
  623|  10.0M|   word z0 = 0, z1 = 0;
  624|       |
  625|  10.0M|   asm("mulq %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  626|       |
  627|  10.0M|   asm(R"(
  628|  10.0M|      addq %[z0],%[w0]
  629|  10.0M|      adcq %[z1],%[w1]
  630|  10.0M|      adcq $0,%[w2]
  631|  10.0M|
  632|  10.0M|      addq %[z0],%[w0]
  633|  10.0M|      adcq %[z1],%[w1]
  634|  10.0M|      adcq $0,%[w2]
  635|  10.0M|      )"
  636|  10.0M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  637|  10.0M|       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  638|  10.0M|       : "cc");
  639|       |
  640|       |#else
  641|       |   word carry = 0;
  642|       |   x = word_madd2(x, y, &carry);
  643|       |   y = carry;
  644|       |
  645|       |   word top = (y >> (BOTAN_MP_WORD_BITS - 1));
  646|       |   y <<= 1;
  647|       |   y |= (x >> (BOTAN_MP_WORD_BITS - 1));
  648|       |   x <<= 1;
  649|       |
  650|       |   carry = 0;
  651|       |   *w0 = word_add(*w0, x, &carry);
  652|       |   *w1 = word_add(*w1, y, &carry);
  653|       |   *w2 = word_add(*w2, top, &carry);
  654|       |#endif
  655|  10.0M|}

_ZN5Botan10bigint_cmpEPKmmS1_m:
  490|  10.6k|inline int32_t bigint_cmp(const word x[], size_t x_size, const word y[], size_t y_size) {
  491|  10.6k|   static_assert(sizeof(word) >= sizeof(uint32_t), "Size assumption");
  492|       |
  493|  10.6k|   const word LT = static_cast<word>(-1);
  494|  10.6k|   const word EQ = 0;
  495|  10.6k|   const word GT = 1;
  496|       |
  497|  10.6k|   const size_t common_elems = std::min(x_size, y_size);
  498|       |
  499|  10.6k|   word result = EQ;  // until found otherwise
  500|       |
  501|   205k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (501:22): [True: 194k, False: 10.6k]
  ------------------
  502|   194k|      const auto is_eq = CT::Mask<word>::is_equal(x[i], y[i]);
  503|   194k|      const auto is_lt = CT::Mask<word>::is_lt(x[i], y[i]);
  504|       |
  505|   194k|      result = is_eq.select(result, is_lt.select(LT, GT));
  506|   194k|   }
  507|       |
  508|  10.6k|   if(x_size < y_size) {
  ------------------
  |  Branch (508:7): [True: 6.90k, False: 3.75k]
  ------------------
  509|  6.90k|      word mask = 0;
  510|  76.4k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (510:30): [True: 69.4k, False: 6.90k]
  ------------------
  511|  69.4k|         mask |= y[i];
  512|  69.4k|      }
  513|       |
  514|       |      // If any bits were set in high part of y, then x < y
  515|  6.90k|      result = CT::Mask<word>::is_zero(mask).select(result, LT);
  516|  6.90k|   } else if(y_size < x_size) {
  ------------------
  |  Branch (516:14): [True: 0, False: 3.75k]
  ------------------
  517|      0|      word mask = 0;
  518|      0|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (518:30): [True: 0, False: 0]
  ------------------
  519|      0|         mask |= x[i];
  520|      0|      }
  521|       |
  522|       |      // If any bits were set in high part of x, then x > y
  523|      0|      result = CT::Mask<word>::is_zero(mask).select(result, GT);
  524|      0|   }
  525|       |
  526|  10.6k|   CT::unpoison(result);
  527|  10.6k|   BOTAN_DEBUG_ASSERT(result == LT || result == GT || result == EQ);
  ------------------
  |  |   99|  10.6k|      do {                          \
  |  |  100|  10.6k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  528|  10.6k|   return static_cast<int32_t>(result);
  529|  10.6k|}
_ZN5Botan15bigint_ct_is_ltEPKmmS1_mb:
  537|  2.73k|   const word x[], size_t x_size, const word y[], size_t y_size, bool lt_or_equal = false) {
  538|  2.73k|   const size_t common_elems = std::min(x_size, y_size);
  539|       |
  540|  2.73k|   auto is_lt = CT::Mask<word>::expand(lt_or_equal);
  541|       |
  542|  7.98k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (542:22): [True: 5.24k, False: 2.73k]
  ------------------
  543|  5.24k|      const auto eq = CT::Mask<word>::is_equal(x[i], y[i]);
  544|  5.24k|      const auto lt = CT::Mask<word>::is_lt(x[i], y[i]);
  545|  5.24k|      is_lt = eq.select_mask(is_lt, lt);
  546|  5.24k|   }
  547|       |
  548|  2.73k|   if(x_size < y_size) {
  ------------------
  |  Branch (548:7): [True: 2.58k, False: 148]
  ------------------
  549|  2.58k|      word mask = 0;
  550|  56.4k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (550:30): [True: 53.8k, False: 2.58k]
  ------------------
  551|  53.8k|         mask |= y[i];
  552|  53.8k|      }
  553|       |      // If any bits were set in high part of y, then is_lt should be forced true
  554|  2.58k|      is_lt |= CT::Mask<word>::expand(mask);
  555|  2.58k|   } else if(y_size < x_size) {
  ------------------
  |  Branch (555:14): [True: 0, False: 148]
  ------------------
  556|      0|      word mask = 0;
  557|      0|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (557:30): [True: 0, False: 0]
  ------------------
  558|      0|         mask |= x[i];
  559|      0|      }
  560|       |
  561|       |      // If any bits were set in high part of x, then is_lt should be false
  562|      0|      is_lt &= CT::Mask<word>::is_zero(mask);
  563|      0|   }
  564|       |
  565|  2.73k|   return is_lt;
  566|  2.73k|}
_ZN5Botan11bigint_sub3EPmPKmmS2_m:
  321|  4.40M|inline word bigint_sub3(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  322|  4.40M|   word borrow = 0;
  323|       |
  324|  4.40M|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  4.40M|   do {                                                                                 \
  |  |   52|  4.40M|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 4.40M]
  |  |  ------------------
  |  |   53|  4.40M|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  4.40M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  325|       |
  326|  4.40M|   const size_t blocks = y_size - (y_size % 8);
  327|       |
  328|  17.7M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (328:22): [True: 13.3M, False: 4.40M]
  ------------------
  329|  13.3M|      borrow = word8_sub3(z + i, x + i, y + i, borrow);
  330|  13.3M|   }
  331|       |
  332|  14.3M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (332:27): [True: 9.97M, False: 4.40M]
  ------------------
  333|  9.97M|      z[i] = word_sub(x[i], y[i], &borrow);
  334|  9.97M|   }
  335|       |
  336|  27.5M|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (336:27): [True: 23.1M, False: 4.40M]
  ------------------
  337|  23.1M|      z[i] = word_sub(x[i], 0, &borrow);
  338|  23.1M|   }
  339|       |
  340|  4.40M|   return borrow;
  341|  4.40M|}
_ZN5Botan15bigint_cnd_swapEmPmS0_m:
   29|  3.94M|inline void bigint_cnd_swap(word cnd, word x[], word y[], size_t size) {
   30|  3.94M|   const auto mask = CT::Mask<word>::expand(cnd);
   31|       |
   32|   138M|   for(size_t i = 0; i != size; ++i) {
  ------------------
  |  Branch (32:22): [True: 134M, False: 3.94M]
  ------------------
   33|   134M|      const word a = x[i];
   34|   134M|      const word b = y[i];
   35|   134M|      x[i] = mask.select(b, a);
   36|   134M|      y[i] = mask.select(a, b);
   37|   134M|   }
   38|  3.94M|}
_ZN5Botan21bigint_cnd_add_or_subENS_2CT4MaskImEEPmPKmm:
  123|  4.76k|inline void bigint_cnd_add_or_sub(CT::Mask<word> mask, word x[], const word y[], size_t size) {
  124|  4.76k|   const size_t blocks = size - (size % 8);
  125|       |
  126|  4.76k|   word carry = 0;
  127|  4.76k|   word borrow = 0;
  128|       |
  129|  4.76k|   word t0[8] = {0};
  130|  4.76k|   word t1[8] = {0};
  131|       |
  132|  33.3k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (132:22): [True: 28.5k, False: 4.76k]
  ------------------
  133|  28.5k|      carry = word8_add3(t0, x + i, y + i, carry);
  134|  28.5k|      borrow = word8_sub3(t1, x + i, y + i, borrow);
  135|       |
  136|   257k|      for(size_t j = 0; j != 8; ++j) {
  ------------------
  |  Branch (136:25): [True: 228k, False: 28.5k]
  ------------------
  137|   228k|         x[i + j] = mask.select(t0[j], t1[j]);
  138|   228k|      }
  139|  28.5k|   }
  140|       |
  141|  6.39k|   for(size_t i = blocks; i != size; ++i) {
  ------------------
  |  Branch (141:27): [True: 1.62k, False: 4.76k]
  ------------------
  142|  1.62k|      const word a = word_add(x[i], y[i], &carry);
  143|  1.62k|      const word s = word_sub(x[i], y[i], &borrow);
  144|       |
  145|  1.62k|      x[i] = mask.select(a, s);
  146|  1.62k|   }
  147|  4.76k|}
_ZN5Botan14bigint_add2_ncEPmmPKmm:
  203|  37.2k|inline word bigint_add2_nc(word x[], size_t x_size, const word y[], size_t y_size) {
  204|  37.2k|   word carry = 0;
  205|       |
  206|  37.2k|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  37.2k|   do {                                                                                 \
  |  |   52|  37.2k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 37.2k]
  |  |  ------------------
  |  |   53|  37.2k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  37.2k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  207|       |
  208|  37.2k|   const size_t blocks = y_size - (y_size % 8);
  209|       |
  210|  91.6k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (210:22): [True: 54.4k, False: 37.2k]
  ------------------
  211|  54.4k|      carry = word8_add2(x + i, y + i, carry);
  212|  54.4k|   }
  213|       |
  214|  72.4k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (214:27): [True: 35.2k, False: 37.2k]
  ------------------
  215|  35.2k|      x[i] = word_add(x[i], y[i], &carry);
  216|  35.2k|   }
  217|       |
  218|   370k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (218:27): [True: 333k, False: 37.2k]
  ------------------
  219|   333k|      x[i] = word_add(x[i], 0, &carry);
  220|   333k|   }
  221|       |
  222|  37.2k|   return carry;
  223|  37.2k|}
_ZN5Botan14bigint_add3_ncEPmPKmmS2_m:
  228|  11.0k|inline word bigint_add3_nc(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  229|  11.0k|   if(x_size < y_size) {
  ------------------
  |  Branch (229:7): [True: 0, False: 11.0k]
  ------------------
  230|      0|      return bigint_add3_nc(z, y, y_size, x, x_size);
  231|      0|   }
  232|       |
  233|  11.0k|   word carry = 0;
  234|       |
  235|  11.0k|   const size_t blocks = y_size - (y_size % 8);
  236|       |
  237|  55.0k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (237:22): [True: 44.0k, False: 11.0k]
  ------------------
  238|  44.0k|      carry = word8_add3(z + i, x + i, y + i, carry);
  239|  44.0k|   }
  240|       |
  241|  12.0k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (241:27): [True: 1.08k, False: 11.0k]
  ------------------
  242|  1.08k|      z[i] = word_add(x[i], y[i], &carry);
  243|  1.08k|   }
  244|       |
  245|  11.0k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (245:27): [True: 0, False: 11.0k]
  ------------------
  246|      0|      z[i] = word_add(x[i], 0, &carry);
  247|      0|   }
  248|       |
  249|  11.0k|   return carry;
  250|  11.0k|}
_ZN5Botan11bigint_add2EPmmPKmm:
  259|  4.20k|inline void bigint_add2(word x[], size_t x_size, const word y[], size_t y_size) {
  260|  4.20k|   x[x_size] += bigint_add2_nc(x, x_size, y, y_size);
  261|  4.20k|}
_ZN5Botan11bigint_sub2EPmmPKmm:
  273|  6.23k|inline word bigint_sub2(word x[], size_t x_size, const word y[], size_t y_size) {
  274|  6.23k|   word borrow = 0;
  275|       |
  276|  6.23k|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  6.23k|   do {                                                                                 \
  |  |   52|  6.23k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 6.23k]
  |  |  ------------------
  |  |   53|  6.23k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  6.23k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  277|       |
  278|  6.23k|   const size_t blocks = y_size - (y_size % 8);
  279|       |
  280|  31.1k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (280:22): [True: 24.9k, False: 6.23k]
  ------------------
  281|  24.9k|      borrow = word8_sub2(x + i, y + i, borrow);
  282|  24.9k|   }
  283|       |
  284|  6.23k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (284:27): [True: 0, False: 6.23k]
  ------------------
  285|      0|      x[i] = word_sub(x[i], y[i], &borrow);
  286|      0|   }
  287|       |
  288|   106k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (288:27): [True: 99.8k, False: 6.23k]
  ------------------
  289|  99.8k|      x[i] = word_sub(x[i], 0, &borrow);
  290|  99.8k|   }
  291|       |
  292|  6.23k|   return borrow;
  293|  6.23k|}
_ZN5Botan15bigint_sub2_revEPmPKmm:
  298|    169|inline void bigint_sub2_rev(word x[], const word y[], size_t y_size) {
  299|    169|   word borrow = 0;
  300|       |
  301|    169|   const size_t blocks = y_size - (y_size % 8);
  302|       |
  303|    788|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (303:22): [True: 619, False: 169]
  ------------------
  304|    619|      borrow = word8_sub2_rev(x + i, y + i, borrow);
  305|    619|   }
  306|       |
  307|    367|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (307:27): [True: 198, False: 169]
  ------------------
  308|    198|      x[i] = word_sub(y[i], x[i], &borrow);
  309|    198|   }
  310|       |
  311|    169|   BOTAN_ASSERT(borrow == 0, "y must be greater than x");
  ------------------
  |  |   51|    169|   do {                                                                                 \
  |  |   52|    169|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 169]
  |  |  ------------------
  |  |   53|    169|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|    169|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  312|    169|}
_ZN5Botan14bigint_sub_absEPmPKmS2_mS0_:
  355|  15.7k|inline CT::Mask<word> bigint_sub_abs(word z[], const word x[], const word y[], size_t N, word ws[]) {
  356|       |   // Subtract in both direction then conditional copy out the result
  357|       |
  358|  15.7k|   word* ws0 = ws;
  359|  15.7k|   word* ws1 = ws + N;
  360|       |
  361|  15.7k|   word borrow0 = 0;
  362|  15.7k|   word borrow1 = 0;
  363|       |
  364|  15.7k|   const size_t blocks = N - (N % 8);
  365|       |
  366|  47.3k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (366:22): [True: 31.5k, False: 15.7k]
  ------------------
  367|  31.5k|      borrow0 = word8_sub3(ws0 + i, x + i, y + i, borrow0);
  368|  31.5k|      borrow1 = word8_sub3(ws1 + i, y + i, x + i, borrow1);
  369|  31.5k|   }
  370|       |
  371|  16.8k|   for(size_t i = blocks; i != N; ++i) {
  ------------------
  |  Branch (371:27): [True: 1.08k, False: 15.7k]
  ------------------
  372|  1.08k|      ws0[i] = word_sub(x[i], y[i], &borrow0);
  373|  1.08k|      ws1[i] = word_sub(y[i], x[i], &borrow1);
  374|  1.08k|   }
  375|       |
  376|  15.7k|   return CT::conditional_copy_mem(borrow0, z, ws1, ws0, N);
  377|  15.7k|}
_ZN5Botan11bigint_shr1EPmmmm:
  397|  8.74k|inline void bigint_shr1(word x[], size_t x_size, size_t word_shift, size_t bit_shift) {
  398|  8.74k|   const size_t top = x_size >= word_shift ? (x_size - word_shift) : 0;
  ------------------
  |  Branch (398:23): [True: 8.54k, False: 201]
  ------------------
  399|       |
  400|  8.74k|   if(top > 0) {
  ------------------
  |  Branch (400:7): [True: 8.53k, False: 209]
  ------------------
  401|  8.53k|      copy_mem(x, x + word_shift, top);
  402|  8.53k|   }
  403|  8.74k|   clear_mem(x + top, std::min(word_shift, x_size));
  404|       |
  405|  8.74k|   const auto carry_mask = CT::Mask<word>::expand(bit_shift);
  406|  8.74k|   const word carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);
  ------------------
  |  |   50|  8.74k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  407|       |
  408|  8.74k|   word carry = 0;
  409|       |
  410|   183k|   for(size_t i = 0; i != top; ++i) {
  ------------------
  |  Branch (410:22): [True: 174k, False: 8.74k]
  ------------------
  411|   174k|      const word w = x[top - i - 1];
  412|   174k|      x[top - i - 1] = (w >> bit_shift) | carry;
  413|   174k|      carry = carry_mask.if_set_return(w << carry_shift);
  414|   174k|   }
  415|  8.74k|}
_ZN5Botan14bigint_linmul2EPmmm:
  452|  3.93M|[[nodiscard]] inline word bigint_linmul2(word x[], size_t x_size, word y) {
  453|  3.93M|   const size_t blocks = x_size - (x_size % 8);
  454|       |
  455|  3.93M|   word carry = 0;
  456|       |
  457|  20.7M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (457:22): [True: 16.8M, False: 3.93M]
  ------------------
  458|  16.8M|      carry = word8_linmul2(x + i, y, carry);
  459|  16.8M|   }
  460|       |
  461|  3.93M|   for(size_t i = blocks; i != x_size; ++i) {
  ------------------
  |  Branch (461:27): [True: 0, False: 3.93M]
  ------------------
  462|      0|      x[i] = word_madd2(x[i], y, &carry);
  463|      0|   }
  464|       |
  465|  3.93M|   return carry;
  466|  3.93M|}
_ZN5Botan14bigint_linmul3EPmPKmmm:
  468|  96.4k|inline void bigint_linmul3(word z[], const word x[], size_t x_size, word y) {
  469|  96.4k|   const size_t blocks = x_size - (x_size % 8);
  470|       |
  471|  96.4k|   word carry = 0;
  472|       |
  473|   100k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (473:22): [True: 3.88k, False: 96.4k]
  ------------------
  474|  3.88k|      carry = word8_linmul3(z + i, x + i, y, carry);
  475|  3.88k|   }
  476|       |
  477|   195k|   for(size_t i = blocks; i != x_size; ++i) {
  ------------------
  |  Branch (477:27): [True: 99.4k, False: 96.4k]
  ------------------
  478|  99.4k|      z[i] = word_madd2(x[i], y, &carry);
  479|  99.4k|   }
  480|       |
  481|  96.4k|   z[x_size] = carry;
  482|  96.4k|}
_ZN5Botan14bigint_sub_absEPmPKmmS2_m:
  604|  8.74k|inline int32_t bigint_sub_abs(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  605|  8.74k|   const int32_t relative_size = bigint_cmp(x, x_size, y, y_size);
  606|       |
  607|       |   // Swap if relative_size == -1
  608|  8.74k|   const bool need_swap = relative_size < 0;
  609|  8.74k|   CT::conditional_swap_ptr(need_swap, x, y);
  610|  8.74k|   CT::conditional_swap(need_swap, x_size, y_size);
  611|       |
  612|       |   /*
  613|       |   * We know at this point that x >= y so if y_size is larger than
  614|       |   * x_size, we are guaranteed they are just leading zeros which can
  615|       |   * be ignored
  616|       |   */
  617|  8.74k|   y_size = std::min(x_size, y_size);
  618|       |
  619|  8.74k|   bigint_sub3(z, x, x_size, y, y_size);
  620|       |
  621|  8.74k|   return relative_size;
  622|  8.74k|}
_ZN5Botan17bigint_monty_redcEPmPKmmmS0_m:
  757|   450k|inline void bigint_monty_redc(word z[], const word p[], size_t p_size, word p_dash, word ws[], size_t ws_size) {
  758|   450k|   const size_t z_size = 2 * p_size;
  759|       |
  760|   450k|   BOTAN_ARG_CHECK(ws_size >= p_size + 1, "Montgomery workspace too small");
  ------------------
  |  |   30|   450k|   do {                                                          \
  |  |   31|   450k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 450k]
  |  |  ------------------
  |  |   32|   450k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|   450k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  761|       |
  762|   450k|   if(p_size == 4) {
  ------------------
  |  Branch (762:7): [True: 32.4k, False: 417k]
  ------------------
  763|  32.4k|      bigint_monty_redc_4(z, p, p_dash, ws);
  764|   417k|   } else if(p_size == 6) {
  ------------------
  |  Branch (764:14): [True: 16.0k, False: 401k]
  ------------------
  765|  16.0k|      bigint_monty_redc_6(z, p, p_dash, ws);
  766|   401k|   } else if(p_size == 8) {
  ------------------
  |  Branch (766:14): [True: 45.8k, False: 355k]
  ------------------
  767|  45.8k|      bigint_monty_redc_8(z, p, p_dash, ws);
  768|   355k|   } else if(p_size == 16) {
  ------------------
  |  Branch (768:14): [True: 58.1k, False: 297k]
  ------------------
  769|  58.1k|      bigint_monty_redc_16(z, p, p_dash, ws);
  770|   297k|   } else if(p_size == 24) {
  ------------------
  |  Branch (770:14): [True: 5.01k, False: 292k]
  ------------------
  771|  5.01k|      bigint_monty_redc_24(z, p, p_dash, ws);
  772|   292k|   } else if(p_size == 32) {
  ------------------
  |  Branch (772:14): [True: 10.1k, False: 282k]
  ------------------
  773|  10.1k|      bigint_monty_redc_32(z, p, p_dash, ws);
  774|   282k|   } else {
  775|   282k|      bigint_monty_redc_generic(z, z_size, p, p_size, p_dash, ws);
  776|   282k|   }
  777|   450k|}

_ZN5Botan10PSS_ParamsC2INSt3__19allocatorIhEEEERKNS2_6vectorIhT_EE:
   25|      3|      PSS_Params(const std::vector<uint8_t, Alloc>& vec) : PSS_Params(vec.data(), vec.size()) {}

_ZN5Botan4rotlILm7EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm11EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm5EjEET0_S1_:
   23|  5.32M|{
   24|  5.32M|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  5.32M|}
_ZN5Botan4rotlILm9EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm15EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm12EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm17EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm22EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm14EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm20EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm4EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm16EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm23EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm6EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm10EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm21EjEET0_S1_:
   23|  62.5k|{
   24|  62.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  62.5k|}
_ZN5Botan4rotlILm30EjEET0_S1_:
   23|  5.26M|{
   24|  5.26M|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  5.26M|}
_ZN5Botan3rhoILm2ELm13ELm22EjEET2_S1_:
   51|  3.92M|inline constexpr T rho(T x) {
   52|  3.92M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  3.92M|}
_ZN5Botan4rotrILm2EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm13EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm22EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan3rhoILm6ELm11ELm25EjEET2_S1_:
   51|  3.92M|inline constexpr T rho(T x) {
   52|  3.92M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  3.92M|}
_ZN5Botan4rotrILm6EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm11EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm25EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan5sigmaILm17ELm19ELm10EjEET2_S1_:
   43|  3.92M|inline constexpr T sigma(T x) {
   44|  3.92M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  3.92M|}
_ZN5Botan4rotrILm17EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm19EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan5sigmaILm7ELm18ELm3EjEET2_S1_:
   43|  3.92M|inline constexpr T sigma(T x) {
   44|  3.92M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  3.92M|}
_ZN5Botan4rotrILm7EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan4rotrILm18EjEET0_S1_:
   35|  3.92M|{
   36|  3.92M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  3.92M|}
_ZN5Botan3rhoILm14ELm18ELm41EmEET2_S1_:
   51|  28.8k|inline constexpr T rho(T x) {
   52|  28.8k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  28.8k|}
_ZN5Botan4rotrILm14EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm18EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm41EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan3rhoILm28ELm34ELm39EmEET2_S1_:
   51|  28.8k|inline constexpr T rho(T x) {
   52|  28.8k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  28.8k|}
_ZN5Botan4rotrILm28EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm34EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm39EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan5sigmaILm19ELm61ELm6EmEET2_S1_:
   43|  28.8k|inline constexpr T sigma(T x) {
   44|  28.8k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  28.8k|}
_ZN5Botan4rotrILm19EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm61EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan5sigmaILm1ELm8ELm7EmEET2_S1_:
   43|  28.8k|inline constexpr T sigma(T x) {
   44|  28.8k|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  28.8k|}
_ZN5Botan4rotrILm1EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}
_ZN5Botan4rotrILm8EmEET0_S1_:
   35|  28.8k|{
   36|  28.8k|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  28.8k|}

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

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

_ZNK5Botan9SCAN_Name9algo_nameEv:
   44|  5.79k|      const std::string& algo_name() const { return m_alg_name; }
_ZNK5Botan9SCAN_Name9arg_countEv:
   49|  5.78k|      size_t arg_count() const { return m_args.size(); }

_ZNK5Botan5SHA_14nameEv:
   32|      1|      std::string name() const override { return "SHA-1"; }
_ZNK5Botan5SHA_113output_lengthEv:
   34|  6.77k|      size_t output_length() const override { return 20; }

_ZNK5Botan7SHA_2244nameEv:
   33|     32|      std::string name() const override { return "SHA-224"; }
_ZNK5Botan7SHA_22413output_lengthEv:
   35|     52|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan7SHA_2564nameEv:
   73|    145|      std::string name() const override { return "SHA-256"; }
_ZNK5Botan7SHA_25613output_lengthEv:
   75|  10.3k|      size_t output_length() const override { return output_bytes; }

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

_ZNK5Botan7SHA_3844nameEv:
   32|     42|      std::string name() const override { return "SHA-384"; }
_ZNK5Botan7SHA_38413output_lengthEv:
   34|     81|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan7SHA_5124nameEv:
   72|      9|      std::string name() const override { return "SHA-512"; }
_ZNK5Botan7SHA_51213output_lengthEv:
   74|     17|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan11SHA_512_2564nameEv:
  123|      2|      std::string name() const override { return "SHA-512-256"; }
_ZNK5Botan11SHA_512_25613output_lengthEv:
  125|      3|      size_t output_length() const override { return output_bytes; }

_ZN5Botan9SHA2_64_FEmmmRmmmmS0_S0_mmmm:
   31|  28.8k|                                  uint64_t magic) {
   32|  28.8k|   const uint64_t E_rho = rho<14, 18, 41>(E);
   33|  28.8k|   const uint64_t A_rho = rho<28, 34, 39>(A);
   34|  28.8k|   const uint64_t M2_sigma = sigma<19, 61, 6>(M2);
   35|  28.8k|   const uint64_t M4_sigma = sigma<1, 8, 7>(M4);
   36|  28.8k|   H += magic + E_rho + choose(E, F, G) + M1;
   37|  28.8k|   D += H;
   38|  28.8k|   H += A_rho + majority(A, B, C);
   39|  28.8k|   M1 += M2_sigma + M3 + M4_sigma;
   40|  28.8k|}

_ZN5Botan9SIMD_4x325splatEj:
  129|  55.4k|      static SIMD_4x32 splat(uint32_t B) noexcept {
  130|  55.4k|#if defined(BOTAN_SIMD_USE_SSE2)
  131|  55.4k|         return SIMD_4x32(_mm_set1_epi32(B));
  132|       |#elif defined(BOTAN_SIMD_USE_NEON)
  133|       |         return SIMD_4x32(vdupq_n_u32(B));
  134|       |#else
  135|       |         return SIMD_4x32(B, B, B, B);
  136|       |#endif
  137|  55.4k|      }
_ZN5Botan9SIMD_4x32C2EDv2_x:
  597|  6.89M|      explicit SIMD_4x32(native_simd_type x) noexcept : m_simd(x) {}
_ZN5Botan9SIMD_4x327load_beEPKv:
  172|   263k|      static SIMD_4x32 load_be(const void* in) noexcept {
  173|   263k|#if defined(BOTAN_SIMD_USE_SSE2)
  174|   263k|         return load_le(in).bswap();
  175|       |
  176|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  177|       |         uint32_t R[4];
  178|       |         Botan::load_be(R, static_cast<const uint8_t*>(in), 4);
  179|       |         return SIMD_4x32(R);
  180|       |
  181|       |#elif defined(BOTAN_SIMD_USE_NEON)
  182|       |         SIMD_4x32 l(vld1q_u32(static_cast<const uint32_t*>(in)));
  183|       |         return CPUID::is_little_endian() ? l.bswap() : l;
  184|       |#endif
  185|   263k|      }
_ZN5Botan9SIMD_4x327load_leEPKv:
  156|   263k|      static SIMD_4x32 load_le(const void* in) noexcept {
  157|   263k|#if defined(BOTAN_SIMD_USE_SSE2)
  158|   263k|         return SIMD_4x32(_mm_loadu_si128(reinterpret_cast<const __m128i*>(in)));
  159|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  160|       |         uint32_t R[4];
  161|       |         Botan::load_le(R, static_cast<const uint8_t*>(in), 4);
  162|       |         return SIMD_4x32(R);
  163|       |#elif defined(BOTAN_SIMD_USE_NEON)
  164|       |         SIMD_4x32 l(vld1q_u32(static_cast<const uint32_t*>(in)));
  165|       |         return CPUID::is_big_endian() ? l.bswap() : l;
  166|       |#endif
  167|   263k|      }
_ZNK5Botan9SIMD_4x325bswapEv:
  474|   263k|      SIMD_4x32 bswap() const noexcept {
  475|   263k|#if defined(BOTAN_SIMD_USE_SSE2)
  476|       |
  477|   263k|         __m128i T = m_simd;
  478|   263k|         T = _mm_shufflehi_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
  479|   263k|         T = _mm_shufflelo_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
  480|   263k|         return SIMD_4x32(_mm_or_si128(_mm_srli_epi16(T, 8), _mm_slli_epi16(T, 8)));
  481|       |
  482|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  483|       |         return SIMD_4x32(vec_revb(m_simd));
  484|       |
  485|       |#elif defined(BOTAN_SIMD_USE_NEON)
  486|       |         return SIMD_4x32(vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(m_simd))));
  487|       |#endif
  488|   263k|      }
_ZNK5Botan9SIMD_4x32plERKS0_:
  321|  1.31M|      SIMD_4x32 operator+(const SIMD_4x32& other) const noexcept {
  322|  1.31M|         SIMD_4x32 retval(*this);
  323|  1.31M|         retval += other;
  324|  1.31M|         return retval;
  325|  1.31M|      }
_ZN5Botan9SIMD_4x32pLERKS0_:
  363|  1.31M|      void operator+=(const SIMD_4x32& other) noexcept {
  364|  1.31M|#if defined(BOTAN_SIMD_USE_SSE2)
  365|  1.31M|         m_simd = _mm_add_epi32(m_simd, other.m_simd);
  366|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  367|       |         m_simd = vec_add(m_simd, other.m_simd);
  368|       |#elif defined(BOTAN_SIMD_USE_NEON)
  369|       |         m_simd = vaddq_u32(m_simd, other.m_simd);
  370|       |#endif
  371|  1.31M|      }
_ZNK5Botan9SIMD_4x328store_leEPj:
  187|  1.31M|      void store_le(uint32_t out[4]) const noexcept { this->store_le(reinterpret_cast<uint8_t*>(out)); }
_ZNK5Botan9SIMD_4x328store_leEPh:
  196|  1.31M|      void store_le(uint8_t out[]) const noexcept {
  197|  1.31M|#if defined(BOTAN_SIMD_USE_SSE2)
  198|       |
  199|  1.31M|         _mm_storeu_si128(reinterpret_cast<__m128i*>(out), raw());
  200|       |
  201|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  202|       |
  203|       |         union {
  204|       |               __vector unsigned int V;
  205|       |               uint32_t R[4];
  206|       |         } vec;
  207|       |
  208|       |         vec.V = raw();
  209|       |         Botan::store_le(out, vec.R[0], vec.R[1], vec.R[2], vec.R[3]);
  210|       |
  211|       |#elif defined(BOTAN_SIMD_USE_NEON)
  212|       |         if(CPUID::is_little_endian()) {
  213|       |            vst1q_u8(out, vreinterpretq_u8_u32(m_simd));
  214|       |         } else {
  215|       |            vst1q_u8(out, vreinterpretq_u8_u32(bswap().m_simd));
  216|       |         }
  217|       |#endif
  218|  1.31M|      }
_ZNK5Botan9SIMD_4x323rawEv:
  595|  6.57M|      native_simd_type raw() const noexcept { return m_simd; }
_ZNK5Botan9SIMD_4x3217shift_elems_rightILm1EEES0_v:
  514|  1.05M|      {
  515|  1.05M|#if defined(BOTAN_SIMD_USE_SSE2)
  516|  1.05M|         return SIMD_4x32(_mm_srli_si128(raw(), 4 * I));
  517|       |#elif defined(BOTAN_SIMD_USE_NEON)
  518|       |         return SIMD_4x32(vextq_u32(raw(), vdupq_n_u32(0), I));
  519|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  520|       |         const __vector unsigned int zero = vec_splat_u32(0);
  521|       |
  522|       |         const __vector unsigned char shuf[3] = {
  523|       |            {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
  524|       |            {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23},
  525|       |            {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27},
  526|       |         };
  527|       |
  528|       |         return SIMD_4x32(vec_perm(raw(), zero, shuf[I - 1]));
  529|       |#endif
  530|  1.05M|      }
_ZN5Botan9SIMD_4x32eOERKS0_:
  383|  4.20M|      void operator^=(const SIMD_4x32& other) noexcept {
  384|  4.20M|#if defined(BOTAN_SIMD_USE_SSE2)
  385|  4.20M|         m_simd = _mm_xor_si128(m_simd, other.m_simd);
  386|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  387|       |         m_simd = vec_xor(m_simd, other.m_simd);
  388|       |#elif defined(BOTAN_SIMD_USE_NEON)
  389|       |         m_simd = veorq_u32(m_simd, other.m_simd);
  390|       |#endif
  391|  4.20M|      }
_ZNK5Botan9SIMD_4x3216shift_elems_leftILm3EEES0_v:
  493|  1.05M|      {
  494|  1.05M|#if defined(BOTAN_SIMD_USE_SSE2)
  495|  1.05M|         return SIMD_4x32(_mm_slli_si128(raw(), 4 * I));
  496|       |#elif defined(BOTAN_SIMD_USE_NEON)
  497|       |         return SIMD_4x32(vextq_u32(vdupq_n_u32(0), raw(), 4 - I));
  498|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  499|       |         const __vector unsigned int zero = vec_splat_u32(0);
  500|       |
  501|       |         const __vector unsigned char shuf[3] = {
  502|       |            {16, 17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
  503|       |            {16, 17, 18, 19, 20, 21, 22, 23, 0, 1, 2, 3, 4, 5, 6, 7},
  504|       |            {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 0, 1, 2, 3},
  505|       |         };
  506|       |
  507|       |         return SIMD_4x32(vec_perm(raw(), zero, shuf[I - 1]));
  508|       |#endif
  509|  1.05M|      }
_ZNK5Botan9SIMD_4x324rotlILm1EEES0_v:
  281|  1.05M|      {
  282|  1.05M|#if defined(BOTAN_SIMD_USE_SSE2)
  283|       |
  284|  1.05M|         return SIMD_4x32(_mm_or_si128(_mm_slli_epi32(m_simd, static_cast<int>(ROT)),
  285|  1.05M|                                       _mm_srli_epi32(m_simd, static_cast<int>(32 - ROT))));
  286|       |
  287|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  288|       |
  289|       |         const unsigned int r = static_cast<unsigned int>(ROT);
  290|       |         __vector unsigned int rot = {r, r, r, r};
  291|       |         return SIMD_4x32(vec_rl(m_simd, rot));
  292|       |
  293|       |#elif defined(BOTAN_SIMD_USE_NEON)
  294|       |
  295|       |   #if defined(BOTAN_TARGET_ARCH_IS_ARM64)
  296|       |
  297|       |         if constexpr(ROT == 8) {
  298|       |            const uint8_t maskb[16] = {3, 0, 1, 2, 7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14};
  299|       |            const uint8x16_t mask = vld1q_u8(maskb);
  300|       |            return SIMD_4x32(vreinterpretq_u32_u8(vqtbl1q_u8(vreinterpretq_u8_u32(m_simd), mask)));
  301|       |         } else if constexpr(ROT == 16) {
  302|       |            return SIMD_4x32(vreinterpretq_u32_u16(vrev32q_u16(vreinterpretq_u16_u32(m_simd))));
  303|       |         }
  304|       |   #endif
  305|       |         return SIMD_4x32(
  306|       |            vorrq_u32(vshlq_n_u32(m_simd, static_cast<int>(ROT)), vshrq_n_u32(m_simd, static_cast<int>(32 - ROT))));
  307|       |#endif
  308|  1.05M|      }
_ZNK5Botan9SIMD_4x324rotlILm2EEES0_v:
  281|  1.05M|      {
  282|  1.05M|#if defined(BOTAN_SIMD_USE_SSE2)
  283|       |
  284|  1.05M|         return SIMD_4x32(_mm_or_si128(_mm_slli_epi32(m_simd, static_cast<int>(ROT)),
  285|  1.05M|                                       _mm_srli_epi32(m_simd, static_cast<int>(32 - ROT))));
  286|       |
  287|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  288|       |
  289|       |         const unsigned int r = static_cast<unsigned int>(ROT);
  290|       |         __vector unsigned int rot = {r, r, r, r};
  291|       |         return SIMD_4x32(vec_rl(m_simd, rot));
  292|       |
  293|       |#elif defined(BOTAN_SIMD_USE_NEON)
  294|       |
  295|       |   #if defined(BOTAN_TARGET_ARCH_IS_ARM64)
  296|       |
  297|       |         if constexpr(ROT == 8) {
  298|       |            const uint8_t maskb[16] = {3, 0, 1, 2, 7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14};
  299|       |            const uint8x16_t mask = vld1q_u8(maskb);
  300|       |            return SIMD_4x32(vreinterpretq_u32_u8(vqtbl1q_u8(vreinterpretq_u8_u32(m_simd), mask)));
  301|       |         } else if constexpr(ROT == 16) {
  302|       |            return SIMD_4x32(vreinterpretq_u32_u16(vrev32q_u16(vreinterpretq_u16_u32(m_simd))));
  303|       |         }
  304|       |   #endif
  305|       |         return SIMD_4x32(
  306|       |            vorrq_u32(vshlq_n_u32(m_simd, static_cast<int>(ROT)), vshrq_n_u32(m_simd, static_cast<int>(32 - ROT))));
  307|       |#endif
  308|  1.05M|      }
_ZN5Botan9SIMD_4x32C2Ejjjj:
  113|     96|      SIMD_4x32(uint32_t B0, uint32_t B1, uint32_t B2, uint32_t B3) noexcept {
  114|     96|#if defined(BOTAN_SIMD_USE_SSE2)
  115|     96|         m_simd = _mm_set_epi32(B3, B2, B1, B0);
  116|       |#elif defined(BOTAN_SIMD_USE_ALTIVEC)
  117|       |         __vector unsigned int val = {B0, B1, B2, B3};
  118|       |         m_simd = val;
  119|       |#elif defined(BOTAN_SIMD_USE_NEON)
  120|       |         // Better way to do this?
  121|       |         const uint32_t B[4] = {B0, B1, B2, B3};
  122|       |         m_simd = vld1q_u32(B);
  123|       |#endif
  124|     96|      }
_ZN5Botan9SIMD_4x328splat_u8Eh:
  142|      2|      static SIMD_4x32 splat_u8(uint8_t B) noexcept {
  143|      2|#if defined(BOTAN_SIMD_USE_SSE2)
  144|      2|         return SIMD_4x32(_mm_set1_epi8(B));
  145|       |#elif defined(BOTAN_SIMD_USE_NEON)
  146|       |         return SIMD_4x32(vreinterpretq_u32_u8(vdupq_n_u8(B)));
  147|       |#else
  148|       |         const uint32_t B4 = make_uint32(B, B, B, B);
  149|       |         return SIMD_4x32(B4, B4, B4, B4);
  150|       |#endif
  151|      2|      }

_ZN5Botan15multimap_insertINS_3OIDENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRNS2_8multimapIT_T0_NS2_4lessISA_EENS6_INS2_4pairIKSA_SB_EEEEEERSF_RKSB_:
  109|  1.02k|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|  1.02k|   multimap.insert(std::make_pair(key, value));
  111|  1.02k|}
_ZN5Botan12BufferSlicerC2ENSt3__14spanIKhLm18446744073709551615EEE:
  143|  50.1k|      BufferSlicer(std::span<const uint8_t> buffer) : m_remaining(buffer) {}
_ZN5Botan12BufferSlicer4takeEm:
  155|   172k|      std::span<const uint8_t> take(const size_t count) {
  156|   172k|         BOTAN_STATE_CHECK(remaining() >= count);
  ------------------
  |  |   42|   172k|   do {                                                         \
  |  |   43|   172k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 172k]
  |  |  ------------------
  |  |   44|   172k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|   172k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|   172k|         auto result = m_remaining.first(count);
  158|   172k|         m_remaining = m_remaining.subspan(count);
  159|   172k|         return result;
  160|   172k|      }
_ZNK5Botan12BufferSlicer9remainingEv:
  184|   232k|      size_t remaining() const { return m_remaining.size(); }
_ZNK5Botan12BufferSlicer5emptyEv:
  186|  48.1k|      bool empty() const { return m_remaining.empty(); }
_ZN5Botan13BufferStufferC2ENSt3__14spanIhLm18446744073709551615EEE:
  201|  1.05k|      BufferStuffer(std::span<uint8_t> buffer) : m_buffer(buffer) {}
_ZN5Botan13BufferStuffer4nextEm:
  207|  5.28k|      std::span<uint8_t> next(size_t bytes) {
  208|  5.28k|         BOTAN_STATE_CHECK(m_buffer.size() >= bytes);
  ------------------
  |  |   42|  5.28k|   do {                                                         \
  |  |   43|  5.28k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 5.28k]
  |  |  ------------------
  |  |   44|  5.28k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|  5.28k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  209|       |
  210|  5.28k|         auto result = m_buffer.first(bytes);
  211|  5.28k|         m_buffer = m_buffer.subspan(bytes);
  212|  5.28k|         return result;
  213|  5.28k|      }
_ZN5Botan13BufferStuffer6appendENSt3__14spanIKhLm18446744073709551615EEE:
  234|  2.11k|      void append(std::span<const uint8_t> buffer) {
  235|  2.11k|         auto sink = next(buffer.size());
  236|  2.11k|         std::copy(buffer.begin(), buffer.end(), sink.begin());
  237|  2.11k|      }
_ZN5Botan13BufferStuffer6appendEhm:
  239|  3.16k|      void append(uint8_t b, size_t repeat = 1) {
  240|  3.16k|         auto sink = next(repeat);
  241|  3.16k|         std::fill(sink.begin(), sink.end(), b);
  242|  3.16k|      }
_ZNK5Botan13BufferStuffer4fullEv:
  244|  1.05k|      bool full() const { return m_buffer.empty(); }
_ZNK5Botan13BufferStuffer18remaining_capacityEv:
  246|  1.05k|      size_t remaining_capacity() const { return m_buffer.size(); }
_ZN5Botan15multimap_insertINS_3OIDENS_11ASN1_StringEEEvRNSt3__18multimapIT_T0_NS3_4lessIS5_EENS3_9allocatorINS3_4pairIKS5_S6_EEEEEERSB_RKS6_:
  109|    342|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|    342|   multimap.insert(std::make_pair(key, value));
  111|    342|}

_ZN5Botan11ASN1_ObjectD2Ev:
  120|   398k|      virtual ~ASN1_Object() = default;
_ZN5Botan10BER_ObjectC2Ev:
  128|   426k|      BER_Object() : m_type_tag(ASN1_Type::NoObject), m_class_tag(ASN1_Class::Universal) {}
_ZNK5Botan10BER_Object6is_setEv:
  138|   639k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|   326k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|   326k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|   326k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  16.3k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|    387|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|  4.05M|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|  8.53M|      size_t length() const { return m_value.size(); }
_ZN5Botan10BER_Object12mutable_bitsEm:
  169|   286k|      uint8_t* mutable_bits(size_t length) {
  170|   286k|         m_value.resize(length);
  171|   286k|         return m_value.data();
  172|   286k|      }
_ZN5Botan3OIDC2ESt16initializer_listIjE:
  229|    281|      explicit OID(std::initializer_list<uint32_t> init) : m_id(init) {
  230|    281|         BOTAN_ARG_CHECK(m_id.size() > 2 && m_id[0] <= 2 && (m_id[0] != 2 || m_id[1] <= 39), "Invalid OID");
  ------------------
  |  |   30|    281|   do {                                                          \
  |  |   31|  1.47k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 281, False: 0]
  |  |  |  Branch (31:12): [True: 281, False: 0]
  |  |  |  Branch (31:12): [True: 208, False: 73]
  |  |  |  Branch (31:12): [True: 73, False: 0]
  |  |  ------------------
  |  |   32|    281|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    281|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  231|    281|      }
_ZNK5Botan3OID9has_valueEv:
  271|    337|      bool has_value() const { return (m_id.empty() == false); }
_ZNK5Botan3OID14get_componentsEv:
  277|   198k|      const std::vector<uint32_t>& get_components() const { return m_id; }
_ZNK5Botan3OIDeqERKS0_:
  309|   148k|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan11ASN1_String5valueEv:
  415|  1.54k|      const std::string& value() const { return m_utf8_str; }
_ZNK5Botan11ASN1_String5emptyEv:
  419|  2.45k|      bool empty() const { return m_utf8_str.empty(); }
_ZNK5Botan19AlgorithmIdentifier3oidEv:
  455|  14.7k|      const OID& oid() const { return m_oid; }
_ZNK5Botan19AlgorithmIdentifier10parametersEv:
  457|  3.48k|      const std::vector<uint8_t>& parameters() const { return m_parameters; }
_ZNK5Botan19AlgorithmIdentifier20parameters_are_emptyEv:
  469|  7.16k|      bool parameters_are_empty() const { return m_parameters.empty(); }
_ZNK5Botan19AlgorithmIdentifier28parameters_are_null_or_emptyEv:
  471|  7.16k|      bool parameters_are_null_or_empty() const { return parameters_are_empty() || parameters_are_null(); }
  ------------------
  |  Branch (471:58): [True: 266, False: 6.90k]
  |  Branch (471:84): [True: 6.85k, False: 47]
  ------------------
_ZN5BotanorENS_10ASN1_ClassES0_:
   78|   149k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   79|   149k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   80|   149k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|   326k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|   326k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|   326k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  40.0k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  40.0k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  40.0k|}
_ZN5BotanneERKNS_3OIDES2_:
  326|  7.72k|inline bool operator!=(const OID& a, const OID& b) {
  327|  7.72k|   return !(a == b);
  328|  7.72k|}
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|  93.7k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan9ASN1_TimeC2Ev:
  362|  12.3k|      ASN1_Time() = default;
_ZN5Botan11ASN1_ObjectC2Ev:
  117|   304k|      ASN1_Object() = default;
_ZN5Botan19AlgorithmIdentifierC2Ev:
  447|  19.4k|      AlgorithmIdentifier() = default;
_ZN5Botan3OIDC2Ev:
  218|  42.8k|      explicit OID() = default;
_ZN5Botan11ASN1_ObjectaSERKS0_:
  119|  3.29k|      ASN1_Object& operator=(const ASN1_Object&) = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  136|  88.1k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  134|   124k|      BER_Object(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectaSERKS0_:
  132|  2.94k|      BER_Object& operator=(const BER_Object& other) = default;

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

_ZN5Botan11BER_Decoder14start_sequenceEv:
  113|  87.4k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder22start_context_specificEj:
  117|  5.03k|      BER_Decoder start_context_specific(uint32_t tag) {
  118|  5.03k|         return start_cons(ASN1_Type(tag), ASN1_Class::ContextSpecific);
  119|  5.03k|      }
_ZN5Botan11BER_Decoder21get_next_octet_stringEv:
  188|  3.75k|      std::vector<uint8_t> get_next_octet_string() {
  189|  3.75k|         std::vector<uint8_t> out_vec;
  190|  3.75k|         decode(out_vec, ASN1_Type::OctetString);
  191|  3.75k|         return out_vec;
  192|  3.75k|      }
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectE:
   52|  6.02k|      BER_Decoder(const BER_Object& obj) : BER_Decoder(obj.bits(), obj.length()) {}
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  198|  33.3k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  199|  33.3k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  200|  33.3k|      }
_ZN5Botan11BER_Decoder16decode_and_checkINS_3OIDEEERS0_RKT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  257|  3.95k|      BER_Decoder& decode_and_check(const T& expected, std::string_view error_msg) {
  258|  3.95k|         T actual;
  259|  3.95k|         decode(actual);
  260|       |
  261|  3.95k|         if(actual != expected) {
  ------------------
  |  Branch (261:13): [True: 111, False: 3.83k]
  ------------------
  262|    111|            throw Decoding_Error(error_msg);
  263|    111|         }
  264|       |
  265|  3.83k|         return (*this);
  266|  3.95k|      }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EE:
  162|  33.7k|      BER_Decoder& raw_bytes(std::vector<uint8_t, Alloc>& out) {
  163|  33.7k|         out.clear();
  164|  33.7k|         uint8_t buf;
  165|  3.28M|         while(m_source->read_byte(buf)) {
  ------------------
  |  Branch (165:16): [True: 3.25M, False: 33.7k]
  ------------------
  166|  3.25M|            out.push_back(buf);
  167|  3.25M|         }
  168|  33.7k|         return (*this);
  169|  33.7k|      }
_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  7.52k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  7.52k|   BER_Object obj = get_next_object();
  319|       |
  320|  7.52k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 3.29k, False: 4.22k]
  ------------------
  321|  3.29k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 3.14k, False: 156]
  ------------------
  322|  3.14k|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|  3.14k|      } else {
  324|    156|         push_back(std::move(obj));
  325|    156|         decode(out, type_tag, class_tag);
  326|    156|      }
  327|  4.22k|   } else {
  328|  4.22k|      out = default_value;
  329|  4.22k|      push_back(std::move(obj));
  330|  4.22k|   }
  331|       |
  332|  7.52k|   return (*this);
  333|  7.52k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectE:
   57|  4.49k|      BER_Decoder(BER_Object&& obj) : BER_Decoder(std::move(obj), nullptr) {}
_ZN5Botan11BER_Decoder6decodeERm:
  181|  3.22k|      BER_Decoder& decode(size_t& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder15decode_optionalINS_7X509_DNEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS4_:
  317|  2.96k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  2.96k|   BER_Object obj = get_next_object();
  319|       |
  320|  2.96k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 239, False: 2.73k]
  ------------------
  321|    239|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 239, False: 0]
  ------------------
  322|    239|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|    239|      } else {
  324|      0|         push_back(std::move(obj));
  325|      0|         decode(out, type_tag, class_tag);
  326|      0|      }
  327|  2.73k|   } else {
  328|  2.73k|      out = default_value;
  329|  2.73k|      push_back(std::move(obj));
  330|  2.73k|   }
  331|       |
  332|  2.96k|   return (*this);
  333|  2.96k|}
_ZN5Botan11BER_Decoder22decode_optional_stringINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeEjNS_10ASN1_ClassE:
  275|  10.1k|                                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  276|  10.1k|         BER_Object obj = get_next_object();
  277|       |
  278|  10.1k|         ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
  279|       |
  280|  10.1k|         if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (280:13): [True: 79, False: 10.1k]
  ------------------
  281|     79|            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (281:16): [True: 28, False: 51]
  ------------------
  282|     28|               BER_Decoder(std::move(obj)).decode(out, real_type).verify_end();
  283|     51|            } else {
  284|     51|               push_back(std::move(obj));
  285|     51|               decode(out, real_type, type_tag, class_tag);
  286|     51|            }
  287|  10.1k|         } else {
  288|  10.1k|            out.clear();
  289|  10.1k|            push_back(std::move(obj));
  290|  10.1k|         }
  291|       |
  292|  10.1k|         return (*this);
  293|  10.1k|      }
_ZN5Botan11BER_Decoder11decode_listINS_4OCSP14SingleResponseEEERS0_RNSt3__16vectorIT_NS5_9allocatorIS7_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|  1.11k|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|  1.11k|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  1.13k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 14, False: 1.11k]
  ------------------
  368|     14|      T value;
  369|     14|      list.decode(value);
  370|     14|      vec.push_back(std::move(value));
  371|     14|   }
  372|       |
  373|  1.11k|   list.end_cons();
  374|       |
  375|  1.11k|   return (*this);
  376|  1.11k|}
_ZN5Botan11BER_Decoder15decode_optionalINS_10ExtensionsEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS4_:
  317|  1.10k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  1.10k|   BER_Object obj = get_next_object();
  319|       |
  320|  1.10k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 1.08k, False: 16]
  ------------------
  321|  1.08k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 1.08k, False: 0]
  ------------------
  322|  1.08k|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|  1.08k|      } else {
  324|      0|         push_back(std::move(obj));
  325|      0|         decode(out, type_tag, class_tag);
  326|      0|      }
  327|  1.08k|   } else {
  328|     16|      out = default_value;
  329|     16|      push_back(std::move(obj));
  330|     16|   }
  331|       |
  332|  1.10k|   return (*this);
  333|  1.10k|}
_ZN5Botan11BER_DecoderC2ENSt3__14spanIKhLm18446744073709551615EEE:
   32|  1.71k|      BER_Decoder(std::span<const uint8_t> buf) : BER_Decoder(buf.data(), buf.size()) {}
_ZN5Botan11BER_Decoder8get_nextERNS_10BER_ObjectE:
   69|  7.26k|      BER_Decoder& get_next(BER_Object& ber) {
   70|  7.26k|         ber = get_next_object();
   71|  7.26k|         return (*this);
   72|  7.26k|      }
_ZN5Botan11BER_Decoder9start_setEv:
  115|  3.28k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  186|  6.92k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder15decode_optionalINS_9ASN1_TimeEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS4_:
  317|      6|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|      6|   BER_Object obj = get_next_object();
  319|       |
  320|      6|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 1, False: 5]
  ------------------
  321|      1|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 1, False: 0]
  ------------------
  322|      1|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|      1|      } else {
  324|      0|         push_back(std::move(obj));
  325|      0|         decode(out, type_tag, class_tag);
  326|      0|      }
  327|      5|   } else {
  328|      5|      out = default_value;
  329|      5|      push_back(std::move(obj));
  330|      5|   }
  331|       |
  332|      6|   return (*this);
  333|      6|}
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  14.6k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  14.6k|   BER_Object obj = get_next_object();
  319|       |
  320|  14.6k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 456, False: 14.1k]
  ------------------
  321|    456|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 0, False: 456]
  ------------------
  322|      0|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|    456|      } else {
  324|    456|         push_back(std::move(obj));
  325|    456|         decode(out, type_tag, class_tag);
  326|    456|      }
  327|  14.1k|   } else {
  328|  14.1k|      out = default_value;
  329|  14.1k|      push_back(std::move(obj));
  330|  14.1k|   }
  331|       |
  332|  14.6k|   return (*this);
  333|  14.6k|}
_ZN5Botan11BER_Decoder11decode_listINS_3OIDEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    207|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    207|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|    465|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 258, False: 207]
  ------------------
  368|    258|      T value;
  369|    258|      list.decode(value);
  370|    258|      vec.push_back(std::move(value));
  371|    258|   }
  372|       |
  373|    207|   list.end_cons();
  374|       |
  375|    207|   return (*this);
  376|    207|}
_ZN5Botan11BER_Decoder11decode_listINS_14GeneralSubtreeEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    634|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    634|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  1.64k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 1.00k, False: 634]
  ------------------
  368|  1.00k|      T value;
  369|  1.00k|      list.decode(value);
  370|  1.00k|      vec.push_back(std::move(value));
  371|  1.00k|   }
  372|       |
  373|    634|   list.end_cons();
  374|       |
  375|    634|   return (*this);
  376|    634|}
x509_ext.cpp:_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension12_GLOBAL__N_118Policy_InformationEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    410|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    410|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|    694|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 284, False: 410]
  ------------------
  368|    284|      T value;
  369|    284|      list.decode(value);
  370|    284|      vec.push_back(std::move(value));
  371|    284|   }
  372|       |
  373|    410|   list.end_cons();
  374|       |
  375|    410|   return (*this);
  376|    410|}
_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension23CRL_Distribution_Points18Distribution_PointEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|  1.87k|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|  1.87k|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  3.27k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 1.40k, False: 1.87k]
  ------------------
  368|  1.40k|      T value;
  369|  1.40k|      list.decode(value);
  370|  1.40k|      vec.push_back(std::move(value));
  371|  1.40k|   }
  372|       |
  373|  1.87k|   list.end_cons();
  374|       |
  375|  1.87k|   return (*this);
  376|  1.87k|}
_ZN5Botan11BER_Decoder24decode_optional_implicitINS_15AlternativeNameEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassES6_S7_RKS4_:
  344|    883|                                                   const T& default_value) {
  345|    883|   BER_Object obj = get_next_object();
  346|       |
  347|    883|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (347:7): [True: 653, False: 230]
  ------------------
  348|    653|      obj.set_tagging(real_type, real_class);
  349|    653|      push_back(std::move(obj));
  350|    653|      decode(out, real_type, real_class);
  351|    653|   } else {
  352|       |      // Not what we wanted, push it back on the stream
  353|    230|      out = default_value;
  354|    230|      push_back(std::move(obj));
  355|    230|   }
  356|       |
  357|    883|   return (*this);
  358|    883|}

_ZN5Botan6BigIntD2Ev:
  148|  63.8k|      ~BigInt() { const_time_unpoison(); }
_ZNK5Botan6BigInt19const_time_unpoisonEv:
  726|  65.2k|      void const_time_unpoison() const {}
_ZN5Botan6BigIntC2EOS0_:
  146|  2.73k|      BigInt(BigInt&& other) { this->swap(other); }
_ZN5Botan6BigIntaSEOS0_:
  153|  17.3k|      BigInt& operator=(BigInt&& other) {
  154|  17.3k|         if(this != &other) {
  ------------------
  |  Branch (154:13): [True: 17.3k, False: 0]
  ------------------
  155|  17.3k|            this->swap(other);
  156|  17.3k|         }
  157|       |
  158|  17.3k|         return (*this);
  159|  17.3k|      }
_ZN5Botan6BigInt4swapERS0_:
  170|  20.0k|      void swap(BigInt& other) {
  171|  20.0k|         m_data.swap(other.m_data);
  172|  20.0k|         std::swap(m_signedness, other.m_signedness);
  173|  20.0k|      }
_ZN5Botan6BigInt8swap_regERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  177|  12.1k|      void swap_reg(secure_vector<word>& reg) {
  178|  12.1k|         m_data.swap(reg);
  179|       |         // sign left unchanged
  180|  12.1k|      }
_ZN5Botan6BigInt5clearEv:
  370|  16.3k|      void clear() {
  371|  16.3k|         m_data.set_to_zero();
  372|  16.3k|         m_signedness = Positive;
  373|  16.3k|      }
_ZNK5Botan6BigInt7is_evenEv:
  410|  4.43k|      bool is_even() const { return (get_bit(0) == 0); }
_ZNK5Botan6BigInt10is_nonzeroEv:
  422|  4.37k|      bool is_nonzero() const { return (!is_zero()); }
_ZNK5Botan6BigInt7is_zeroEv:
  428|  8.37k|      bool is_zero() const { return (sig_words() == 0); }
_ZN5Botan6BigInt7set_bitEm:
  434|  2.91k|      void set_bit(size_t n) { conditionally_set_bit(n, true); }
_ZN5Botan6BigInt21conditionally_set_bitEmb:
  444|  7.87M|      void conditionally_set_bit(size_t n, bool set_it) {
  445|  7.87M|         const size_t which = n / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  7.87M|#define BOTAN_MP_WORD_BITS 64
  ------------------
  446|  7.87M|         const word mask = static_cast<word>(set_it) << (n % BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|  7.87M|#define BOTAN_MP_WORD_BITS 64
  ------------------
  447|  7.87M|         m_data.set_word_at(which, word_at(which) | mask);
  448|  7.87M|      }
_ZN5Botan6BigInt9mask_bitsEm:
  460|  4.37k|      void mask_bits(size_t n) { m_data.mask_bits(n); }
_ZNK5Botan6BigInt7get_bitEm:
  467|  3.94M|      bool get_bit(size_t n) const { return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1); }
  ------------------
  |  |   50|  3.94M|#define BOTAN_MP_WORD_BITS 64
  ------------------
                    bool get_bit(size_t n) const { return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1); }
  ------------------
  |  |   50|  3.94M|#define BOTAN_MP_WORD_BITS 64
  ------------------
_ZNK5Botan6BigInt7word_atEm:
  518|  12.2M|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZN5Botan6BigInt11set_word_atEmm:
  520|  3.93M|      void set_word_at(size_t i, word w) { m_data.set_word_at(i, w); }
_ZNK5Botan6BigInt11is_negativeEv:
  528|  58.7k|      bool is_negative() const { return (sign() == Negative); }
_ZNK5Botan6BigInt11is_positiveEv:
  534|  4.11k|      bool is_positive() const { return (sign() == Positive); }
_ZNK5Botan6BigInt4signEv:
  540|   113k|      Sign sign() const { return (m_signedness); }
_ZNK5Botan6BigInt12reverse_signEv:
  545|  2.37k|      Sign reverse_sign() const {
  546|  2.37k|         if(sign() == Positive) {
  ------------------
  |  Branch (546:13): [True: 2.37k, False: 0]
  ------------------
  547|  2.37k|            return Negative;
  548|  2.37k|         }
  549|      0|         return Positive;
  550|  2.37k|      }
_ZN5Botan6BigInt9flip_signEv:
  555|  2.37k|      void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  561|  29.2k|      void set_sign(Sign sign) {
  562|  29.2k|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (562:13): [True: 2.54k, False: 26.6k]
  |  Branch (562:33): [True: 0, False: 2.54k]
  ------------------
  563|      0|            sign = Positive;
  564|      0|         }
  565|       |
  566|  29.2k|         m_signedness = sign;
  567|  29.2k|      }
_ZNK5Botan6BigInt4sizeEv:
  578|  21.3M|      size_t size() const { return m_data.size(); }
_ZNK5Botan6BigInt9sig_wordsEv:
  584|   113k|      size_t sig_words() const { return m_data.sig_words(); }
_ZN5Botan6BigInt12mutable_dataEv:
  609|  16.2M|      word* mutable_data() { return m_data.mutable_data(); }
_ZNK5Botan6BigInt4dataEv:
  615|  8.96M|      const word* data() const { return m_data.const_data(); }
_ZNK5Botan6BigInt7grow_toEm:
  631|  7.90M|      void grow_to(size_t n) const { m_data.grow_to(n); }
_ZN5Botan6BigInt10power_of_2Em:
  742|  1.45k|      static BigInt power_of_2(size_t n) {
  743|  1.45k|         BigInt b;
  744|  1.45k|         b.set_bit(n);
  745|  1.45k|         return b;
  746|  1.45k|      }
_ZN5Botan6BigInt6encodeERKS0_:
  753|  4.94k|      static std::vector<uint8_t> encode(const BigInt& n) {
  754|  4.94k|         std::vector<uint8_t> output(n.bytes());
  755|  4.94k|         n.binary_encode(output.data());
  756|  4.94k|         return output;
  757|  4.94k|      }
_ZN5Botan6BigInt4Data12mutable_dataEv:
  834|  16.2M|            word* mutable_data() {
  835|  16.2M|               invalidate_sig_words();
  836|  16.2M|               return m_reg.data();
  837|  16.2M|            }
_ZNK5Botan6BigInt4Data10const_dataEv:
  839|  8.96M|            const word* const_data() const { return m_reg.data(); }
_ZNK5Botan6BigInt4Data11get_word_atEm:
  848|  12.2M|            word get_word_at(size_t n) const {
  849|  12.2M|               if(n < m_reg.size()) {
  ------------------
  |  Branch (849:19): [True: 12.2M, False: 19.7k]
  ------------------
  850|  12.2M|                  return m_reg[n];
  851|  12.2M|               }
  852|  19.7k|               return 0;
  853|  12.2M|            }
_ZN5Botan6BigInt4Data11set_word_atEmm:
  855|  11.8M|            void set_word_at(size_t i, word w) {
  856|  11.8M|               invalidate_sig_words();
  857|  11.8M|               if(i >= m_reg.size()) {
  ------------------
  |  Branch (857:19): [True: 3.94M, False: 7.87M]
  ------------------
  858|  3.94M|                  if(w == 0) {
  ------------------
  |  Branch (858:22): [True: 3.93M, False: 2.91k]
  ------------------
  859|  3.93M|                     return;
  860|  3.93M|                  }
  861|  2.91k|                  grow_to(i + 1);
  862|  2.91k|               }
  863|  7.87M|               m_reg[i] = w;
  864|  7.87M|            }
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  871|  16.3k|            void set_to_zero() {
  872|  16.3k|               m_reg.resize(m_reg.capacity());
  873|  16.3k|               clear_mem(m_reg.data(), m_reg.size());
  874|  16.3k|               m_sig_words = 0;
  875|  16.3k|            }
_ZN5Botan6BigInt4Data9mask_bitsEm:
  883|  4.37k|            void mask_bits(size_t n) {
  884|  4.37k|               if(n == 0) {
  ------------------
  |  Branch (884:19): [True: 0, False: 4.37k]
  ------------------
  885|      0|                  return set_to_zero();
  886|      0|               }
  887|       |
  888|  4.37k|               const size_t top_word = n / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  4.37k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  889|       |
  890|       |               // if(top_word < sig_words()) ?
  891|  4.37k|               if(top_word < size()) {
  ------------------
  |  Branch (891:19): [True: 4.26k, False: 110]
  ------------------
  892|  4.26k|                  const word mask = (static_cast<word>(1) << (n % BOTAN_MP_WORD_BITS)) - 1;
  ------------------
  |  |   50|  4.26k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  893|  4.26k|                  const size_t len = size() - (top_word + 1);
  894|  4.26k|                  if(len > 0) {
  ------------------
  |  Branch (894:22): [True: 4.26k, False: 0]
  ------------------
  895|  4.26k|                     clear_mem(&m_reg[top_word + 1], len);
  896|  4.26k|                  }
  897|  4.26k|                  m_reg[top_word] &= mask;
  898|  4.26k|                  invalidate_sig_words();
  899|  4.26k|               }
  900|  4.37k|            }
_ZNK5Botan6BigInt4Data7grow_toEm:
  902|  7.90M|            void grow_to(size_t n) const {
  903|  7.90M|               if(n > size()) {
  ------------------
  |  Branch (903:19): [True: 17.8k, False: 7.88M]
  ------------------
  904|  17.8k|                  if(n <= m_reg.capacity()) {
  ------------------
  |  Branch (904:22): [True: 5.73k, False: 12.1k]
  ------------------
  905|  5.73k|                     m_reg.resize(n);
  906|  12.1k|                  } else {
  907|  12.1k|                     m_reg.resize(n + (8 - (n % 8)));
  908|  12.1k|                  }
  909|  17.8k|               }
  910|  7.90M|            }
_ZNK5Botan6BigInt4Data4sizeEv:
  912|  29.2M|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERS1_:
  921|  20.0k|            void swap(Data& other) {
  922|  20.0k|               m_reg.swap(other.m_reg);
  923|  20.0k|               std::swap(m_sig_words, other.m_sig_words);
  924|  20.0k|            }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  926|  23.7k|            void swap(secure_vector<word>& reg) {
  927|  23.7k|               m_reg.swap(reg);
  928|  23.7k|               invalidate_sig_words();
  929|  23.7k|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
  931|  28.0M|            void invalidate_sig_words() const { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
  933|   113k|            size_t sig_words() const {
  934|   113k|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (934:19): [True: 48.8k, False: 64.4k]
  ------------------
  935|  48.8k|                  m_sig_words = calc_sig_words();
  936|  64.4k|               } else {
  937|  64.4k|                  BOTAN_DEBUG_ASSERT(m_sig_words == calc_sig_words());
  ------------------
  |  |   99|  64.4k|      do {                          \
  |  |  100|  64.4k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  938|  64.4k|               }
  939|   113k|               return m_sig_words;
  940|   113k|            }
_ZN5BotangeERKNS_6BigIntES2_:
 1007|  1.38k|inline bool operator>=(const BigInt& a, const BigInt& b) {
 1008|  1.38k|   return (a.cmp(b) >= 0);
 1009|  1.38k|}
_ZN5BotanltERKNS_6BigIntES2_:
 1011|  2.73k|inline bool operator<(const BigInt& a, const BigInt& b) {
 1012|  2.73k|   return a.is_less_than(b);
 1013|  2.73k|}
_ZN5BotanltERKNS_6BigIntEm:
 1035|  2.91k|inline bool operator<(const BigInt& a, word b) {
 1036|  2.91k|   return (a.cmp_word(b) < 0);
 1037|  2.91k|}
_ZN5BotangtERKNS_6BigIntEm:
 1039|  1.45k|inline bool operator>(const BigInt& a, word b) {
 1040|  1.45k|   return (a.cmp_word(b) > 0);
 1041|  1.45k|}
_ZN5Botan6BigIntC2Ev:
   40|  42.4k|      BigInt() = default;
_ZN5Botan6BigIntC2ERKS0_:
   80|  7.10k|      BigInt(const BigInt& other) = default;
_ZN5Botan6BigIntaSERKS0_:
  164|  11.5k|      BigInt& operator=(const BigInt&) = default;

_ZN5Botan20Buffered_Computation6updateEPKhm:
   35|  8.21k|      void update(const uint8_t in[], size_t length) { add_data({in, length}); }
_ZN5Botan20Buffered_Computation6updateENSt3__14spanIKhLm18446744073709551615EEE:
   41|  10.1k|      void update(std::span<const uint8_t> in) { add_data(in); }
_ZN5Botan20Buffered_Computation12final_stdvecEv:
   84|  11.6k|      std::vector<uint8_t> final_stdvec() { return final<std::vector<uint8_t>>(); }
_ZN5Botan20Buffered_Computation5finalINSt3__16vectorIhNS2_9allocatorIhEEEEEET_v:
   78|  11.6k|      T final() {
   79|  11.6k|         T output(output_length());
   80|  11.6k|         final_result(output);
   81|  11.6k|         return output;
   82|  11.6k|      }
_ZN5Botan20Buffered_Computation5finalINSt3__16vectorIhNS_16secure_allocatorIhEEEEEET_v:
   78|  6.77k|      T final() {
   79|  6.77k|         T output(output_length());
   80|  6.77k|         final_result(output);
   81|  6.77k|         return output;
   82|  6.77k|      }
_ZN5Botan20Buffered_ComputationD2Ev:
  134|  14.9k|      virtual ~Buffered_Computation() = default;
_ZN5Botan20Buffered_Computation7processINSt3__16vectorIhNS_16secure_allocatorIhEEEEEET_PKhm:
  105|  6.77k|      T process(const uint8_t in[], size_t length) {
  106|  6.77k|         update(in, length);
  107|  6.77k|         return final<T>();
  108|  6.77k|      }

_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIKhLm4EEEEEvOT0_:
   86|  1.96M|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  1.96M|   const std::span s{r};
   88|  1.96M|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  1.96M|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  1.96M|   } else {
   91|  1.96M|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  1.96M|   }
   93|  1.96M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIjLm1EEEJRNS3_IKhLm4EEEEEEvOT_DpOT0_:
  107|   982k|{
  108|   982k|   const std::span s0{r0};
  109|       |
  110|   982k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|   982k|      constexpr size_t expected_size = s0.size_bytes();
  112|   982k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|   982k|   } else {
  114|   982k|      const size_t expected_size = s0.size_bytes();
  115|   982k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|   982k|                      "memory regions don't have equal lengths");
  117|   982k|   }
  118|   982k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIjLm1EEEEEmOT_:
   73|   982k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|   982k|   return std::span{r}.size_bytes();
   75|   982k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIhLm8EEEEEvOT0_:
   86|  46.0k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  46.0k|   const std::span s{r};
   88|  46.0k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  46.0k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  46.0k|   } else {
   91|  46.0k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  46.0k|   }
   93|  46.0k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm8EEEJRNS3_IKmLm1EEEEEEvOT_DpOT0_:
  107|  46.0k|{
  108|  46.0k|   const std::span s0{r0};
  109|       |
  110|  46.0k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  46.0k|      constexpr size_t expected_size = s0.size_bytes();
  112|  46.0k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  46.0k|   } else {
  114|  46.0k|      const size_t expected_size = s0.size_bytes();
  115|  46.0k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  46.0k|                      "memory regions don't have equal lengths");
  117|  46.0k|   }
  118|  46.0k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIKmLm1EEEEEvOT0_:
   86|  46.0k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  46.0k|   const std::span s{r};
   88|  46.0k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  46.0k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  46.0k|   } else {
   91|  46.0k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  46.0k|   }
   93|  46.0k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIhLm8EEEEEmOT_:
   73|  46.0k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  46.0k|   return std::span{r}.size_bytes();
   75|  46.0k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIhLm4EEEEEvOT0_:
   86|   122k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   122k|   const std::span s{r};
   88|   122k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   122k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   122k|   } else {
   91|   122k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   122k|   }
   93|   122k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm4EEEJRNS3_IKjLm1EEEEEEvOT_DpOT0_:
  107|   122k|{
  108|   122k|   const std::span s0{r0};
  109|       |
  110|   122k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|   122k|      constexpr size_t expected_size = s0.size_bytes();
  112|   122k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|   122k|   } else {
  114|   122k|      const size_t expected_size = s0.size_bytes();
  115|   122k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|   122k|                      "memory regions don't have equal lengths");
  117|   122k|   }
  118|   122k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIKjLm1EEEEEvOT0_:
   86|   122k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   122k|   const std::span s{r};
   88|   122k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   122k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   122k|   } else {
   91|   122k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   122k|   }
   93|   122k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIhLm4EEEEEmOT_:
   73|   122k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|   122k|   return std::span{r}.size_bytes();
   75|   122k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIjLm18446744073709551615EEEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_:
  107|  15.6k|{
  108|  15.6k|   const std::span s0{r0};
  109|       |
  110|  15.6k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  15.6k|      constexpr size_t expected_size = s0.size_bytes();
  112|  15.6k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  15.6k|   } else {
  114|  15.6k|      const size_t expected_size = s0.size_bytes();
  115|  15.6k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  15.6k|   do {                                                          \
  |  |   31|  15.6k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 15.6k]
  |  |  ------------------
  |  |   32|  15.6k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  15.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  15.6k|                      "memory regions don't have equal lengths");
  117|  15.6k|   }
  118|  15.6k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIjLm18446744073709551615EEEEEmOT_:
   73|  15.6k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  15.6k|   return std::span{r}.size_bytes();
   75|  15.6k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIKhLm8EEEEEvOT0_:
   86|   146k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   146k|   const std::span s{r};
   88|   146k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   146k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   146k|   } else {
   91|   146k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   146k|   }
   93|   146k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanImLm1EEEJRNS3_IKhLm8EEEEEEvOT_DpOT0_:
  107|  73.0k|{
  108|  73.0k|   const std::span s0{r0};
  109|       |
  110|  73.0k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  73.0k|      constexpr size_t expected_size = s0.size_bytes();
  112|  73.0k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  73.0k|   } else {
  114|  73.0k|      const size_t expected_size = s0.size_bytes();
  115|  73.0k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  73.0k|                      "memory regions don't have equal lengths");
  117|  73.0k|   }
  118|  73.0k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanImLm1EEEEEmOT_:
   73|  73.0k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  73.0k|   return std::span{r}.size_bytes();
   75|  73.0k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm2ERNSt3__14spanIKhLm2EEEEEvOT0_:
   86|  2.45k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  2.45k|   const std::span s{r};
   88|  2.45k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  2.45k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  2.45k|   } else {
   91|  2.45k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  2.45k|   }
   93|  2.45k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanItLm1EEEJRNS3_IKhLm2EEEEEEvOT_DpOT0_:
  107|  1.22k|{
  108|  1.22k|   const std::span s0{r0};
  109|       |
  110|  1.22k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  1.22k|      constexpr size_t expected_size = s0.size_bytes();
  112|  1.22k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  1.22k|   } else {
  114|  1.22k|      const size_t expected_size = s0.size_bytes();
  115|  1.22k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  1.22k|                      "memory regions don't have equal lengths");
  117|  1.22k|   }
  118|  1.22k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanItLm1EEEEEmOT_:
   73|  1.22k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  1.22k|   return std::span{r}.size_bytes();
   75|  1.22k|}

_ZN5Botan17DataSource_MemoryC2EPKhm:
  118|  47.8k|      DataSource_Memory(const uint8_t in[], size_t length) : m_source(in, in + length), m_offset(0) {}
_ZN5Botan17DataSource_MemoryC2ENSt3__16vectorIhNS_16secure_allocatorIhEEEE:
  124|  99.4k|      explicit DataSource_Memory(secure_vector<uint8_t> in) : m_source(std::move(in)), m_offset(0) {}
_ZN5Botan17DataSource_MemoryC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  136|  2.98k|      explicit DataSource_Memory(const std::vector<uint8_t>& in) : m_source(in.begin(), in.end()), m_offset(0) {}
_ZN5Botan10DataSourceC2Ev:
   91|   250k|      DataSource() = default;
_ZN5Botan10DataSourceD2Ev:
   92|   250k|      virtual ~DataSource() = default;

_ZN5Botan11DER_Encoder14start_sequenceEv:
   65|  22.3k|      DER_Encoder& start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  163|  3.38k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const std::vector<uint8_t>& rep) {
  164|  3.38k|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  165|  3.38k|      }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS_16secure_allocatorIhEEEE:
  167|  3.38k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const secure_vector<uint8_t>& rep) {
  168|  3.38k|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  169|  3.38k|      }
_ZN5Botan11DER_Encoder12DER_SequenceC2EOS1_:
  192|  48.1k|                  m_set_contents(std::move(seq.m_set_contents)) {}
_ZN5Botan11DER_Encoder6encodeINSt3__19allocatorIhEEEERS0_RKNS2_6vectorIhT_EENS_9ASN1_TypeE:
   99|  3.38k|      DER_Encoder& encode(const std::vector<uint8_t, Alloc>& vec, ASN1_Type real_type) {
  100|  3.38k|         return encode(vec.data(), vec.size(), real_type);
  101|  3.38k|      }
_ZN5Botan11DER_Encoder9raw_bytesINSt3__19allocatorIhEEEERS0_RKNS2_6vectorIhT_EE:
   88|  6.77k|      DER_Encoder& raw_bytes(const std::vector<uint8_t, Alloc>& val) {
   89|  6.77k|         return raw_bytes(val.data(), val.size());
   90|  6.77k|      }

_ZNK5Botan9Exception4whatEv:
   93|  2.11k|      const char* what() const noexcept override { return m_msg.c_str(); }
_ZN5Botan12Lookup_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  237|      1|      explicit Lookup_Error(std::string_view err) : Exception(err) {}

_ZN5Botan10hex_encodeENSt3__14spanIKhLm18446744073709551615EEEb:
   43|  6.77k|inline std::string hex_encode(std::span<const uint8_t> input, bool uppercase = true) {
   44|  6.77k|   return hex_encode(input.data(), input.size(), uppercase);
   45|  6.77k|}

_ZN5Botan11clear_bytesEPvm:
  103|  1.20M|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  1.20M|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 1.19M, False: 16.2k]
  ------------------
  105|  1.19M|      std::memset(ptr, 0, bytes);
  106|  1.19M|   }
  107|  1.20M|}
_ZN5Botan22cast_uint8_ptr_to_charEPKh:
  276|  17.4k|inline const char* cast_uint8_ptr_to_char(const uint8_t* b) {
  277|  17.4k|   return reinterpret_cast<const char*>(b);
  278|  17.4k|}
_ZN5Botan9clear_memImEEvPT_m:
  120|  1.15M|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  1.15M|   clear_bytes(ptr, sizeof(T) * n);
  122|  1.15M|}
_ZN5Botan8copy_memIhEEvPT_PKS1_m:
  146|  6.87M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  6.87M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  6.87M|   do {                                                                                          \
  |  |   79|  13.3M|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 6.68M, False: 190k]
  |  |  |  Branch (79:23): [True: 6.68M, False: 0]
  |  |  |  Branch (79:23): [True: 6.68M, False: 0]
  |  |  ------------------
  |  |   80|  6.87M|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  6.87M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  6.87M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 6.85M, False: 16.7k]
  |  Branch (149:24): [True: 6.81M, False: 39.7k]
  |  Branch (149:42): [True: 6.68M, False: 133k]
  ------------------
  150|  6.68M|      std::memmove(out, in, sizeof(T) * n);
  151|  6.68M|   }
  152|  6.87M|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|  53.7k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  53.7k|   clear_bytes(ptr, sizeof(T) * n);
  122|  53.7k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEET_OT0_:
  209|   982k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|   982k|   ToT dst;
  211|   982k|   typecast_copy(dst, src);
  212|   982k|   return dst;
  213|   982k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEEvRT_OT0_:
  188|   982k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|   982k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|   982k|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm1EEERNS2_IKhLm4EEEEEvOT_OT0_:
  176|   982k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|   982k|   ranges::assert_equal_byte_lengths(out, in);
  178|   982k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|   982k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEEmEEvOT_RKT0_:
  199|  46.0k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|  46.0k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|  46.0k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEENS2_IKmLm1EEEEEvOT_OT0_:
  176|  46.0k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  46.0k|   ranges::assert_equal_byte_lengths(out, in);
  178|  46.0k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  46.0k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEEjEEvOT_RKT0_:
  199|   122k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|   122k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|   122k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEENS2_IKjLm1EEEEEvOT_OT0_:
  176|   122k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|   122k|   ranges::assert_equal_byte_lengths(out, in);
  178|   122k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|   122k|}
_ZN5Botan13typecast_copyIjEEvPT_PKhm:
  228|  15.6k|{
  229|       |   // asserts that *in and *out point to the correct amount of memory
  230|  15.6k|   typecast_copy(std::span<T>(out, N), std::span<const uint8_t>(in, N * sizeof(T)));
  231|  15.6k|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm18446744073709551615EEENS2_IKhLm18446744073709551615EEEEEvOT_OT0_:
  176|  15.6k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  15.6k|   ranges::assert_equal_byte_lengths(out, in);
  178|  15.6k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  15.6k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEET_OT0_:
  209|  73.0k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  73.0k|   ToT dst;
  211|  73.0k|   typecast_copy(dst, src);
  212|  73.0k|   return dst;
  213|  73.0k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEEvRT_OT0_:
  188|  73.0k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  73.0k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  73.0k|}
_ZN5Botan13typecast_copyINSt3__14spanImLm1EEERNS2_IKhLm8EEEEEvOT_OT0_:
  176|  73.0k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  73.0k|   ranges::assert_equal_byte_lengths(out, in);
  178|  73.0k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  73.0k|}
_ZN5Botan8copy_memImEEvPT_PKS1_m:
  146|   456k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|   456k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|   456k|   do {                                                                                          \
  |  |   79|   912k|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 456k, False: 0]
  |  |  |  Branch (79:23): [True: 456k, False: 0]
  |  |  |  Branch (79:23): [True: 456k, False: 0]
  |  |  ------------------
  |  |   80|   456k|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|   456k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|   456k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 456k, False: 0]
  |  Branch (149:24): [True: 456k, False: 0]
  |  Branch (149:42): [True: 456k, False: 0]
  ------------------
  150|   456k|      std::memmove(out, in, sizeof(T) * n);
  151|   456k|   }
  152|   456k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEET_OT0_:
  209|  1.22k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  1.22k|   ToT dst;
  211|  1.22k|   typecast_copy(dst, src);
  212|  1.22k|   return dst;
  213|  1.22k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEEvRT_OT0_:
  188|  1.22k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  1.22k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.22k|}
_ZN5Botan13typecast_copyINSt3__14spanItLm1EEERNS2_IKhLm2EEEEEvOT_OT0_:
  176|  1.22k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  1.22k|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.22k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.22k|}
_ZN5Botan9clear_memIjEEvPT_m:
  120|      1|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|      1|   clear_bytes(ptr, sizeof(T) * n);
  122|      1|}
_ZN5Botan8copy_memIiEEvPT_PKS1_m:
  146|  1.53k|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  1.53k|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  1.53k|   do {                                                                                          \
  |  |   79|  3.07k|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  |  Branch (79:23): [True: 1.53k, False: 0]
  |  |  ------------------
  |  |   80|  1.53k|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  1.53k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  1.53k|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 1.53k, False: 0]
  |  Branch (149:24): [True: 1.53k, False: 0]
  |  Branch (149:42): [True: 1.53k, False: 0]
  ------------------
  150|  1.53k|      std::memmove(out, in, sizeof(T) * n);
  151|  1.53k|   }
  152|  1.53k|}

_ZN5Botan4OCSP6CertIDC2Ev:
   27|     14|      CertID() = default;

_ZNK5Botan10Public_Key13message_partsEv:
  177|  2.89k|      virtual size_t message_parts() const { return 1; }
_ZNK5Botan10Public_Key17message_part_sizeEv:
  188|  1.44k|      virtual size_t message_part_size() const { return 0; }
_ZNK5Botan10Public_Key29default_x509_signature_formatEv:
  190|  1.44k|      virtual Signature_Format default_x509_signature_format() const {
  191|  1.44k|         return (this->message_parts() >= 2) ? Signature_Format::DerSequence : Signature_Format::Standard;
  ------------------
  |  Branch (191:17): [True: 0, False: 1.44k]
  ------------------
  192|  1.44k|      }
_ZN5Botan22create_hex_fingerprintENSt3__14spanIKhLm18446744073709551615EEENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
  386|  6.77k|inline std::string create_hex_fingerprint(std::span<const uint8_t> vec, std::string_view hash_name) {
  387|  6.77k|   return create_hex_fingerprint(vec.data(), vec.size(), hash_name);
  388|  6.77k|}
_ZN5Botan14Asymmetric_KeyD2Ev:
   61|  1.71k|      virtual ~Asymmetric_Key() = default;

_ZN5Botan6PK_Ops12VerificationD2Ev:
   88|  1.44k|      virtual ~Verification() = default;

_ZN5Botan15Key_ConstraintsC2ENS0_4BitsE:
  139|    221|      Key_Constraints(Key_Constraints::Bits bits) : m_value(bits) {}
_ZN5Botan15Key_ConstraintsC2Ej:
  141|     48|      explicit Key_Constraints(uint32_t bits) : m_value(bits) {}
_ZN5Botan15Key_ConstraintsC2Ev:
  143|  3.67k|      Key_Constraints() : m_value(0) {}
_ZNK5Botan15Key_Constraints8includesENS0_4BitsE:
  158|      9|      bool includes(Key_Constraints::Bits other) const { return (m_value & other) == other; }
_ZNK5Botan15Key_Constraints5emptyEv:
  165|     46|      bool empty() const { return m_value == 0; }

_ZNK5Botan7X509_DN8get_bitsEv:
   62|  7.16k|      const std::vector<uint8_t>& get_bits() const { return m_dn_bits; }
_ZNK5Botan7X509_DN5emptyEv:
   66|    464|      bool empty() const { return m_rdn.empty(); }
_ZNK5Botan7X509_DN7dn_infoEv:
   70|    770|      const std::vector<std::pair<OID, ASN1_String>>& dn_info() const { return m_rdn; }
_ZN5Botan14GeneralSubtreeC2Ev:
  246|  1.00k|      GeneralSubtree() : m_base(), m_minimum(0), m_maximum(std::numeric_limits<std::size_t>::max()) {}
_ZN5Botan15NameConstraintsC2Ev:
  299|  4.88k|      NameConstraints() : m_permitted_subtrees(), m_excluded_subtrees() {}
_ZN5Botan15NameConstraintsC2EONSt3__16vectorINS_14GeneralSubtreeENS1_9allocatorIS3_EEEES7_:
  308|    167|            m_permitted_subtrees(permitted_subtrees), m_excluded_subtrees(excluded_subtrees) {}
_ZN5Botan10Extensions15Extensions_InfoC2EbRKNSt3__16vectorIhNS2_9allocatorIhEEEENS2_10unique_ptrINS_21Certificate_ExtensionENS2_14default_deleteISA_EEEE:
  538|  14.3k|                  m_obj(std::move(ext)), m_bits(encoding), m_critical(critical) {}
_ZNK5Botan10Extensions15Extensions_Info3objEv:
  544|  2.13k|            const Certificate_Extension& obj() const {
  545|  2.13k|               BOTAN_ASSERT_NONNULL(m_obj.get());
  ------------------
  |  |   87|  2.13k|   do {                                                                                   \
  |  |   88|  2.13k|      if((ptr) == nullptr)                                                                \
  |  |  ------------------
  |  |  |  Branch (88:10): [True: 0, False: 2.13k]
  |  |  ------------------
  |  |   89|  2.13k|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |   90|  2.13k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  546|  2.13k|               return *m_obj;
  547|  2.13k|            }
_ZN5Botan7X509_DNC2Ev:
   39|  16.6k|      X509_DN() = default;
_ZN5Botan10ExtensionsC2Ev:
  517|  7.76k|      Extensions() = default;
_ZN5Botan10ExtensionsaSERKS0_:
  520|     15|      Extensions& operator=(const Extensions&) = default;
_ZN5Botan21Certificate_ExtensionD2Ev:
  371|  20.3k|      virtual ~Certificate_Extension() = default;
_ZN5Botan11GeneralNameC2Ev:
  194|  1.00k|      GeneralName() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension9Key_UsageEEEPKT_RKNS_3OIDE:
  397|  3.39k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.39k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 81, False: 3.30k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     81|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 61, False: 20]
  ------------------
  401|     61|               return nullptr;
  402|     61|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 20, False: 0]
  ------------------
  403|     20|               return extn_as_T;
  404|     20|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     81|         }
  408|       |
  409|  3.30k|         return nullptr;
  410|  3.39k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension14Subject_Key_IDEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 101, False: 3.28k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    101|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 76, False: 25]
  ------------------
  401|     76|               return nullptr;
  402|     76|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 25, False: 0]
  ------------------
  403|     25|               return extn_as_T;
  404|     25|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    101|         }
  408|       |
  409|  3.28k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Authority_Key_IDEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 164, False: 3.22k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    164|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 140, False: 24]
  ------------------
  401|    140|               return nullptr;
  402|    140|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 24, False: 0]
  ------------------
  403|     24|               return extn_as_T;
  404|     24|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    164|         }
  408|       |
  409|  3.22k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Name_ConstraintsEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 257, False: 3.13k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    257|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 224, False: 33]
  ------------------
  401|    224|               return nullptr;
  402|    224|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 33, False: 0]
  ------------------
  403|     33|               return extn_as_T;
  404|     33|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    257|         }
  408|       |
  409|  3.13k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension17Basic_ConstraintsEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 59, False: 3.32k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     59|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 15, False: 44]
  ------------------
  401|     15|               return nullptr;
  402|     44|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 44, False: 0]
  ------------------
  403|     44|               return extn_as_T;
  404|     44|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     59|         }
  408|       |
  409|  3.32k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension23Issuer_Alternative_NameEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 460, False: 2.92k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    460|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 191, False: 269]
  ------------------
  401|    191|               return nullptr;
  402|    269|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 269, False: 0]
  ------------------
  403|    269|               return extn_as_T;
  404|    269|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    460|         }
  408|       |
  409|  2.92k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension24Subject_Alternative_NameEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 237, False: 3.15k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    237|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 160, False: 77]
  ------------------
  401|    160|               return nullptr;
  402|    160|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 77, False: 0]
  ------------------
  403|     77|               return extn_as_T;
  404|     77|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    237|         }
  408|       |
  409|  3.15k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension18Extended_Key_UsageEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 62, False: 3.32k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     62|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 39, False: 23]
  ------------------
  401|     39|               return nullptr;
  402|     39|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 23, False: 0]
  ------------------
  403|     23|               return extn_as_T;
  404|     23|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     62|         }
  408|       |
  409|  3.32k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension20Certificate_PoliciesEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 177, False: 3.21k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    177|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 150, False: 27]
  ------------------
  401|    150|               return nullptr;
  402|    150|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 27, False: 0]
  ------------------
  403|     27|               return extn_as_T;
  404|     27|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    177|         }
  408|       |
  409|  3.21k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension28Authority_Information_AccessEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 58, False: 3.33k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     58|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 25, False: 33]
  ------------------
  401|     25|               return nullptr;
  402|     33|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 33, False: 0]
  ------------------
  403|     33|               return extn_as_T;
  404|     33|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     58|         }
  408|       |
  409|  3.33k|         return nullptr;
  410|  3.38k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension23CRL_Distribution_PointsEEEPKT_RKNS_3OIDE:
  397|  3.38k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  3.38k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 478, False: 2.91k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    478|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 365, False: 113]
  ------------------
  401|    365|               return nullptr;
  402|    365|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 113, False: 0]
  ------------------
  403|    113|               return extn_as_T;
  404|    113|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    478|         }
  408|       |
  409|  2.91k|         return nullptr;
  410|  3.38k|      }

_ZN5Botan11PK_Verifier14verify_messageENSt3__14spanIKhLm18446744073709551615EEES4_:
  325|  1.44k|      bool verify_message(std::span<const uint8_t> msg, std::span<const uint8_t> sig) {
  326|  1.44k|         return verify_message(msg.data(), msg.size(), sig.data(), sig.size());
  327|  1.44k|      }

_ZNK5Botan15Modular_Reducer8multiplyERKNS_6BigIntES3_:
   30|  1.45k|      BigInt multiply(const BigInt& x, const BigInt& y) const { return reduce(x * y); }
_ZNK5Botan15Modular_Reducer6squareERKNS_6BigIntE:
   43|  1.45k|      BigInt square(const BigInt& x) const { return reduce(Botan::square(x)); }

_ZN5Botan16secure_allocatorImE10deallocateEPmm:
   47|  63.0k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIhE8allocateEm:
   45|   621k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
   47|   621k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE8allocateEm:
   45|  63.0k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5BotanneIhhEEbRKNS_16secure_allocatorIT_EERKNS1_IT0_EE:
   56|  88.1k|inline bool operator!=(const secure_allocator<T>&, const secure_allocator<U>&) {
   57|  88.1k|   return false;
   58|  88.1k|}
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPS5_T1_EE:
   98|   106k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<T*, L>& in) {
   99|   106k|   out.insert(out.end(), in.first, in.first + in.second);
  100|   106k|   return out;
  101|   106k|}
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPKS5_T1_EE:
   92|  49.4k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<const T*, L>& in) {
   93|  49.4k|   out.insert(out.end(), in.first, in.first + in.second);
   94|  49.4k|   return out;
   95|  49.4k|}
_ZN5Botan16secure_allocatorIjE10deallocateEPjm:
   47|  14.9k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIjE8allocateEm:
   45|  14.9k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }

_ZN5Botan14Cert_Extension17Basic_ConstraintsC2Ebm:
   31|    235|      Basic_Constraints(bool ca = false, size_t limit = 0) : m_is_ca(ca), m_path_limit(limit) {}
_ZNK5Botan14Cert_Extension17Basic_Constraints9get_is_caEv:
   33|     44|      bool get_is_ca() const { return m_is_ca; }
_ZN5Botan14Cert_Extension17Basic_Constraints10static_oidEv:
   37|  14.1k|      static OID static_oid() { return OID("2.5.29.19"); }
_ZNK5Botan14Cert_Extension17Basic_Constraints8oid_nameEv:
   42|     44|      std::string oid_name() const override { return "X509v3.BasicConstraints"; }
_ZN5Botan14Cert_Extension9Key_UsageC2Ev:
   62|    221|      explicit Key_Usage() : m_constraints(Key_Constraints::None) {}
_ZNK5Botan14Cert_Extension9Key_Usage15get_constraintsEv:
   64|     20|      Key_Constraints get_constraints() const { return m_constraints; }
_ZN5Botan14Cert_Extension9Key_Usage10static_oidEv:
   66|  16.5k|      static OID static_oid() { return OID("2.5.29.15"); }
_ZNK5Botan14Cert_Extension9Key_Usage8oid_nameEv:
   71|     20|      std::string oid_name() const override { return "X509v3.KeyUsage"; }
_ZNK5Botan14Cert_Extension14Subject_Key_ID10get_key_idEv:
   96|     25|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension14Subject_Key_ID10static_oidEv:
   98|  17.7k|      static OID static_oid() { return OID("2.5.29.14"); }
_ZNK5Botan14Cert_Extension14Subject_Key_ID8oid_nameEv:
  103|     25|      std::string oid_name() const override { return "X509v3.SubjectKeyIdentifier"; }
_ZNK5Botan14Cert_Extension16Authority_Key_ID10get_key_idEv:
  126|     24|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension16Authority_Key_ID10static_oidEv:
  128|  13.7k|      static OID static_oid() { return OID("2.5.29.35"); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID8oid_nameEv:
  133|     24|      std::string oid_name() const override { return "X509v3.AuthorityKeyIdentifier"; }
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name12get_alt_nameEv:
  148|     77|      const AlternativeName& get_alt_name() const { return m_alt_name; }
_ZN5Botan14Cert_Extension24Subject_Alternative_Name10static_oidEv:
  150|  16.3k|      static OID static_oid() { return OID("2.5.29.17"); }
_ZN5Botan14Cert_Extension24Subject_Alternative_NameC2ERKNS_15AlternativeNameE:
  158|    748|      explicit Subject_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name8oid_nameEv:
  161|     77|      std::string oid_name() const override { return "X509v3.SubjectAlternativeName"; }
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name12get_alt_nameEv:
  176|    269|      const AlternativeName& get_alt_name() const { return m_alt_name; }
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name10static_oidEv:
  178|  15.5k|      static OID static_oid() { return OID("2.5.29.18"); }
_ZN5Botan14Cert_Extension23Issuer_Alternative_NameC2ERKNS_15AlternativeNameE:
  186|  1.42k|      explicit Issuer_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name8oid_nameEv:
  189|    269|      std::string oid_name() const override { return "X509v3.IssuerAlternativeName"; }
_ZNK5Botan14Cert_Extension18Extended_Key_Usage18object_identifiersEv:
  212|     23|      const std::vector<OID>& object_identifiers() const { return m_oids; }
_ZN5Botan14Cert_Extension18Extended_Key_Usage10static_oidEv:
  214|  9.90k|      static OID static_oid() { return OID("2.5.29.37"); }
_ZNK5Botan14Cert_Extension18Extended_Key_Usage8oid_nameEv:
  219|     23|      std::string oid_name() const override { return "X509v3.ExtendedKeyUsage"; }
_ZNK5Botan14Cert_Extension16Name_Constraints20get_name_constraintsEv:
  248|     33|      const NameConstraints& get_name_constraints() const { return m_name_constraints; }
_ZN5Botan14Cert_Extension16Name_Constraints10static_oidEv:
  250|  13.5k|      static OID static_oid() { return OID("2.5.29.30"); }
_ZNK5Botan14Cert_Extension16Name_Constraints8oid_nameEv:
  255|     33|      std::string oid_name() const override { return "X509v3.NameConstraints"; }
_ZNK5Botan14Cert_Extension20Certificate_Policies15get_policy_oidsEv:
  278|     27|      const std::vector<OID>& get_policy_oids() const { return m_oids; }
_ZN5Botan14Cert_Extension20Certificate_Policies10static_oidEv:
  280|  10.3k|      static OID static_oid() { return OID("2.5.29.32"); }
_ZNK5Botan14Cert_Extension20Certificate_Policies8oid_nameEv:
  291|     27|      std::string oid_name() const override { return "X509v3.CertificatePolicies"; }
_ZNK5Botan14Cert_Extension28Authority_Information_Access14ocsp_responderEv:
  316|     33|      std::string ocsp_responder() const { return m_ocsp_responder; }
_ZN5Botan14Cert_Extension28Authority_Information_Access10static_oidEv:
  318|  9.70k|      static OID static_oid() { return OID("1.3.6.1.5.5.7.1.1"); }
_ZNK5Botan14Cert_Extension28Authority_Information_Access10ca_issuersEv:
  322|     33|      const std::vector<std::string>& ca_issuers() const { return m_ca_issuers; }
_ZNK5Botan14Cert_Extension28Authority_Information_Access8oid_nameEv:
  325|     33|      std::string oid_name() const override { return "PKIX.AuthorityInformationAccess"; }
_ZN5Botan14Cert_Extension10CRL_NumberC2Ev:
  343|     83|      CRL_Number() : m_has_value(false), m_crl_number(0) {}
_ZN5Botan14Cert_Extension10CRL_Number10static_oidEv:
  349|  10.5k|      static OID static_oid() { return OID("2.5.29.20"); }
_ZN5Botan14Cert_Extension14CRL_ReasonCodeC2ENS_8CRL_CodeE:
  374|     81|      explicit CRL_ReasonCode(CRL_Code r = CRL_Code::Unspecified) : m_reason(r) {}
_ZN5Botan14Cert_Extension14CRL_ReasonCode10static_oidEv:
  378|  10.4k|      static OID static_oid() { return OID("2.5.29.21"); }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_PointC2ERKNS_15AlternativeNameE:
  404|  1.50k|            explicit Distribution_Point(const AlternativeName& name = AlternativeName()) : m_point(name) {}
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_Point5pointEv:
  406|    667|            const AlternativeName& point() const { return m_point; }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points21crl_distribution_urlsEv:
  422|    113|      const std::vector<std::string>& crl_distribution_urls() const { return m_crl_distribution_urls; }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points10static_oidEv:
  424|  12.3k|      static OID static_oid() { return OID("2.5.29.31"); }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points8oid_nameEv:
  429|    113|      std::string oid_name() const override { return "X509v3.CRLDistributionPoints"; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point10static_oidEv:
  457|  7.03k|      static OID static_oid() { return OID("2.5.29.28"); }
_ZN5Botan14Cert_Extension17Unknown_ExtensionC2ERKNS_3OIDEb:
  509|  12.0k|      Unknown_Extension(const OID& oid, bool critical) : m_oid(oid), m_critical(critical) {}
_ZNK5Botan14Cert_Extension17Unknown_Extension8oid_nameEv:
  543|  1.44k|      std::string oid_name() const override { return ""; }
_ZN5Botan14Cert_Extension14Subject_Key_IDC2Ev:
   86|  1.19k|      Subject_Key_ID() = default;
_ZN5Botan14Cert_Extension16Authority_Key_IDC2Ev:
  122|    252|      Authority_Key_ID() = default;
_ZN5Botan14Cert_Extension16Name_ConstraintsC2Ev:
  238|  1.21k|      Name_Constraints() = default;
_ZN5Botan14Cert_Extension23CRL_Distribution_PointsC2Ev:
  416|  1.87k|      CRL_Distribution_Points() = default;
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_PointC2Ev:
  446|    105|      CRL_Issuing_Distribution_Point() = default;
_ZN5Botan14Cert_Extension20Certificate_PoliciesC2Ev:
  274|    410|      Certificate_Policies() = default;
_ZN5Botan14Cert_Extension18Extended_Key_UsageC2Ev:
  208|    207|      Extended_Key_Usage() = default;
_ZN5Botan14Cert_Extension28Authority_Information_AccessC2Ev:
  310|    265|      Authority_Information_Access() = default;

_ZN5Botan4X5098load_keyERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
   58|  2.98k|inline std::unique_ptr<Public_Key> load_key(const std::vector<uint8_t>& enc) {
   59|  2.98k|   DataSource_Memory source(enc);
   60|  2.98k|   return X509::load_key(source);
   61|  2.98k|}

_ZNK5Botan11X509_Object9signatureEv:
   37|  4.83k|      const std::vector<uint8_t>& signature() const { return m_sig; }
_ZNK5Botan11X509_Object11signed_bodyEv:
   42|  7.06k|      const std::vector<uint8_t>& signed_body() const { return m_tbs_bits; }
_ZNK5Botan11X509_Object19signature_algorithmEv:
   47|  8.46k|      const AlgorithmIdentifier& signature_algorithm() const { return m_sig_algo; }
_ZN5Botan11X509_ObjectC2ERKS0_:
   96|  5.67k|      X509_Object(const X509_Object&) = default;
_ZN5Botan11X509_ObjectD2Ev:
  103|  9.78k|      ~X509_Object() override = default;
_ZN5Botan11X509_ObjectC2Ev:
  121|  4.10k|      X509_Object() = default;

_ZN5Botan16X509_CertificateC2ERKS0_:
  405|  5.67k|      X509_Certificate(const X509_Certificate& other) = default;

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

_Z4fuzzPKhm:
   11|  4.97k|void fuzz(const uint8_t in[], size_t len) {
   12|  4.97k|   try {
   13|  4.97k|      Botan::OCSP::Response response(in, len);
   14|  4.97k|   } catch(Botan::Exception& e) {}
   15|  4.97k|}

_ZN5Botan19AlgorithmIdentifierC2ERKNS_3OIDERKNSt3__16vectorIhNS4_9allocatorIhEEEE:
   19|      3|      m_oid(oid), m_parameters(param) {}
_ZN5Botan19AlgorithmIdentifierC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS1_6vectorIhNS1_9allocatorIhEEEE:
   25|      3|      AlgorithmIdentifier(OID::from_string(oid), param) {}
_ZN5Botan19AlgorithmIdentifierC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS0_15Encoding_OptionE:
   42|      3|      m_oid(OID::from_string(oid)), m_parameters() {
   43|      3|   const uint8_t DER_NULL[] = {0x05, 0x00};
   44|       |
   45|      3|   if(option == USE_NULL_PARAM) {
  ------------------
  |  Branch (45:7): [True: 3, False: 0]
  ------------------
   46|      3|      m_parameters.assign(DER_NULL, DER_NULL + 2);
   47|      3|   }
   48|      3|}
_ZNK5Botan19AlgorithmIdentifier19parameters_are_nullEv:
   50|  6.90k|bool AlgorithmIdentifier::parameters_are_null() const {
   51|  6.90k|   return (m_parameters.size() == 2 && (m_parameters[0] == 0x05) && (m_parameters[1] == 0x00));
  ------------------
  |  Branch (51:12): [True: 6.89k, False: 11]
  |  Branch (51:40): [True: 6.85k, False: 35]
  |  Branch (51:69): [True: 6.85k, False: 1]
  ------------------
   52|  6.90k|}
_ZN5BotaneqERKNS_19AlgorithmIdentifierES2_:
   54|  3.61k|bool operator==(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   55|  3.61k|   if(a1.oid() != a2.oid()) {
  ------------------
  |  Branch (55:7): [True: 12, False: 3.60k]
  ------------------
   56|     12|      return false;
   57|     12|   }
   58|       |
   59|       |   /*
   60|       |   * Treat NULL and empty as equivalent
   61|       |   */
   62|  3.60k|   if(a1.parameters_are_null_or_empty() && a2.parameters_are_null_or_empty()) {
  ------------------
  |  Branch (62:7): [True: 3.56k, False: 43]
  |  Branch (62:44): [True: 3.55k, False: 4]
  ------------------
   63|  3.55k|      return true;
   64|  3.55k|   }
   65|       |
   66|     47|   return (a1.parameters() == a2.parameters());
   67|  3.60k|}
_ZN5BotanneERKNS_19AlgorithmIdentifierES2_:
   69|  3.61k|bool operator!=(const AlgorithmIdentifier& a1, const AlgorithmIdentifier& a2) {
   70|  3.61k|   return !(a1 == a2);
   71|  3.61k|}
_ZNK5Botan19AlgorithmIdentifier11encode_intoERNS_11DER_EncoderE:
   76|  3.39k|void AlgorithmIdentifier::encode_into(DER_Encoder& codec) const {
   77|  3.39k|   codec.start_sequence().encode(oid()).raw_bytes(parameters()).end_cons();
   78|  3.39k|}
_ZN5Botan19AlgorithmIdentifier11decode_fromERNS_11BER_DecoderE:
   83|  17.7k|void AlgorithmIdentifier::decode_from(BER_Decoder& codec) {
   84|  17.7k|   codec.start_sequence().decode(m_oid).raw_bytes(m_parameters).end_cons();
   85|  17.7k|}

_ZNK5Botan11ASN1_Object10BER_encodeEv:
   19|  3.39k|std::vector<uint8_t> ASN1_Object::BER_encode() const {
   20|  3.39k|   std::vector<uint8_t> output;
   21|  3.39k|   DER_Encoder der(output);
   22|  3.39k|   this->encode_into(der);
   23|  3.39k|   return output;
   24|  3.39k|}
_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   29|   150k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   30|   150k|   if(this->is_a(expected_type_tag, expected_class_tag) == false) {
  ------------------
  |  Branch (30:7): [True: 3.74k, False: 146k]
  ------------------
   31|  3.74k|      std::stringstream msg;
   32|       |
   33|  3.74k|      msg << "Tag mismatch when decoding " << descr << " got ";
   34|       |
   35|  3.74k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (35:10): [True: 429, False: 3.31k]
  |  Branch (35:49): [True: 429, False: 0]
  ------------------
   36|    429|         msg << "EOF";
   37|  3.31k|      } else {
   38|  3.31k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (38:13): [True: 626, False: 2.68k]
  |  Branch (38:53): [True: 1.35k, False: 1.33k]
  ------------------
   39|  1.97k|            msg << asn1_tag_to_string(m_type_tag);
   40|  1.97k|         } else {
   41|  1.33k|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   42|  1.33k|         }
   43|       |
   44|  3.31k|         msg << "/" << asn1_class_to_string(m_class_tag);
   45|  3.31k|      }
   46|       |
   47|  3.74k|      msg << " expected ";
   48|       |
   49|  3.74k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (49:10): [True: 1.37k, False: 2.36k]
  |  Branch (49:57): [True: 2.24k, False: 121]
  ------------------
   50|  3.61k|         msg << asn1_tag_to_string(expected_type_tag);
   51|  3.61k|      } else {
   52|    121|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   53|    121|      }
   54|       |
   55|  3.74k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   56|       |
   57|  3.74k|      throw BER_Decoding_Error(msg.str());
   58|  3.74k|   }
   59|   150k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   61|   240k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   62|   240k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (62:12): [True: 167k, False: 73.5k]
  |  Branch (62:47): [True: 165k, False: 1.40k]
  ------------------
   63|   240k|}
_ZNK5Botan10BER_Object4is_aEiNS_10ASN1_ClassE:
   65|  49.1k|bool BER_Object::is_a(int expected_type_tag, ASN1_Class expected_class_tag) const {
   66|  49.1k|   return is_a(ASN1_Type(expected_type_tag), expected_class_tag);
   67|  49.1k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   69|   304k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   70|   304k|   m_type_tag = type_tag;
   71|   304k|   m_class_tag = class_tag;
   72|   304k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   74|  7.05k|std::string asn1_class_to_string(ASN1_Class type) {
   75|  7.05k|   switch(type) {
   76|  2.00k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (76:7): [True: 2.00k, False: 5.04k]
  ------------------
   77|  2.00k|         return "UNIVERSAL";
   78|  3.59k|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (78:7): [True: 3.59k, False: 3.45k]
  ------------------
   79|  3.59k|         return "CONSTRUCTED";
   80|    130|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (80:7): [True: 130, False: 6.92k]
  ------------------
   81|    130|         return "CONTEXT_SPECIFIC";
   82|    156|      case ASN1_Class::Application:
  ------------------
  |  Branch (82:7): [True: 156, False: 6.89k]
  ------------------
   83|    156|         return "APPLICATION";
   84|    405|      case ASN1_Class::Private:
  ------------------
  |  Branch (84:7): [True: 405, False: 6.64k]
  ------------------
   85|    405|         return "PRIVATE";
   86|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (86:7): [True: 0, False: 7.05k]
  ------------------
   87|      0|         return "NO_OBJECT";
   88|    762|      default:
  ------------------
  |  Branch (88:7): [True: 762, False: 6.28k]
  ------------------
   89|    762|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   90|  7.05k|   }
   91|  7.05k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   93|  5.59k|std::string asn1_tag_to_string(ASN1_Type type) {
   94|  5.59k|   switch(type) {
   95|  2.29k|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (95:7): [True: 2.29k, False: 3.30k]
  ------------------
   96|  2.29k|         return "SEQUENCE";
   97|       |
   98|    298|      case ASN1_Type::Set:
  ------------------
  |  Branch (98:7): [True: 298, False: 5.30k]
  ------------------
   99|    298|         return "SET";
  100|       |
  101|     35|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (101:7): [True: 35, False: 5.56k]
  ------------------
  102|     35|         return "PRINTABLE STRING";
  103|       |
  104|     48|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (104:7): [True: 48, False: 5.55k]
  ------------------
  105|     48|         return "NUMERIC STRING";
  106|       |
  107|     98|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (107:7): [True: 98, False: 5.50k]
  ------------------
  108|     98|         return "IA5 STRING";
  109|       |
  110|     37|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (110:7): [True: 37, False: 5.56k]
  ------------------
  111|     37|         return "T61 STRING";
  112|       |
  113|    102|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (113:7): [True: 102, False: 5.49k]
  ------------------
  114|    102|         return "UTF8 STRING";
  115|       |
  116|     49|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (116:7): [True: 49, False: 5.54k]
  ------------------
  117|     49|         return "VISIBLE STRING";
  118|       |
  119|     36|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (119:7): [True: 36, False: 5.56k]
  ------------------
  120|     36|         return "BMP STRING";
  121|       |
  122|     20|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (122:7): [True: 20, False: 5.57k]
  ------------------
  123|     20|         return "UNIVERSAL STRING";
  124|       |
  125|     25|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (125:7): [True: 25, False: 5.57k]
  ------------------
  126|     25|         return "UTC TIME";
  127|       |
  128|     48|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (128:7): [True: 48, False: 5.55k]
  ------------------
  129|     48|         return "GENERALIZED TIME";
  130|       |
  131|  1.33k|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (131:7): [True: 1.33k, False: 4.25k]
  ------------------
  132|  1.33k|         return "OCTET STRING";
  133|       |
  134|    183|      case ASN1_Type::BitString:
  ------------------
  |  Branch (134:7): [True: 183, False: 5.41k]
  ------------------
  135|    183|         return "BIT STRING";
  136|       |
  137|    162|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (137:7): [True: 162, False: 5.43k]
  ------------------
  138|    162|         return "ENUMERATED";
  139|       |
  140|    163|      case ASN1_Type::Integer:
  ------------------
  |  Branch (140:7): [True: 163, False: 5.43k]
  ------------------
  141|    163|         return "INTEGER";
  142|       |
  143|     18|      case ASN1_Type::Null:
  ------------------
  |  Branch (143:7): [True: 18, False: 5.58k]
  ------------------
  144|     18|         return "NULL";
  145|       |
  146|     49|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (146:7): [True: 49, False: 5.54k]
  ------------------
  147|     49|         return "OBJECT";
  148|       |
  149|     75|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (149:7): [True: 75, False: 5.52k]
  ------------------
  150|     75|         return "BOOLEAN";
  151|       |
  152|     39|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (152:7): [True: 39, False: 5.55k]
  ------------------
  153|     39|         return "NO_OBJECT";
  154|       |
  155|    483|      default:
  ------------------
  |  Branch (155:7): [True: 483, False: 5.11k]
  ------------------
  156|    483|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  157|  5.59k|   }
  158|  5.59k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  163|  7.60k|BER_Decoding_Error::BER_Decoding_Error(std::string_view str) : Decoding_Error(fmt("BER: {}", str)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  165|    375|BER_Bad_Tag::BER_Bad_Tag(std::string_view str, uint32_t tagging) : BER_Decoding_Error(fmt("{}: {}", str, tagging)) {}
_ZN5Botan4ASN115put_in_sequenceERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  172|  12.1k|std::vector<uint8_t> put_in_sequence(const std::vector<uint8_t>& contents) {
  173|  12.1k|   return ASN1::put_in_sequence(contents.data(), contents.size());
  174|  12.1k|}
_ZN5Botan4ASN115put_in_sequenceEPKhm:
  176|  12.1k|std::vector<uint8_t> put_in_sequence(const uint8_t bits[], size_t len) {
  177|  12.1k|   std::vector<uint8_t> output;
  178|  12.1k|   DER_Encoder(output).start_sequence().raw_bytes(bits, len).end_cons();
  179|  12.1k|   return output;
  180|  12.1k|}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  185|  17.4k|std::string to_string(const BER_Object& obj) {
  186|  17.4k|   return std::string(cast_uint8_ptr_to_char(obj.bits()), obj.length());
  187|  17.4k|}
_ZN5Botan4ASN19maybe_BERERNS_10DataSourceE:
  192|  7.08k|bool maybe_BER(DataSource& source) {
  193|  7.08k|   uint8_t first_u8;
  194|  7.08k|   if(!source.peek_byte(first_u8)) {
  ------------------
  |  Branch (194:7): [True: 61, False: 7.02k]
  ------------------
  195|     61|      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
  ------------------
  |  |   69|     61|   do {                                                                                                \
  |  |   70|     61|      if((expr1) != (expr2))                                                                           \
  |  |  ------------------
  |  |  |  Branch (70:10): [True: 0, False: 61]
  |  |  ------------------
  |  |   71|     61|         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   72|     61|   } while(0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  196|     61|      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
  197|     61|   }
  198|       |
  199|  7.02k|   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
  200|  7.02k|   if(first_u8 == cons_seq) {
  ------------------
  |  Branch (200:7): [True: 6.77k, False: 253]
  ------------------
  201|  6.77k|      return true;
  202|  6.77k|   }
  203|    253|   return false;
  204|  7.02k|}

_ZN5Botan3OID11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   74|    337|OID OID::from_string(std::string_view str) {
   75|    337|   if(str.empty()) {
  ------------------
  |  Branch (75:7): [True: 0, False: 337]
  ------------------
   76|      0|      throw Invalid_Argument("OID::from_string argument must be non-empty");
   77|      0|   }
   78|       |
   79|    337|   OID o = OID_Map::global_registry().str2oid(str);
   80|    337|   if(o.has_value()) {
  ------------------
  |  Branch (80:7): [True: 337, False: 0]
  ------------------
   81|    337|      return o;
   82|    337|   }
   83|       |
   84|      0|   std::vector<uint32_t> raw = parse_oid_str(str);
   85|       |
   86|      0|   if(!raw.empty()) {
  ------------------
  |  Branch (86:7): [True: 0, False: 0]
  ------------------
   87|      0|      return OID(std::move(raw));
   88|      0|   }
   89|       |
   90|      0|   throw Lookup_Error(fmt("No OID associated with name '{}'", str));
   91|      0|}
_ZN5Botan3OIDC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   96|   181k|OID::OID(std::string_view oid_str) {
   97|   181k|   if(!oid_str.empty()) {
  ------------------
  |  Branch (97:7): [True: 181k, False: 0]
  ------------------
   98|   181k|      m_id = parse_oid_str(oid_str);
   99|   181k|      if(m_id.size() < 2 || m_id[0] > 2 || (m_id[0] < 2 && m_id[1] > 39)) {
  ------------------
  |  Branch (99:10): [True: 0, False: 181k]
  |  Branch (99:29): [True: 0, False: 181k]
  |  Branch (99:45): [True: 13.6k, False: 168k]
  |  Branch (99:60): [True: 0, False: 13.6k]
  ------------------
  100|      0|         throw Decoding_Error(fmt("Invalid OID '{}'", oid_str));
  101|      0|      }
  102|   181k|   }
  103|   181k|}
_ZNK5Botan3OID9to_stringEv:
  108|  20.3k|std::string OID::to_string() const {
  109|  20.3k|   std::ostringstream out;
  110|  20.3k|   out << (*this);
  111|  20.3k|   return out.str();
  112|  20.3k|}
_ZNK5Botan3OID19to_formatted_stringEv:
  114|  4.63k|std::string OID::to_formatted_string() const {
  115|  4.63k|   std::string s = this->human_name_or_empty();
  116|  4.63k|   if(!s.empty()) {
  ------------------
  |  Branch (116:7): [True: 3.25k, False: 1.37k]
  ------------------
  117|  3.25k|      return s;
  118|  3.25k|   }
  119|  1.37k|   return this->to_string();
  120|  4.63k|}
_ZNK5Botan3OID19human_name_or_emptyEv:
  122|  4.63k|std::string OID::human_name_or_empty() const {
  123|  4.63k|   return OID_Map::global_registry().oid2str(*this);
  124|  4.63k|}
_ZN5BotanltERKNS_3OIDES2_:
  133|  89.1k|bool operator<(const OID& a, const OID& b) {
  134|  89.1k|   const std::vector<uint32_t>& oid1 = a.get_components();
  135|  89.1k|   const std::vector<uint32_t>& oid2 = b.get_components();
  136|       |
  137|  89.1k|   return std::lexicographical_compare(oid1.begin(), oid1.end(), oid2.begin(), oid2.end());
  138|  89.1k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_3OIDE:
  140|  20.3k|std::ostream& operator<<(std::ostream& out, const OID& oid) {
  141|  20.3k|   const auto& val = oid.get_components();
  142|       |
  143|   152k|   for(size_t i = 0; i != val.size(); ++i) {
  ------------------
  |  Branch (143:22): [True: 132k, False: 20.3k]
  ------------------
  144|       |      // avoid locale issues with integer formatting
  145|   132k|      out << std::to_string(val[i]);
  146|   132k|      if(i != val.size() - 1) {
  ------------------
  |  Branch (146:10): [True: 111k, False: 20.3k]
  ------------------
  147|   111k|         out << ".";
  148|   111k|      }
  149|   132k|   }
  150|       |
  151|  20.3k|   return out;
  152|  20.3k|}
_ZNK5Botan3OID11encode_intoERNS_11DER_EncoderE:
  157|  3.39k|void OID::encode_into(DER_Encoder& der) const {
  158|  3.39k|   if(m_id.size() < 2) {
  ------------------
  |  Branch (158:7): [True: 0, False: 3.39k]
  ------------------
  159|      0|      throw Invalid_Argument("OID::encode_into: OID is invalid");
  160|      0|   }
  161|       |
  162|  3.39k|   std::vector<uint8_t> encoding;
  163|       |
  164|  3.39k|   if(m_id[0] > 2 || m_id[1] >= 40) {
  ------------------
  |  Branch (164:7): [True: 2, False: 3.38k]
  |  Branch (164:22): [True: 0, False: 3.38k]
  ------------------
  165|      2|      throw Encoding_Error("Invalid OID prefix, cannot encode");
  166|      2|   }
  167|       |
  168|  3.38k|   encoding.push_back(static_cast<uint8_t>(40 * m_id[0] + m_id[1]));
  169|       |
  170|  20.5k|   for(size_t i = 2; i != m_id.size(); ++i) {
  ------------------
  |  Branch (170:22): [True: 17.1k, False: 3.38k]
  ------------------
  171|  17.1k|      if(m_id[i] == 0) {
  ------------------
  |  Branch (171:10): [True: 149, False: 17.0k]
  ------------------
  172|    149|         encoding.push_back(0);
  173|  17.0k|      } else {
  174|  17.0k|         size_t blocks = high_bit(m_id[i]) + 6;
  175|  17.0k|         blocks = (blocks - (blocks % 7)) / 7;
  176|       |
  177|  17.0k|         BOTAN_ASSERT(blocks > 0, "Math works");
  ------------------
  |  |   51|  17.0k|   do {                                                                                 \
  |  |   52|  17.0k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 17.0k]
  |  |  ------------------
  |  |   53|  17.0k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  17.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  178|       |
  179|  27.1k|         for(size_t j = 0; j != blocks - 1; ++j) {
  ------------------
  |  Branch (179:28): [True: 10.1k, False: 17.0k]
  ------------------
  180|  10.1k|            encoding.push_back(0x80 | ((m_id[i] >> 7 * (blocks - j - 1)) & 0x7F));
  181|  10.1k|         }
  182|  17.0k|         encoding.push_back(m_id[i] & 0x7F);
  183|  17.0k|      }
  184|  17.1k|   }
  185|  3.38k|   der.add_object(ASN1_Type::ObjectId, ASN1_Class::Universal, encoding);
  186|  3.38k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  191|  40.2k|void OID::decode_from(BER_Decoder& decoder) {
  192|  40.2k|   BER_Object obj = decoder.get_next_object();
  193|  40.2k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (193:7): [True: 366, False: 39.8k]
  ------------------
  194|    366|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  195|    366|   }
  196|       |
  197|  39.8k|   const size_t length = obj.length();
  198|  39.8k|   const uint8_t* bits = obj.bits();
  199|       |
  200|  39.8k|   if(length < 2 && !(length == 1 && bits[0] == 0)) {
  ------------------
  |  Branch (200:7): [True: 2.79k, False: 37.0k]
  |  Branch (200:23): [True: 2.78k, False: 12]
  |  Branch (200:38): [True: 2.76k, False: 22]
  ------------------
  201|     34|      throw BER_Decoding_Error("OID encoding is too short");
  202|     34|   }
  203|       |
  204|  39.8k|   m_id.clear();
  205|  39.8k|   m_id.push_back(bits[0] / 40);
  206|  39.8k|   m_id.push_back(bits[0] % 40);
  207|       |
  208|  39.8k|   size_t i = 0;
  209|   268k|   while(i != length - 1) {
  ------------------
  |  Branch (209:10): [True: 228k, False: 39.8k]
  ------------------
  210|   228k|      uint32_t component = 0;
  211|   286k|      while(i != length - 1) {
  ------------------
  |  Branch (211:13): [True: 278k, False: 8.44k]
  ------------------
  212|   278k|         ++i;
  213|       |
  214|   278k|         if(component >> (32 - 7)) {
  ------------------
  |  Branch (214:13): [True: 28, False: 278k]
  ------------------
  215|     28|            throw Decoding_Error("OID component overflow");
  216|     28|         }
  217|       |
  218|   278k|         component = (component << 7) + (bits[i] & 0x7F);
  219|       |
  220|   278k|         if(!(bits[i] & 0x80)) {
  ------------------
  |  Branch (220:13): [True: 220k, False: 58.3k]
  ------------------
  221|   220k|            break;
  222|   220k|         }
  223|   278k|      }
  224|   228k|      m_id.push_back(component);
  225|   228k|   }
  226|  39.8k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_113parse_oid_strENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   24|   181k|std::vector<uint32_t> parse_oid_str(std::string_view oid) {
   25|   181k|   try {
   26|   181k|      std::string elem;
   27|   181k|      std::vector<uint32_t> oid_elems;
   28|       |
   29|  1.75M|      for(char c : oid) {
  ------------------
  |  Branch (29:18): [True: 1.75M, False: 181k]
  ------------------
   30|  1.75M|         if(c == '.') {
  ------------------
  |  Branch (30:13): [True: 617k, False: 1.14M]
  ------------------
   31|   617k|            if(elem.empty()) {
  ------------------
  |  Branch (31:16): [True: 0, False: 617k]
  ------------------
   32|      0|               return std::vector<uint32_t>();
   33|      0|            }
   34|   617k|            oid_elems.push_back(to_u32bit(elem));
   35|   617k|            elem.clear();
   36|  1.14M|         } else {
   37|  1.14M|            elem += c;
   38|  1.14M|         }
   39|  1.75M|      }
   40|       |
   41|   181k|      if(!elem.empty()) {
  ------------------
  |  Branch (41:10): [True: 181k, False: 0]
  ------------------
   42|   181k|         oid_elems.push_back(to_u32bit(elem));
   43|   181k|      }
   44|       |
   45|   181k|      return oid_elems;
   46|   181k|   } catch(Invalid_Argument&)  // thrown by to_u32bit
   47|   181k|   {
   48|      0|      return std::vector<uint32_t>();
   49|      0|   }
   50|   181k|}

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

_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   53|  10.0k|void ASN1_Time::decode_from(BER_Decoder& source) {
   54|  10.0k|   BER_Object ber_time = source.get_next_object();
   55|       |
   56|  10.0k|   set_to(ASN1::to_string(ber_time), ber_time.type());
   57|  10.0k|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  157|  10.0k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  158|  10.0k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   30|  10.0k|   do {                                                          \
  |  |   31|  12.7k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 7.37k, False: 2.70k]
  |  |  |  Branch (31:12): [True: 1.16k, False: 1.54k]
  |  |  ------------------
  |  |   32|  10.0k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  10.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  159|  10.0k|                   "Invalid tag for ASN1_Time");
  160|       |
  161|  10.0k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (161:7): [True: 1.16k, False: 8.92k]
  ------------------
  162|  1.16k|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   30|  1.16k|   do {                                                          \
  |  |   31|  1.16k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 20, False: 1.14k]
  |  |  ------------------
  |  |   32|  1.16k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.16k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  8.92k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (163:14): [True: 7.37k, False: 1.54k]
  ------------------
  164|  7.37k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   30|  7.37k|   do {                                                          \
  |  |   31|  7.37k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 8, False: 7.36k]
  |  |  ------------------
  |  |   32|  7.37k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  7.37k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  7.37k|   }
  166|       |
  167|  10.0k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   30|  10.0k|   do {                                                          \
  |  |   31|  10.0k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 13, False: 10.0k]
  |  |  ------------------
  |  |   32|  10.0k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  10.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  168|       |
  169|  10.0k|   const size_t field_len = 2;
  170|       |
  171|  10.0k|   const size_t year_start = 0;
  172|  10.0k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (172:28): [True: 7.35k, False: 2.72k]
  ------------------
  173|  10.0k|   const size_t month_start = year_start + year_len;
  174|  10.0k|   const size_t day_start = month_start + field_len;
  175|  10.0k|   const size_t hour_start = day_start + field_len;
  176|  10.0k|   const size_t min_start = hour_start + field_len;
  177|  10.0k|   const size_t sec_start = min_start + field_len;
  178|       |
  179|  10.0k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  180|  10.0k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  181|  10.0k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  182|  10.0k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  183|  10.0k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  184|  10.0k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  185|  10.0k|   m_tag = spec_tag;
  186|       |
  187|  10.0k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (187:7): [True: 7.34k, False: 2.73k]
  ------------------
  188|  7.34k|      if(m_year >= 50) {
  ------------------
  |  Branch (188:10): [True: 2.42k, False: 4.91k]
  ------------------
  189|  2.42k|         m_year += 1900;
  190|  4.91k|      } else {
  191|  4.91k|         m_year += 2000;
  192|  4.91k|      }
  193|  7.34k|   }
  194|       |
  195|  10.0k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (195:7): [True: 53, False: 10.0k]
  ------------------
  196|     53|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  197|     53|   }
  198|  10.0k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  203|  8.47k|bool ASN1_Time::passes_sanity_check() const {
  204|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  205|  8.47k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (205:7): [True: 10, False: 8.46k]
  |  Branch (205:24): [True: 3, False: 8.46k]
  ------------------
  206|     13|      return false;
  207|     13|   }
  208|  8.46k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (208:7): [True: 3, False: 8.46k]
  |  Branch (208:23): [True: 6, False: 8.45k]
  ------------------
  209|      9|      return false;
  210|      9|   }
  211|       |
  212|  8.45k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  213|       |
  214|  8.45k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (214:7): [True: 1, False: 8.45k]
  |  Branch (214:21): [True: 10, False: 8.44k]
  ------------------
  215|     11|      return false;
  216|     11|   }
  217|       |
  218|  8.44k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (218:7): [True: 736, False: 7.70k]
  |  Branch (218:23): [True: 48, False: 688]
  ------------------
  219|     48|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (219:10): [True: 3, False: 45]
  ------------------
  220|      3|         return false;  // not a leap year
  221|      3|      }
  222|       |
  223|     45|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (223:10): [True: 6, False: 39]
  |  Branch (223:31): [True: 2, False: 4]
  ------------------
  224|      2|         return false;
  225|      2|      }
  226|     45|   }
  227|       |
  228|  8.43k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (228:7): [True: 7, False: 8.43k]
  |  Branch (228:23): [True: 2, False: 8.42k]
  |  Branch (228:41): [True: 3, False: 8.42k]
  ------------------
  229|     12|      return false;
  230|     12|   }
  231|       |
  232|  8.42k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (232:7): [True: 7.32k, False: 1.10k]
  ------------------
  233|       |      /*
  234|       |      UTCTime limits the value of components such that leap seconds
  235|       |      are not covered. See "UNIVERSAL 23" in "Information technology
  236|       |      Abstract Syntax Notation One (ASN.1): Specification of basic notation"
  237|       |
  238|       |      http://www.itu.int/ITU-T/studygroups/com17/languages/
  239|       |      */
  240|  7.32k|      if(m_second > 59) {
  ------------------
  |  Branch (240:10): [True: 3, False: 7.31k]
  ------------------
  241|      3|         return false;
  242|      3|      }
  243|  7.32k|   }
  244|       |
  245|  8.42k|   return true;
  246|  8.42k|}

_ZNK5Botan11BER_Decoder10more_itemsEv:
  195|  61.2k|bool BER_Decoder::more_items() const {
  196|  61.2k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (196:7): [True: 17.6k, False: 43.6k]
  |  Branch (196:34): [True: 17.6k, False: 0]
  ------------------
  197|  17.6k|      return false;
  198|  17.6k|   }
  199|  43.6k|   return true;
  200|  61.2k|}
_ZN5Botan11BER_Decoder10verify_endEv:
  205|  8.55k|BER_Decoder& BER_Decoder::verify_end() {
  206|  8.55k|   return verify_end("BER_Decoder::verify_end called, but data remains");
  207|  8.55k|}
_ZN5Botan11BER_Decoder10verify_endENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  212|  12.1k|BER_Decoder& BER_Decoder::verify_end(std::string_view err) {
  213|  12.1k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (213:7): [True: 62, False: 12.1k]
  |  Branch (213:35): [True: 0, False: 12.1k]
  ------------------
  214|     62|      throw Decoding_Error(err);
  215|     62|   }
  216|  12.1k|   return (*this);
  217|  12.1k|}
_ZN5Botan11BER_Decoder17discard_remainingEv:
  222|    126|BER_Decoder& BER_Decoder::discard_remaining() {
  223|    126|   uint8_t buf;
  224|  1.81k|   while(m_source->read_byte(buf)) {}
  ------------------
  |  Branch (224:10): [True: 1.68k, False: 126]
  ------------------
  225|    126|   return (*this);
  226|    126|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  231|   268k|BER_Object BER_Decoder::get_next_object() {
  232|   268k|   BER_Object next;
  233|       |
  234|   268k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (234:7): [True: 24.1k, False: 244k]
  ------------------
  235|  24.1k|      std::swap(next, m_pushed);
  236|  24.1k|      return next;
  237|  24.1k|   }
  238|       |
  239|   304k|   for(;;) {
  240|   304k|      ASN1_Type type_tag;
  241|   304k|      ASN1_Class class_tag;
  242|   304k|      decode_tag(m_source, type_tag, class_tag);
  243|   304k|      next.set_tagging(type_tag, class_tag);
  244|   304k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (244:10): [True: 14.8k, False: 289k]
  ------------------
  245|  14.8k|         return next;
  246|  14.8k|      }
  247|       |
  248|   289k|      size_t field_size;
  249|   289k|      const size_t length = decode_length(m_source, field_size, ALLOWED_EOC_NESTINGS);
  250|   289k|      if(!m_source->check_available(length)) {
  ------------------
  |  Branch (250:10): [True: 1.33k, False: 288k]
  ------------------
  251|  1.33k|         throw BER_Decoding_Error("Value truncated");
  252|  1.33k|      }
  253|       |
  254|   288k|      uint8_t* out = next.mutable_bits(length);
  255|   288k|      if(m_source->read(out, length) != length) {
  ------------------
  |  Branch (255:10): [True: 0, False: 288k]
  ------------------
  256|      0|         throw BER_Decoding_Error("Value truncated");
  257|      0|      }
  258|       |
  259|   288k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (259:10): [True: 60.0k, False: 228k]
  ------------------
  260|  60.0k|         continue;
  261|   228k|      } else {
  262|   228k|         break;
  263|   228k|      }
  264|   288k|   }
  265|       |
  266|   228k|   return next;
  267|   244k|}
_ZN5Botan11BER_Decoder9push_backERKNS_10BER_ObjectE:
  272|  2.94k|void BER_Decoder::push_back(const BER_Object& obj) {
  273|  2.94k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (273:7): [True: 0, False: 2.94k]
  ------------------
  274|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  275|      0|   }
  276|  2.94k|   m_pushed = obj;
  277|  2.94k|}
_ZN5Botan11BER_Decoder9push_backEONS_10BER_ObjectE:
  279|  32.6k|void BER_Decoder::push_back(BER_Object&& obj) {
  280|  32.6k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (280:7): [True: 0, False: 32.6k]
  ------------------
  281|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  282|      0|   }
  283|  32.6k|   m_pushed = std::move(obj);
  284|  32.6k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  286|   100k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  287|   100k|   BER_Object obj = get_next_object();
  288|   100k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  289|   100k|   return BER_Decoder(std::move(obj), this);
  290|   100k|}
_ZN5Botan11BER_Decoder8end_consEv:
  295|  67.2k|BER_Decoder& BER_Decoder::end_cons() {
  296|  67.2k|   if(!m_parent) {
  ------------------
  |  Branch (296:7): [True: 0, False: 67.2k]
  ------------------
  297|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  298|      0|   }
  299|  67.2k|   if(!m_source->end_of_data()) {
  ------------------
  |  Branch (299:7): [True: 655, False: 66.6k]
  ------------------
  300|    655|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  301|    655|   }
  302|  66.6k|   return (*m_parent);
  303|  67.2k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  305|   100k|BER_Decoder::BER_Decoder(BER_Object&& obj, BER_Decoder* parent) {
  306|   100k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  307|   100k|   m_source = m_data_src.get();
  308|   100k|   m_parent = parent;
  309|   100k|}
_ZN5Botan11BER_DecoderC2ERNS_10DataSourceE:
  314|  6.76k|BER_Decoder::BER_Decoder(DataSource& src) {
  315|  6.76k|   m_source = &src;
  316|  6.76k|}
_ZN5Botan11BER_DecoderC2EPKhm:
  321|  7.74k|BER_Decoder::BER_Decoder(const uint8_t data[], size_t length) {
  322|  7.74k|   m_data_src = std::make_unique<DataSource_Memory>(data, length);
  323|  7.74k|   m_source = m_data_src.get();
  324|  7.74k|}
_ZN5Botan11BER_DecoderC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  337|  35.9k|BER_Decoder::BER_Decoder(const std::vector<uint8_t>& data) {
  338|  35.9k|   m_data_src = std::make_unique<DataSource_Memory>(data.data(), data.size());
  339|  35.9k|   m_source = m_data_src.get();
  340|  35.9k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  356|  88.7k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  357|  88.7k|   obj.decode_from(*this);
  358|  88.7k|   return (*this);
  359|  88.7k|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  383|    456|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  384|    456|   BER_Object obj = get_next_object();
  385|    456|   obj.assert_is_a(type_tag, class_tag);
  386|       |
  387|    456|   if(obj.length() != 1) {
  ------------------
  |  Branch (387:7): [True: 25, False: 431]
  ------------------
  388|     25|      throw BER_Decoding_Error("BER boolean value had invalid size");
  389|     25|   }
  390|       |
  391|    431|   out = (obj.bits()[0]) ? true : false;
  ------------------
  |  Branch (391:10): [True: 429, False: 2]
  ------------------
  392|    431|   return (*this);
  393|    456|}
_ZN5Botan11BER_Decoder6decodeERmNS_9ASN1_TypeENS_10ASN1_ClassE:
  398|  7.91k|BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  399|  7.91k|   BigInt integer;
  400|  7.91k|   decode(integer, type_tag, class_tag);
  401|       |
  402|  7.91k|   if(integer.is_negative()) {
  ------------------
  |  Branch (402:7): [True: 194, False: 7.72k]
  ------------------
  403|    194|      throw BER_Decoding_Error("Decoded small integer value was negative");
  404|    194|   }
  405|       |
  406|  7.72k|   if(integer.bits() > 32) {
  ------------------
  |  Branch (406:7): [True: 145, False: 7.57k]
  ------------------
  407|    145|      throw BER_Decoding_Error("Decoded integer value larger than expected");
  408|    145|   }
  409|       |
  410|  7.57k|   out = 0;
  411|  37.0k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (411:22): [True: 29.4k, False: 7.57k]
  ------------------
  412|  29.4k|      out = (out << 8) | integer.byte_at(3 - i);
  413|  29.4k|   }
  414|       |
  415|  7.57k|   return (*this);
  416|  7.72k|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  444|  14.8k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  445|  14.8k|   BER_Object obj = get_next_object();
  446|  14.8k|   obj.assert_is_a(type_tag, class_tag);
  447|       |
  448|  14.8k|   if(obj.length() == 0) {
  ------------------
  |  Branch (448:7): [True: 4.36k, False: 10.4k]
  ------------------
  449|  4.36k|      out.clear();
  450|  10.4k|   } else {
  451|  10.4k|      const bool negative = (obj.bits()[0] & 0x80) ? true : false;
  ------------------
  |  Branch (451:29): [True: 2.37k, False: 8.10k]
  ------------------
  452|       |
  453|  10.4k|      if(negative) {
  ------------------
  |  Branch (453:10): [True: 2.37k, False: 8.10k]
  ------------------
  454|  2.37k|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  455|  3.60k|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (455:39): [True: 3.60k, False: 0]
  ------------------
  456|  3.60k|            if(vec[i - 1]--) {
  ------------------
  |  Branch (456:16): [True: 2.37k, False: 1.22k]
  ------------------
  457|  2.37k|               break;
  458|  2.37k|            }
  459|  3.60k|         }
  460|  68.9k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (460:28): [True: 66.5k, False: 2.37k]
  ------------------
  461|  66.5k|            vec[i] = ~vec[i];
  462|  66.5k|         }
  463|  2.37k|         out = BigInt(vec.data(), vec.size());
  464|  2.37k|         out.flip_sign();
  465|  8.10k|      } else {
  466|  8.10k|         out = BigInt(obj.bits(), obj.length());
  467|  8.10k|      }
  468|  10.4k|   }
  469|       |
  470|  14.8k|   return (*this);
  471|  14.8k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  521|  33.3k|                                 ASN1_Class class_tag) {
  522|  33.3k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (522:7): [True: 13.9k, False: 19.4k]
  |  Branch (522:46): [True: 0, False: 13.9k]
  ------------------
  523|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  524|      0|   }
  525|       |
  526|  33.3k|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag);
  527|  33.3k|   return (*this);
  528|  33.3k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|   648k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|   648k|   uint8_t b;
   31|   648k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (31:7): [True: 98.6k, False: 549k]
  ------------------
   32|  98.6k|      type_tag = ASN1_Type::NoObject;
   33|  98.6k|      class_tag = ASN1_Class::NoObject;
   34|  98.6k|      return 0;
   35|  98.6k|   }
   36|       |
   37|   549k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (37:7): [True: 544k, False: 5.20k]
  ------------------
   38|   544k|      type_tag = ASN1_Type(b & 0x1F);
   39|   544k|      class_tag = ASN1_Class(b & 0xE0);
   40|   544k|      return 1;
   41|   544k|   }
   42|       |
   43|  5.20k|   size_t tag_bytes = 1;
   44|  5.20k|   class_tag = ASN1_Class(b & 0xE0);
   45|       |
   46|  5.20k|   size_t tag_buf = 0;
   47|  11.3k|   while(true) {
  ------------------
  |  Branch (47:10): [Folded - Ignored]
  ------------------
   48|  11.3k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (48:10): [True: 76, False: 11.2k]
  ------------------
   49|     76|         throw BER_Decoding_Error("Long-form tag truncated");
   50|     76|      }
   51|  11.2k|      if(tag_buf & 0xFF000000) {
  ------------------
  |  Branch (51:10): [True: 48, False: 11.2k]
  ------------------
   52|     48|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|     48|      }
   54|  11.2k|      ++tag_bytes;
   55|  11.2k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
   56|  11.2k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (56:10): [True: 5.07k, False: 6.14k]
  ------------------
   57|  5.07k|         break;
   58|  5.07k|      }
   59|  11.2k|   }
   60|  5.07k|   type_tag = ASN1_Type(tag_buf);
   61|  5.07k|   return tag_bytes;
   62|  5.20k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceERmm:
   72|   548k|size_t decode_length(DataSource* ber, size_t& field_size, size_t allow_indef) {
   73|   548k|   uint8_t b;
   74|   548k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (74:7): [True: 552, False: 548k]
  ------------------
   75|    552|      throw BER_Decoding_Error("Length field not found");
   76|    552|   }
   77|   548k|   field_size = 1;
   78|   548k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (78:7): [True: 389k, False: 159k]
  ------------------
   79|   389k|      return b;
   80|   389k|   }
   81|       |
   82|   159k|   field_size += (b & 0x7F);
   83|   159k|   if(field_size > 5) {
  ------------------
  |  Branch (83:7): [True: 969, False: 158k]
  ------------------
   84|    969|      throw BER_Decoding_Error("Length field is too large");
   85|    969|   }
   86|       |
   87|   158k|   if(field_size == 1) {
  ------------------
  |  Branch (87:7): [True: 99.3k, False: 58.9k]
  ------------------
   88|  99.3k|      if(allow_indef == 0) {
  ------------------
  |  Branch (88:10): [True: 5, False: 99.3k]
  ------------------
   89|      5|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
   90|  99.3k|      } else {
   91|  99.3k|         return find_eoc(ber, allow_indef - 1);
   92|  99.3k|      }
   93|  99.3k|   }
   94|       |
   95|  58.9k|   size_t length = 0;
   96|       |
   97|   175k|   for(size_t i = 0; i != field_size - 1; ++i) {
  ------------------
  |  Branch (97:22): [True: 116k, False: 58.8k]
  ------------------
   98|   116k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (98:10): [True: 0, False: 116k]
  ------------------
   99|      0|         throw BER_Decoding_Error("Field length overflow");
  100|      0|      }
  101|   116k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (101:10): [True: 66, False: 116k]
  ------------------
  102|     66|         throw BER_Decoding_Error("Corrupted length field");
  103|     66|      }
  104|   116k|      length = (length << 8) | b;
  105|   116k|   }
  106|  58.8k|   return length;
  107|  58.9k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEm:
  112|  99.3k|size_t find_eoc(DataSource* ber, size_t allow_indef) {
  113|  99.3k|   secure_vector<uint8_t> buffer(BOTAN_DEFAULT_BUFFER_SIZE), data;
  ------------------
  |  |  388|  99.3k|#define BOTAN_DEFAULT_BUFFER_SIZE 4096
  ------------------
  114|       |
  115|   205k|   while(true) {
  ------------------
  |  Branch (115:10): [Folded - Ignored]
  ------------------
  116|   205k|      const size_t got = ber->peek(buffer.data(), buffer.size(), data.size());
  117|   205k|      if(got == 0) {
  ------------------
  |  Branch (117:10): [True: 99.3k, False: 106k]
  ------------------
  118|  99.3k|         break;
  119|  99.3k|      }
  120|       |
  121|   106k|      data += std::make_pair(buffer.data(), got);
  122|   106k|   }
  123|       |
  124|  99.3k|   DataSource_Memory source(data);
  125|  99.3k|   data.clear();
  126|       |
  127|  99.3k|   size_t length = 0;
  128|   344k|   while(true) {
  ------------------
  |  Branch (128:10): [Folded - Ignored]
  ------------------
  129|   343k|      ASN1_Type type_tag;
  130|   343k|      ASN1_Class class_tag;
  131|   343k|      size_t tag_size = decode_tag(&source, type_tag, class_tag);
  132|   343k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (132:10): [True: 84.0k, False: 259k]
  ------------------
  133|  84.0k|         break;
  134|  84.0k|      }
  135|       |
  136|   259k|      size_t length_size = 0;
  137|   259k|      size_t item_size = decode_length(&source, length_size, allow_indef);
  138|   259k|      source.discard_next(item_size);
  139|       |
  140|   259k|      length = BOTAN_CHECKED_ADD(length, item_size);
  ------------------
  |  |   73|   259k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  141|   259k|      length = BOTAN_CHECKED_ADD(length, tag_size);
  ------------------
  |  |   73|   259k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  142|   259k|      length = BOTAN_CHECKED_ADD(length, length_size);
  ------------------
  |  |   73|   259k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  143|       |
  144|   259k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (144:10): [True: 39.4k, False: 220k]
  |  Branch (144:40): [True: 14.4k, False: 24.9k]
  ------------------
  145|  14.4k|         break;
  146|  14.4k|      }
  147|   259k|   }
  148|  99.3k|   return length;
  149|  99.3k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  183|   100k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)), m_offset(0) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  153|  3.86M|      size_t read(uint8_t out[], size_t length) override {
  154|  3.86M|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  3.86M|   do {                                                                     \
  |  |   61|  3.86M|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.86M]
  |  |  ------------------
  |  |   62|  3.86M|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.86M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  155|  3.86M|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  156|  3.86M|         copy_mem(out, m_obj.bits() + m_offset, got);
  157|  3.86M|         m_offset += got;
  158|  3.86M|         return got;
  159|  3.86M|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  174|   183k|      bool check_available(size_t n) override {
  175|   183k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|   183k|   do {                                                                     \
  |  |   61|   183k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 183k]
  |  |  ------------------
  |  |   62|   183k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|   183k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  176|   183k|         return (n <= (m_obj.length() - m_offset));
  177|   183k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject4peekEPhmm:
  161|  36.3k|      size_t peek(uint8_t out[], size_t length, size_t peek_offset) const override {
  162|  36.3k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  36.3k|   do {                                                                     \
  |  |   61|  36.3k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 36.3k]
  |  |  ------------------
  |  |   62|  36.3k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  36.3k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  36.3k|         const size_t bytes_left = m_obj.length() - m_offset;
  164|       |
  165|  36.3k|         if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (165:13): [True: 17.7k, False: 18.5k]
  ------------------
  166|  17.7k|            return 0;
  167|  17.7k|         }
  168|       |
  169|  18.5k|         const size_t got = std::min(bytes_left - peek_offset, length);
  170|  18.5k|         copy_mem(out, m_obj.bits() + m_offset + peek_offset, got);
  171|  18.5k|         return got;
  172|  36.3k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  179|   116k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  181|   116k|      size_t get_bytes_read() const override { return m_offset; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassE:
  480|  33.2k|                               ASN1_Class class_tag) {
  481|  33.2k|   obj.assert_is_a(type_tag, class_tag);
  482|       |
  483|  33.2k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (483:7): [True: 18.2k, False: 14.9k]
  ------------------
  484|  18.2k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  485|  18.2k|   } else {
  486|  14.9k|      if(obj.length() == 0) {
  ------------------
  |  Branch (486:10): [True: 2, False: 14.9k]
  ------------------
  487|      2|         throw BER_Decoding_Error("Invalid BIT STRING");
  488|      2|      }
  489|  14.9k|      if(obj.bits()[0] >= 8) {
  ------------------
  |  Branch (489:10): [True: 7, False: 14.9k]
  ------------------
  490|      7|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  491|      7|      }
  492|       |
  493|  14.9k|      buffer.resize(obj.length() - 1);
  494|       |
  495|  14.9k|      if(obj.length() > 1) {
  ------------------
  |  Branch (495:10): [True: 10.3k, False: 4.60k]
  ------------------
  496|  10.3k|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  497|  10.3k|      }
  498|  14.9k|   }
  499|  33.2k|}

_ZN5Botan11DER_EncoderC2ERNSt3__16vectorIhNS1_9allocatorIhEEEE:
   71|  15.5k|DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   72|  15.5k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
   73|  15.5k|}
_ZN5Botan11DER_Encoder12DER_Sequence13push_contentsERS0_:
   78|  22.3k|void DER_Encoder::DER_Sequence::push_contents(DER_Encoder& der) {
   79|  22.3k|   const auto real_class_tag = m_class_tag | ASN1_Class::Constructed;
   80|       |
   81|  22.3k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (81:7): [True: 0, False: 22.3k]
  ------------------
   82|      0|      std::sort(m_set_contents.begin(), m_set_contents.end());
   83|      0|      for(const auto& set_elem : m_set_contents) {
  ------------------
  |  Branch (83:32): [True: 0, False: 0]
  ------------------
   84|      0|         m_contents += set_elem;
   85|      0|      }
   86|      0|      m_set_contents.clear();
   87|      0|   }
   88|       |
   89|  22.3k|   der.add_object(m_type_tag, real_class_tag, m_contents.data(), m_contents.size());
   90|  22.3k|   m_contents.clear();
   91|  22.3k|}
_ZN5Botan11DER_Encoder12DER_Sequence9add_bytesEPKhm:
   96|  18.9k|void DER_Encoder::DER_Sequence::add_bytes(const uint8_t data[], size_t length) {
   97|  18.9k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (97:7): [True: 0, False: 18.9k]
  ------------------
   98|      0|      m_set_contents.push_back(secure_vector<uint8_t>(data, data + length));
   99|  18.9k|   } else {
  100|  18.9k|      m_contents += std::make_pair(data, length);
  101|  18.9k|   }
  102|  18.9k|}
_ZN5Botan11DER_Encoder12DER_Sequence9add_bytesEPKhmS3_m:
  104|  13.5k|void DER_Encoder::DER_Sequence::add_bytes(const uint8_t hdr[], size_t hdr_len, const uint8_t val[], size_t val_len) {
  105|  13.5k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (105:7): [True: 0, False: 13.5k]
  ------------------
  106|      0|      secure_vector<uint8_t> m;
  107|      0|      m.reserve(hdr_len + val_len);
  108|      0|      m += std::make_pair(hdr, hdr_len);
  109|      0|      m += std::make_pair(val, val_len);
  110|      0|      m_set_contents.push_back(std::move(m));
  111|  13.5k|   } else {
  112|  13.5k|      m_contents += std::make_pair(hdr, hdr_len);
  113|  13.5k|      m_contents += std::make_pair(val, val_len);
  114|  13.5k|   }
  115|  13.5k|}
_ZN5Botan11DER_Encoder12DER_SequenceC2ENS_9ASN1_TypeENS_10ASN1_ClassE:
  127|  22.3k|DER_Encoder::DER_Sequence::DER_Sequence(ASN1_Type t1, ASN1_Class t2) : m_type_tag(t1), m_class_tag(t2) {}
_ZN5Botan11DER_Encoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  163|  22.3k|DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  164|  22.3k|   m_subsequences.push_back(DER_Sequence(type_tag, class_tag));
  165|  22.3k|   return (*this);
  166|  22.3k|}
_ZN5Botan11DER_Encoder8end_consEv:
  171|  22.3k|DER_Encoder& DER_Encoder::end_cons() {
  172|  22.3k|   if(m_subsequences.empty()) {
  ------------------
  |  Branch (172:7): [True: 0, False: 22.3k]
  ------------------
  173|      0|      throw Invalid_State("DER_Encoder::end_cons: No such sequence");
  174|      0|   }
  175|       |
  176|  22.3k|   DER_Sequence last_seq = std::move(m_subsequences[m_subsequences.size() - 1]);
  177|  22.3k|   m_subsequences.pop_back();
  178|  22.3k|   last_seq.push_contents(*this);
  179|       |
  180|  22.3k|   return (*this);
  181|  22.3k|}
_ZN5Botan11DER_Encoder9raw_bytesEPKhm:
  207|  18.9k|DER_Encoder& DER_Encoder::raw_bytes(const uint8_t bytes[], size_t length) {
  208|  18.9k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (208:7): [True: 18.9k, False: 0]
  ------------------
  209|  18.9k|      m_subsequences[m_subsequences.size() - 1].add_bytes(bytes, length);
  210|  18.9k|   } else if(m_append_output) {
  ------------------
  |  Branch (210:14): [True: 0, False: 0]
  ------------------
  211|      0|      m_append_output(bytes, length);
  212|      0|   } else {
  213|      0|      m_default_outbuf += std::make_pair(bytes, length);
  214|      0|   }
  215|       |
  216|  18.9k|   return (*this);
  217|  18.9k|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEPKhm:
  222|  29.1k|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
  223|  29.1k|   std::vector<uint8_t> hdr;
  224|  29.1k|   encode_tag(hdr, type_tag, class_tag);
  225|  29.1k|   encode_length(hdr, length);
  226|       |
  227|  29.1k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (227:7): [True: 13.5k, False: 15.5k]
  ------------------
  228|  13.5k|      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
  229|  15.5k|   } else if(m_append_output) {
  ------------------
  |  Branch (229:14): [True: 15.5k, False: 0]
  ------------------
  230|  15.5k|      m_append_output(hdr.data(), hdr.size());
  231|  15.5k|      m_append_output(rep, length);
  232|  15.5k|   } else {
  233|      0|      m_default_outbuf += hdr;
  234|      0|      m_default_outbuf += std::make_pair(rep, length);
  235|      0|   }
  236|       |
  237|  29.1k|   return (*this);
  238|  29.1k|}
_ZN5Botan11DER_Encoder6encodeEPKhmNS_9ASN1_TypeE:
  271|  3.38k|DER_Encoder& DER_Encoder::encode(const uint8_t bytes[], size_t length, ASN1_Type real_type) {
  272|  3.38k|   return encode(bytes, length, real_type, real_type, ASN1_Class::Universal);
  273|  3.38k|}
_ZN5Botan11DER_Encoder6encodeEPKhmNS_9ASN1_TypeES3_NS_10ASN1_ClassE:
  319|  3.38k|   const uint8_t bytes[], size_t length, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag) {
  320|  3.38k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (320:7): [True: 3.38k, False: 0]
  |  Branch (320:46): [True: 0, False: 3.38k]
  ------------------
  321|      0|      throw Invalid_Argument("DER_Encoder: Invalid tag for byte/bit string");
  322|      0|   }
  323|       |
  324|  3.38k|   if(real_type == ASN1_Type::BitString) {
  ------------------
  |  Branch (324:7): [True: 3.38k, False: 0]
  ------------------
  325|  3.38k|      secure_vector<uint8_t> encoded;
  326|  3.38k|      encoded.push_back(0);
  327|  3.38k|      encoded += std::make_pair(bytes, length);
  328|  3.38k|      return add_object(type_tag, class_tag, encoded);
  329|  3.38k|   } else {
  330|      0|      return add_object(type_tag, class_tag, bytes, length);
  331|      0|   }
  332|  3.38k|}
_ZN5Botan11DER_Encoder6encodeERKNS_11ASN1_ObjectE:
  334|  6.77k|DER_Encoder& DER_Encoder::encode(const ASN1_Object& obj) {
  335|  6.77k|   obj.encode_into(*this);
  336|  6.77k|   return (*this);
  337|  6.77k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_110encode_tagERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeENS_10ASN1_ClassE:
   24|  29.1k|void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   25|  29.1k|   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   26|  29.1k|   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
   27|       |
   28|  29.1k|   if((class_tag | 0xE0) != 0xE0) {
  ------------------
  |  Branch (28:7): [True: 0, False: 29.1k]
  ------------------
   29|      0|      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   30|      0|   }
   31|       |
   32|  29.1k|   if(type_tag <= 30) {
  ------------------
  |  Branch (32:7): [True: 29.1k, False: 0]
  ------------------
   33|  29.1k|      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   34|  29.1k|   } else {
   35|      0|      size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
   36|      0|      blocks = (blocks - (blocks % 7)) / 7;
   37|       |
   38|      0|      BOTAN_ASSERT_NOMSG(blocks > 0);
  ------------------
  |  |   60|      0|   do {                                                                     \
  |  |   61|      0|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   62|      0|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      0|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   39|       |
   40|      0|      encoded_tag.push_back(static_cast<uint8_t>(class_tag | 0x1F));
   41|      0|      for(size_t i = 0; i != blocks - 1; ++i) {
  ------------------
  |  Branch (41:25): [True: 0, False: 0]
  ------------------
   42|      0|         encoded_tag.push_back(0x80 | ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
   43|      0|      }
   44|      0|      encoded_tag.push_back(type_tag & 0x7F);
   45|      0|   }
   46|  29.1k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_113encode_lengthERNSt3__16vectorIhNS1_9allocatorIhEEEEm:
   51|  29.1k|void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   52|  29.1k|   if(length <= 127) {
  ------------------
  |  Branch (52:7): [True: 15.9k, False: 13.1k]
  ------------------
   53|  15.9k|      encoded_length.push_back(static_cast<uint8_t>(length));
   54|  15.9k|   } else {
   55|  13.1k|      const size_t bytes_needed = significant_bytes(length);
   56|       |
   57|  13.1k|      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));
   58|       |
   59|  39.4k|      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
  ------------------
  |  Branch (59:53): [True: 26.2k, False: 13.1k]
  ------------------
   60|  26.2k|         encoded_length.push_back(get_byte_var(i, length));
   61|  26.2k|      }
   62|  13.1k|   }
   63|  29.1k|}
der_enc.cpp:_ZZN5Botan11DER_EncoderC1ERNSt3__16vectorIhNS1_9allocatorIhEEEEENK3$_1clEPKhm:
   72|  31.1k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };

_ZN5Botan7OID_MapC2Ev:
   11|      1|OID_Map::OID_Map() {
   12|      1|   m_str2oid = OID_Map::load_str2oid_map();
   13|      1|   m_oid2str = OID_Map::load_oid2str_map();
   14|      1|}
_ZN5Botan7OID_Map15global_registryEv:
   16|  4.96k|OID_Map& OID_Map::global_registry() {
   17|  4.96k|   static OID_Map g_map;
   18|  4.96k|   return g_map;
   19|  4.96k|}
_ZN5Botan7OID_Map7oid2strERKNS_3OIDE:
   56|  4.63k|std::string OID_Map::oid2str(const OID& oid) {
   57|  4.63k|   const std::string oid_str = oid.to_string();
   58|       |
   59|  4.63k|   lock_guard_type<mutex_type> lock(m_mutex);
   60|       |
   61|  4.63k|   auto i = m_oid2str.find(oid_str);
   62|  4.63k|   if(i != m_oid2str.end()) {
  ------------------
  |  Branch (62:7): [True: 3.25k, False: 1.37k]
  ------------------
   63|  3.25k|      return i->second;
   64|  3.25k|   }
   65|       |
   66|  1.37k|   return "";
   67|  4.63k|}
_ZN5Botan7OID_Map7str2oidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   69|    337|OID OID_Map::str2oid(std::string_view str) {
   70|    337|   lock_guard_type<mutex_type> lock(m_mutex);
   71|    337|   auto i = m_str2oid.find(std::string(str));
   72|    337|   if(i != m_str2oid.end()) {
  ------------------
  |  Branch (72:7): [True: 337, False: 0]
  ------------------
   73|    337|      return i->second;
   74|    337|   }
   75|       |
   76|      0|   return OID();
   77|    337|}

_ZN5Botan7OID_Map16load_oid2str_mapEv:
   17|      1|std::unordered_map<std::string, std::string> OID_Map::load_oid2str_map() {
   18|      1|   return std::unordered_map<std::string, std::string>{
   19|       |
   20|      1|      {"0.3.4401.5.3.1.9.26", "Camellia-192/GCM"},
   21|      1|      {"0.3.4401.5.3.1.9.46", "Camellia-256/GCM"},
   22|      1|      {"0.3.4401.5.3.1.9.6", "Camellia-128/GCM"},
   23|      1|      {"0.4.0.127.0.15.1.1.13.0", "XMSS"},
   24|      1|      {"1.0.14888.3.0.5", "ECKCDSA"},
   25|      1|      {"1.2.156.10197.1.104.100", "SM4/OCB"},
   26|      1|      {"1.2.156.10197.1.104.2", "SM4/CBC"},
   27|      1|      {"1.2.156.10197.1.104.8", "SM4/GCM"},
   28|      1|      {"1.2.156.10197.1.301", "sm2p256v1"},
   29|      1|      {"1.2.156.10197.1.301.1", "SM2"},
   30|      1|      {"1.2.156.10197.1.301.2", "SM2_Kex"},
   31|      1|      {"1.2.156.10197.1.301.3", "SM2_Enc"},
   32|      1|      {"1.2.156.10197.1.401", "SM3"},
   33|      1|      {"1.2.156.10197.1.501", "SM2_Sig/SM3"},
   34|      1|      {"1.2.156.10197.1.504", "RSA/EMSA3(SM3)"},
   35|      1|      {"1.2.250.1.223.101.256.1", "frp256v1"},
   36|      1|      {"1.2.392.200011.61.1.1.1.2", "Camellia-128/CBC"},
   37|      1|      {"1.2.392.200011.61.1.1.1.3", "Camellia-192/CBC"},
   38|      1|      {"1.2.392.200011.61.1.1.1.4", "Camellia-256/CBC"},
   39|      1|      {"1.2.410.200004.1.100.4.3", "ECKCDSA/SHA-1"},
   40|      1|      {"1.2.410.200004.1.100.4.4", "ECKCDSA/SHA-224"},
   41|      1|      {"1.2.410.200004.1.100.4.5", "ECKCDSA/SHA-256"},
   42|      1|      {"1.2.410.200004.1.4", "SEED/CBC"},
   43|      1|      {"1.2.643.100.1", "GOST.OGRN"},
   44|      1|      {"1.2.643.100.111", "GOST.SubjectSigningTool"},
   45|      1|      {"1.2.643.100.112", "GOST.IssuerSigningTool"},
   46|      1|      {"1.2.643.2.2.19", "GOST-34.10"},
   47|      1|      {"1.2.643.2.2.3", "GOST-34.10/GOST-R-34.11-94"},
   48|      1|      {"1.2.643.2.2.35.1", "gost_256A"},
   49|      1|      {"1.2.643.2.2.36.0", "gost_256A"},
   50|      1|      {"1.2.643.3.131.1.1", "GOST.INN"},
   51|      1|      {"1.2.643.7.1.1.1.1", "GOST-34.10-2012-256"},
   52|      1|      {"1.2.643.7.1.1.1.2", "GOST-34.10-2012-512"},
   53|      1|      {"1.2.643.7.1.1.2.2", "Streebog-256"},
   54|      1|      {"1.2.643.7.1.1.2.3", "Streebog-512"},
   55|      1|      {"1.2.643.7.1.1.3.2", "GOST-34.10-2012-256/Streebog-256"},
   56|      1|      {"1.2.643.7.1.1.3.3", "GOST-34.10-2012-512/Streebog-512"},
   57|      1|      {"1.2.643.7.1.2.1.1.1", "gost_256A"},
   58|      1|      {"1.2.643.7.1.2.1.1.2", "gost_256B"},
   59|      1|      {"1.2.643.7.1.2.1.2.1", "gost_512A"},
   60|      1|      {"1.2.643.7.1.2.1.2.2", "gost_512B"},
   61|      1|      {"1.2.840.10040.4.1", "DSA"},
   62|      1|      {"1.2.840.10040.4.3", "DSA/SHA-1"},
   63|      1|      {"1.2.840.10045.2.1", "ECDSA"},
   64|      1|      {"1.2.840.10045.3.1.1", "secp192r1"},
   65|      1|      {"1.2.840.10045.3.1.2", "x962_p192v2"},
   66|      1|      {"1.2.840.10045.3.1.3", "x962_p192v3"},
   67|      1|      {"1.2.840.10045.3.1.4", "x962_p239v1"},
   68|      1|      {"1.2.840.10045.3.1.5", "x962_p239v2"},
   69|      1|      {"1.2.840.10045.3.1.6", "x962_p239v3"},
   70|      1|      {"1.2.840.10045.3.1.7", "secp256r1"},
   71|      1|      {"1.2.840.10045.4.1", "ECDSA/SHA-1"},
   72|      1|      {"1.2.840.10045.4.3.1", "ECDSA/SHA-224"},
   73|      1|      {"1.2.840.10045.4.3.2", "ECDSA/SHA-256"},
   74|      1|      {"1.2.840.10045.4.3.3", "ECDSA/SHA-384"},
   75|      1|      {"1.2.840.10045.4.3.4", "ECDSA/SHA-512"},
   76|      1|      {"1.2.840.10046.2.1", "DH"},
   77|      1|      {"1.2.840.113533.7.66.10", "CAST-128/CBC"},
   78|      1|      {"1.2.840.113533.7.66.15", "KeyWrap.CAST-128"},
   79|      1|      {"1.2.840.113549.1.1.1", "RSA"},
   80|      1|      {"1.2.840.113549.1.1.10", "RSA/EMSA4"},
   81|      1|      {"1.2.840.113549.1.1.11", "RSA/EMSA3(SHA-256)"},
   82|      1|      {"1.2.840.113549.1.1.12", "RSA/EMSA3(SHA-384)"},
   83|      1|      {"1.2.840.113549.1.1.13", "RSA/EMSA3(SHA-512)"},
   84|      1|      {"1.2.840.113549.1.1.14", "RSA/EMSA3(SHA-224)"},
   85|      1|      {"1.2.840.113549.1.1.16", "RSA/EMSA3(SHA-512-256)"},
   86|      1|      {"1.2.840.113549.1.1.4", "RSA/EMSA3(MD5)"},
   87|      1|      {"1.2.840.113549.1.1.5", "RSA/EMSA3(SHA-1)"},
   88|      1|      {"1.2.840.113549.1.1.7", "RSA/OAEP"},
   89|      1|      {"1.2.840.113549.1.1.8", "MGF1"},
   90|      1|      {"1.2.840.113549.1.5.12", "PKCS5.PBKDF2"},
   91|      1|      {"1.2.840.113549.1.5.13", "PBE-PKCS5v20"},
   92|      1|      {"1.2.840.113549.1.9.1", "PKCS9.EmailAddress"},
   93|      1|      {"1.2.840.113549.1.9.14", "PKCS9.ExtensionRequest"},
   94|      1|      {"1.2.840.113549.1.9.16.3.18", "ChaCha20Poly1305"},
   95|      1|      {"1.2.840.113549.1.9.16.3.6", "KeyWrap.TripleDES"},
   96|      1|      {"1.2.840.113549.1.9.16.3.8", "Compression.Zlib"},
   97|      1|      {"1.2.840.113549.1.9.2", "PKCS9.UnstructuredName"},
   98|      1|      {"1.2.840.113549.1.9.3", "PKCS9.ContentType"},
   99|      1|      {"1.2.840.113549.1.9.4", "PKCS9.MessageDigest"},
  100|      1|      {"1.2.840.113549.1.9.7", "PKCS9.ChallengePassword"},
  101|      1|      {"1.2.840.113549.2.10", "HMAC(SHA-384)"},
  102|      1|      {"1.2.840.113549.2.11", "HMAC(SHA-512)"},
  103|      1|      {"1.2.840.113549.2.13", "HMAC(SHA-512-256)"},
  104|      1|      {"1.2.840.113549.2.5", "MD5"},
  105|      1|      {"1.2.840.113549.2.7", "HMAC(SHA-1)"},
  106|      1|      {"1.2.840.113549.2.8", "HMAC(SHA-224)"},
  107|      1|      {"1.2.840.113549.2.9", "HMAC(SHA-256)"},
  108|      1|      {"1.2.840.113549.3.7", "TripleDES/CBC"},
  109|      1|      {"1.3.101.110", "Curve25519"},
  110|      1|      {"1.3.101.112", "Ed25519"},
  111|      1|      {"1.3.132.0.10", "secp256k1"},
  112|      1|      {"1.3.132.0.30", "secp160r2"},
  113|      1|      {"1.3.132.0.31", "secp192k1"},
  114|      1|      {"1.3.132.0.32", "secp224k1"},
  115|      1|      {"1.3.132.0.33", "secp224r1"},
  116|      1|      {"1.3.132.0.34", "secp384r1"},
  117|      1|      {"1.3.132.0.35", "secp521r1"},
  118|      1|      {"1.3.132.0.8", "secp160r1"},
  119|      1|      {"1.3.132.0.9", "secp160k1"},
  120|      1|      {"1.3.132.1.12", "ECDH"},
  121|      1|      {"1.3.14.3.2.26", "SHA-1"},
  122|      1|      {"1.3.14.3.2.7", "DES/CBC"},
  123|      1|      {"1.3.36.3.2.1", "RIPEMD-160"},
  124|      1|      {"1.3.36.3.3.1.2", "RSA/EMSA3(RIPEMD-160)"},
  125|      1|      {"1.3.36.3.3.2.5.2.1", "ECGDSA"},
  126|      1|      {"1.3.36.3.3.2.5.4.1", "ECGDSA/RIPEMD-160"},
  127|      1|      {"1.3.36.3.3.2.5.4.2", "ECGDSA/SHA-1"},
  128|      1|      {"1.3.36.3.3.2.5.4.3", "ECGDSA/SHA-224"},
  129|      1|      {"1.3.36.3.3.2.5.4.4", "ECGDSA/SHA-256"},
  130|      1|      {"1.3.36.3.3.2.5.4.5", "ECGDSA/SHA-384"},
  131|      1|      {"1.3.36.3.3.2.5.4.6", "ECGDSA/SHA-512"},
  132|      1|      {"1.3.36.3.3.2.8.1.1.1", "brainpool160r1"},
  133|      1|      {"1.3.36.3.3.2.8.1.1.11", "brainpool384r1"},
  134|      1|      {"1.3.36.3.3.2.8.1.1.13", "brainpool512r1"},
  135|      1|      {"1.3.36.3.3.2.8.1.1.3", "brainpool192r1"},
  136|      1|      {"1.3.36.3.3.2.8.1.1.5", "brainpool224r1"},
  137|      1|      {"1.3.36.3.3.2.8.1.1.7", "brainpool256r1"},
  138|      1|      {"1.3.36.3.3.2.8.1.1.9", "brainpool320r1"},
  139|      1|      {"1.3.6.1.4.1.11591.15.1", "OpenPGP.Ed25519"},
  140|      1|      {"1.3.6.1.4.1.11591.4.11", "Scrypt"},
  141|      1|      {"1.3.6.1.4.1.25258.1.10.1", "Dilithium-4x4-AES-r3"},
  142|      1|      {"1.3.6.1.4.1.25258.1.10.2", "Dilithium-6x5-AES-r3"},
  143|      1|      {"1.3.6.1.4.1.25258.1.10.3", "Dilithium-8x7-AES-r3"},
  144|      1|      {"1.3.6.1.4.1.25258.1.11.1", "Kyber-512-90s-r3"},
  145|      1|      {"1.3.6.1.4.1.25258.1.11.2", "Kyber-768-90s-r3"},
  146|      1|      {"1.3.6.1.4.1.25258.1.11.3", "Kyber-1024-90s-r3"},
  147|      1|      {"1.3.6.1.4.1.25258.1.12.1.1", "SphincsPlus-shake-128s-r3.1"},
  148|      1|      {"1.3.6.1.4.1.25258.1.12.1.2", "SphincsPlus-shake-128f-r3.1"},
  149|      1|      {"1.3.6.1.4.1.25258.1.12.1.3", "SphincsPlus-shake-192s-r3.1"},
  150|      1|      {"1.3.6.1.4.1.25258.1.12.1.4", "SphincsPlus-shake-192f-r3.1"},
  151|      1|      {"1.3.6.1.4.1.25258.1.12.1.5", "SphincsPlus-shake-256s-r3.1"},
  152|      1|      {"1.3.6.1.4.1.25258.1.12.1.6", "SphincsPlus-shake-256f-r3.1"},
  153|      1|      {"1.3.6.1.4.1.25258.1.12.2.1", "SphincsPlus-sha2-128s-r3.1"},
  154|      1|      {"1.3.6.1.4.1.25258.1.12.2.2", "SphincsPlus-sha2-128f-r3.1"},
  155|      1|      {"1.3.6.1.4.1.25258.1.12.2.3", "SphincsPlus-sha2-192s-r3.1"},
  156|      1|      {"1.3.6.1.4.1.25258.1.12.2.4", "SphincsPlus-sha2-192f-r3.1"},
  157|      1|      {"1.3.6.1.4.1.25258.1.12.2.5", "SphincsPlus-sha2-256s-r3.1"},
  158|      1|      {"1.3.6.1.4.1.25258.1.12.2.6", "SphincsPlus-sha2-256f-r3.1"},
  159|      1|      {"1.3.6.1.4.1.25258.1.12.3.1", "SphincsPlus-haraka-128s-r3.1"},
  160|      1|      {"1.3.6.1.4.1.25258.1.12.3.2", "SphincsPlus-haraka-128f-r3.1"},
  161|      1|      {"1.3.6.1.4.1.25258.1.12.3.3", "SphincsPlus-haraka-192s-r3.1"},
  162|      1|      {"1.3.6.1.4.1.25258.1.12.3.4", "SphincsPlus-haraka-192f-r3.1"},
  163|      1|      {"1.3.6.1.4.1.25258.1.12.3.5", "SphincsPlus-haraka-256s-r3.1"},
  164|      1|      {"1.3.6.1.4.1.25258.1.12.3.6", "SphincsPlus-haraka-256f-r3.1"},
  165|      1|      {"1.3.6.1.4.1.25258.1.14.1", "FrodoKEM-640-SHAKE"},
  166|      1|      {"1.3.6.1.4.1.25258.1.14.2", "FrodoKEM-976-SHAKE"},
  167|      1|      {"1.3.6.1.4.1.25258.1.14.3", "FrodoKEM-1344-SHAKE"},
  168|      1|      {"1.3.6.1.4.1.25258.1.15.1", "FrodoKEM-640-AES"},
  169|      1|      {"1.3.6.1.4.1.25258.1.15.2", "FrodoKEM-976-AES"},
  170|      1|      {"1.3.6.1.4.1.25258.1.15.3", "FrodoKEM-1344-AES"},
  171|      1|      {"1.3.6.1.4.1.25258.1.16.1", "eFrodoKEM-640-SHAKE"},
  172|      1|      {"1.3.6.1.4.1.25258.1.16.2", "eFrodoKEM-976-SHAKE"},
  173|      1|      {"1.3.6.1.4.1.25258.1.16.3", "eFrodoKEM-1344-SHAKE"},
  174|      1|      {"1.3.6.1.4.1.25258.1.17.1", "eFrodoKEM-640-AES"},
  175|      1|      {"1.3.6.1.4.1.25258.1.17.2", "eFrodoKEM-976-AES"},
  176|      1|      {"1.3.6.1.4.1.25258.1.17.3", "eFrodoKEM-1344-AES"},
  177|      1|      {"1.3.6.1.4.1.25258.1.3", "McEliece"},
  178|      1|      {"1.3.6.1.4.1.25258.1.5", "XMSS-draft6"},
  179|      1|      {"1.3.6.1.4.1.25258.1.6.1", "GOST-34.10-2012-256/SHA-256"},
  180|      1|      {"1.3.6.1.4.1.25258.1.7.1", "Kyber-512-r3"},
  181|      1|      {"1.3.6.1.4.1.25258.1.7.2", "Kyber-768-r3"},
  182|      1|      {"1.3.6.1.4.1.25258.1.7.3", "Kyber-1024-r3"},
  183|      1|      {"1.3.6.1.4.1.25258.1.8", "XMSS-draft12"},
  184|      1|      {"1.3.6.1.4.1.25258.1.9.1", "Dilithium-4x4-r3"},
  185|      1|      {"1.3.6.1.4.1.25258.1.9.2", "Dilithium-6x5-r3"},
  186|      1|      {"1.3.6.1.4.1.25258.1.9.3", "Dilithium-8x7-r3"},
  187|      1|      {"1.3.6.1.4.1.25258.3.1", "Serpent/CBC"},
  188|      1|      {"1.3.6.1.4.1.25258.3.101", "Serpent/GCM"},
  189|      1|      {"1.3.6.1.4.1.25258.3.102", "Twofish/GCM"},
  190|      1|      {"1.3.6.1.4.1.25258.3.2", "Threefish-512/CBC"},
  191|      1|      {"1.3.6.1.4.1.25258.3.2.1", "AES-128/OCB"},
  192|      1|      {"1.3.6.1.4.1.25258.3.2.2", "AES-192/OCB"},
  193|      1|      {"1.3.6.1.4.1.25258.3.2.3", "AES-256/OCB"},
  194|      1|      {"1.3.6.1.4.1.25258.3.2.4", "Serpent/OCB"},
  195|      1|      {"1.3.6.1.4.1.25258.3.2.5", "Twofish/OCB"},
  196|      1|      {"1.3.6.1.4.1.25258.3.2.6", "Camellia-128/OCB"},
  197|      1|      {"1.3.6.1.4.1.25258.3.2.7", "Camellia-192/OCB"},
  198|      1|      {"1.3.6.1.4.1.25258.3.2.8", "Camellia-256/OCB"},
  199|      1|      {"1.3.6.1.4.1.25258.3.3", "Twofish/CBC"},
  200|      1|      {"1.3.6.1.4.1.25258.3.4.1", "AES-128/SIV"},
  201|      1|      {"1.3.6.1.4.1.25258.3.4.2", "AES-192/SIV"},
  202|      1|      {"1.3.6.1.4.1.25258.3.4.3", "AES-256/SIV"},
  203|      1|      {"1.3.6.1.4.1.25258.3.4.4", "Serpent/SIV"},
  204|      1|      {"1.3.6.1.4.1.25258.3.4.5", "Twofish/SIV"},
  205|      1|      {"1.3.6.1.4.1.25258.3.4.6", "Camellia-128/SIV"},
  206|      1|      {"1.3.6.1.4.1.25258.3.4.7", "Camellia-192/SIV"},
  207|      1|      {"1.3.6.1.4.1.25258.3.4.8", "Camellia-256/SIV"},
  208|      1|      {"1.3.6.1.4.1.25258.3.4.9", "SM4/SIV"},
  209|      1|      {"1.3.6.1.4.1.3029.1.2.1", "ElGamal"},
  210|      1|      {"1.3.6.1.4.1.3029.1.5.1", "OpenPGP.Curve25519"},
  211|      1|      {"1.3.6.1.4.1.311.20.2.2", "Microsoft SmartcardLogon"},
  212|      1|      {"1.3.6.1.4.1.311.20.2.3", "Microsoft UPN"},
  213|      1|      {"1.3.6.1.4.1.8301.3.1.2.9.0.38", "secp521r1"},
  214|      1|      {"1.3.6.1.5.5.7.1.1", "PKIX.AuthorityInformationAccess"},
  215|      1|      {"1.3.6.1.5.5.7.3.1", "PKIX.ServerAuth"},
  216|      1|      {"1.3.6.1.5.5.7.3.2", "PKIX.ClientAuth"},
  217|      1|      {"1.3.6.1.5.5.7.3.3", "PKIX.CodeSigning"},
  218|      1|      {"1.3.6.1.5.5.7.3.4", "PKIX.EmailProtection"},
  219|      1|      {"1.3.6.1.5.5.7.3.5", "PKIX.IPsecEndSystem"},
  220|      1|      {"1.3.6.1.5.5.7.3.6", "PKIX.IPsecTunnel"},
  221|      1|      {"1.3.6.1.5.5.7.3.7", "PKIX.IPsecUser"},
  222|      1|      {"1.3.6.1.5.5.7.3.8", "PKIX.TimeStamping"},
  223|      1|      {"1.3.6.1.5.5.7.3.9", "PKIX.OCSPSigning"},
  224|      1|      {"1.3.6.1.5.5.7.48.1", "PKIX.OCSP"},
  225|      1|      {"1.3.6.1.5.5.7.48.1.1", "PKIX.OCSP.BasicResponse"},
  226|      1|      {"1.3.6.1.5.5.7.48.1.5", "PKIX.OCSP.NoCheck"},
  227|      1|      {"1.3.6.1.5.5.7.48.2", "PKIX.CertificateAuthorityIssuers"},
  228|      1|      {"1.3.6.1.5.5.7.8.5", "PKIX.XMPPAddr"},
  229|      1|      {"2.16.840.1.101.3.4.1.2", "AES-128/CBC"},
  230|      1|      {"2.16.840.1.101.3.4.1.22", "AES-192/CBC"},
  231|      1|      {"2.16.840.1.101.3.4.1.25", "KeyWrap.AES-192"},
  232|      1|      {"2.16.840.1.101.3.4.1.26", "AES-192/GCM"},
  233|      1|      {"2.16.840.1.101.3.4.1.27", "AES-192/CCM"},
  234|      1|      {"2.16.840.1.101.3.4.1.42", "AES-256/CBC"},
  235|      1|      {"2.16.840.1.101.3.4.1.45", "KeyWrap.AES-256"},
  236|      1|      {"2.16.840.1.101.3.4.1.46", "AES-256/GCM"},
  237|      1|      {"2.16.840.1.101.3.4.1.47", "AES-256/CCM"},
  238|      1|      {"2.16.840.1.101.3.4.1.5", "KeyWrap.AES-128"},
  239|      1|      {"2.16.840.1.101.3.4.1.6", "AES-128/GCM"},
  240|      1|      {"2.16.840.1.101.3.4.1.7", "AES-128/CCM"},
  241|      1|      {"2.16.840.1.101.3.4.2.1", "SHA-256"},
  242|      1|      {"2.16.840.1.101.3.4.2.10", "SHA-3(512)"},
  243|      1|      {"2.16.840.1.101.3.4.2.11", "SHAKE-128"},
  244|      1|      {"2.16.840.1.101.3.4.2.12", "SHAKE-256"},
  245|      1|      {"2.16.840.1.101.3.4.2.2", "SHA-384"},
  246|      1|      {"2.16.840.1.101.3.4.2.3", "SHA-512"},
  247|      1|      {"2.16.840.1.101.3.4.2.4", "SHA-224"},
  248|      1|      {"2.16.840.1.101.3.4.2.6", "SHA-512-256"},
  249|      1|      {"2.16.840.1.101.3.4.2.7", "SHA-3(224)"},
  250|      1|      {"2.16.840.1.101.3.4.2.8", "SHA-3(256)"},
  251|      1|      {"2.16.840.1.101.3.4.2.9", "SHA-3(384)"},
  252|      1|      {"2.16.840.1.101.3.4.3.1", "DSA/SHA-224"},
  253|      1|      {"2.16.840.1.101.3.4.3.10", "ECDSA/SHA-3(256)"},
  254|      1|      {"2.16.840.1.101.3.4.3.11", "ECDSA/SHA-3(384)"},
  255|      1|      {"2.16.840.1.101.3.4.3.12", "ECDSA/SHA-3(512)"},
  256|      1|      {"2.16.840.1.101.3.4.3.13", "RSA/EMSA3(SHA-3(224))"},
  257|      1|      {"2.16.840.1.101.3.4.3.14", "RSA/EMSA3(SHA-3(256))"},
  258|      1|      {"2.16.840.1.101.3.4.3.15", "RSA/EMSA3(SHA-3(384))"},
  259|      1|      {"2.16.840.1.101.3.4.3.16", "RSA/EMSA3(SHA-3(512))"},
  260|      1|      {"2.16.840.1.101.3.4.3.2", "DSA/SHA-256"},
  261|      1|      {"2.16.840.1.101.3.4.3.3", "DSA/SHA-384"},
  262|      1|      {"2.16.840.1.101.3.4.3.4", "DSA/SHA-512"},
  263|      1|      {"2.16.840.1.101.3.4.3.5", "DSA/SHA-3(224)"},
  264|      1|      {"2.16.840.1.101.3.4.3.6", "DSA/SHA-3(256)"},
  265|      1|      {"2.16.840.1.101.3.4.3.7", "DSA/SHA-3(384)"},
  266|      1|      {"2.16.840.1.101.3.4.3.8", "DSA/SHA-3(512)"},
  267|      1|      {"2.16.840.1.101.3.4.3.9", "ECDSA/SHA-3(224)"},
  268|      1|      {"2.16.840.1.113730.1.13", "Certificate Comment"},
  269|      1|      {"2.5.29.14", "X509v3.SubjectKeyIdentifier"},
  270|      1|      {"2.5.29.15", "X509v3.KeyUsage"},
  271|      1|      {"2.5.29.16", "X509v3.PrivateKeyUsagePeriod"},
  272|      1|      {"2.5.29.17", "X509v3.SubjectAlternativeName"},
  273|      1|      {"2.5.29.18", "X509v3.IssuerAlternativeName"},
  274|      1|      {"2.5.29.19", "X509v3.BasicConstraints"},
  275|      1|      {"2.5.29.20", "X509v3.CRLNumber"},
  276|      1|      {"2.5.29.21", "X509v3.ReasonCode"},
  277|      1|      {"2.5.29.23", "X509v3.HoldInstructionCode"},
  278|      1|      {"2.5.29.24", "X509v3.InvalidityDate"},
  279|      1|      {"2.5.29.28", "X509v3.CRLIssuingDistributionPoint"},
  280|      1|      {"2.5.29.30", "X509v3.NameConstraints"},
  281|      1|      {"2.5.29.31", "X509v3.CRLDistributionPoints"},
  282|      1|      {"2.5.29.32", "X509v3.CertificatePolicies"},
  283|      1|      {"2.5.29.32.0", "X509v3.AnyPolicy"},
  284|      1|      {"2.5.29.35", "X509v3.AuthorityKeyIdentifier"},
  285|      1|      {"2.5.29.36", "X509v3.PolicyConstraints"},
  286|      1|      {"2.5.29.37", "X509v3.ExtendedKeyUsage"},
  287|      1|      {"2.5.4.10", "X520.Organization"},
  288|      1|      {"2.5.4.11", "X520.OrganizationalUnit"},
  289|      1|      {"2.5.4.12", "X520.Title"},
  290|      1|      {"2.5.4.3", "X520.CommonName"},
  291|      1|      {"2.5.4.4", "X520.Surname"},
  292|      1|      {"2.5.4.42", "X520.GivenName"},
  293|      1|      {"2.5.4.43", "X520.Initials"},
  294|      1|      {"2.5.4.44", "X520.GenerationalQualifier"},
  295|      1|      {"2.5.4.46", "X520.DNQualifier"},
  296|      1|      {"2.5.4.5", "X520.SerialNumber"},
  297|      1|      {"2.5.4.6", "X520.Country"},
  298|      1|      {"2.5.4.65", "X520.Pseudonym"},
  299|      1|      {"2.5.4.7", "X520.Locality"},
  300|      1|      {"2.5.4.8", "X520.State"},
  301|      1|      {"2.5.4.9", "X520.StreetAddress"},
  302|      1|      {"2.5.8.1.1", "RSA"}};
  303|      1|}
_ZN5Botan7OID_Map16load_str2oid_mapEv:
  305|      1|std::unordered_map<std::string, OID> OID_Map::load_str2oid_map() {
  306|      1|   return std::unordered_map<std::string, OID>{
  307|       |
  308|      1|      {"AES-128/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 2})},
  309|      1|      {"AES-128/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 7})},
  310|      1|      {"AES-128/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 6})},
  311|      1|      {"AES-128/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 1})},
  312|      1|      {"AES-128/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 1})},
  313|      1|      {"AES-192/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 22})},
  314|      1|      {"AES-192/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 27})},
  315|      1|      {"AES-192/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 26})},
  316|      1|      {"AES-192/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 2})},
  317|      1|      {"AES-192/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 2})},
  318|      1|      {"AES-256/CBC", OID({2, 16, 840, 1, 101, 3, 4, 1, 42})},
  319|      1|      {"AES-256/CCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 47})},
  320|      1|      {"AES-256/GCM", OID({2, 16, 840, 1, 101, 3, 4, 1, 46})},
  321|      1|      {"AES-256/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 3})},
  322|      1|      {"AES-256/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 3})},
  323|      1|      {"CAST-128/CBC", OID({1, 2, 840, 113533, 7, 66, 10})},
  324|      1|      {"Camellia-128/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 2})},
  325|      1|      {"Camellia-128/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 6})},
  326|      1|      {"Camellia-128/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 6})},
  327|      1|      {"Camellia-128/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 6})},
  328|      1|      {"Camellia-192/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 3})},
  329|      1|      {"Camellia-192/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 26})},
  330|      1|      {"Camellia-192/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 7})},
  331|      1|      {"Camellia-192/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 7})},
  332|      1|      {"Camellia-256/CBC", OID({1, 2, 392, 200011, 61, 1, 1, 1, 4})},
  333|      1|      {"Camellia-256/GCM", OID({0, 3, 4401, 5, 3, 1, 9, 46})},
  334|      1|      {"Camellia-256/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 8})},
  335|      1|      {"Camellia-256/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 8})},
  336|      1|      {"Certificate Comment", OID({2, 16, 840, 1, 113730, 1, 13})},
  337|      1|      {"ChaCha20Poly1305", OID({1, 2, 840, 113549, 1, 9, 16, 3, 18})},
  338|      1|      {"Compression.Zlib", OID({1, 2, 840, 113549, 1, 9, 16, 3, 8})},
  339|      1|      {"Curve25519", OID({1, 3, 101, 110})},
  340|      1|      {"DES/CBC", OID({1, 3, 14, 3, 2, 7})},
  341|      1|      {"DH", OID({1, 2, 840, 10046, 2, 1})},
  342|      1|      {"DSA", OID({1, 2, 840, 10040, 4, 1})},
  343|      1|      {"DSA/SHA-1", OID({1, 2, 840, 10040, 4, 3})},
  344|      1|      {"DSA/SHA-224", OID({2, 16, 840, 1, 101, 3, 4, 3, 1})},
  345|      1|      {"DSA/SHA-256", OID({2, 16, 840, 1, 101, 3, 4, 3, 2})},
  346|      1|      {"DSA/SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 3, 5})},
  347|      1|      {"DSA/SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 3, 6})},
  348|      1|      {"DSA/SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 3, 7})},
  349|      1|      {"DSA/SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 3, 8})},
  350|      1|      {"DSA/SHA-384", OID({2, 16, 840, 1, 101, 3, 4, 3, 3})},
  351|      1|      {"DSA/SHA-512", OID({2, 16, 840, 1, 101, 3, 4, 3, 4})},
  352|      1|      {"Dilithium-4x4-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 1})},
  353|      1|      {"Dilithium-4x4-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 1})},
  354|      1|      {"Dilithium-6x5-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 2})},
  355|      1|      {"Dilithium-6x5-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 2})},
  356|      1|      {"Dilithium-8x7-AES-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 10, 3})},
  357|      1|      {"Dilithium-8x7-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 9, 3})},
  358|      1|      {"ECDH", OID({1, 3, 132, 1, 12})},
  359|      1|      {"ECDSA", OID({1, 2, 840, 10045, 2, 1})},
  360|      1|      {"ECDSA/SHA-1", OID({1, 2, 840, 10045, 4, 1})},
  361|      1|      {"ECDSA/SHA-224", OID({1, 2, 840, 10045, 4, 3, 1})},
  362|      1|      {"ECDSA/SHA-256", OID({1, 2, 840, 10045, 4, 3, 2})},
  363|      1|      {"ECDSA/SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 3, 9})},
  364|      1|      {"ECDSA/SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 3, 10})},
  365|      1|      {"ECDSA/SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 3, 11})},
  366|      1|      {"ECDSA/SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 3, 12})},
  367|      1|      {"ECDSA/SHA-384", OID({1, 2, 840, 10045, 4, 3, 3})},
  368|      1|      {"ECDSA/SHA-512", OID({1, 2, 840, 10045, 4, 3, 4})},
  369|      1|      {"ECGDSA", OID({1, 3, 36, 3, 3, 2, 5, 2, 1})},
  370|      1|      {"ECGDSA/RIPEMD-160", OID({1, 3, 36, 3, 3, 2, 5, 4, 1})},
  371|      1|      {"ECGDSA/SHA-1", OID({1, 3, 36, 3, 3, 2, 5, 4, 2})},
  372|      1|      {"ECGDSA/SHA-224", OID({1, 3, 36, 3, 3, 2, 5, 4, 3})},
  373|      1|      {"ECGDSA/SHA-256", OID({1, 3, 36, 3, 3, 2, 5, 4, 4})},
  374|      1|      {"ECGDSA/SHA-384", OID({1, 3, 36, 3, 3, 2, 5, 4, 5})},
  375|      1|      {"ECGDSA/SHA-512", OID({1, 3, 36, 3, 3, 2, 5, 4, 6})},
  376|      1|      {"ECKCDSA", OID({1, 0, 14888, 3, 0, 5})},
  377|      1|      {"ECKCDSA/SHA-1", OID({1, 2, 410, 200004, 1, 100, 4, 3})},
  378|      1|      {"ECKCDSA/SHA-224", OID({1, 2, 410, 200004, 1, 100, 4, 4})},
  379|      1|      {"ECKCDSA/SHA-256", OID({1, 2, 410, 200004, 1, 100, 4, 5})},
  380|      1|      {"Ed25519", OID({1, 3, 101, 112})},
  381|      1|      {"ElGamal", OID({1, 3, 6, 1, 4, 1, 3029, 1, 2, 1})},
  382|      1|      {"FrodoKEM-1344-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 3})},
  383|      1|      {"FrodoKEM-1344-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 3})},
  384|      1|      {"FrodoKEM-640-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 1})},
  385|      1|      {"FrodoKEM-640-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 1})},
  386|      1|      {"FrodoKEM-976-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 15, 2})},
  387|      1|      {"FrodoKEM-976-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 14, 2})},
  388|      1|      {"GOST-34.10", OID({1, 2, 643, 2, 2, 19})},
  389|      1|      {"GOST-34.10-2012-256", OID({1, 2, 643, 7, 1, 1, 1, 1})},
  390|      1|      {"GOST-34.10-2012-256/SHA-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 6, 1})},
  391|      1|      {"GOST-34.10-2012-256/Streebog-256", OID({1, 2, 643, 7, 1, 1, 3, 2})},
  392|      1|      {"GOST-34.10-2012-512", OID({1, 2, 643, 7, 1, 1, 1, 2})},
  393|      1|      {"GOST-34.10-2012-512/Streebog-512", OID({1, 2, 643, 7, 1, 1, 3, 3})},
  394|      1|      {"GOST-34.10/GOST-R-34.11-94", OID({1, 2, 643, 2, 2, 3})},
  395|      1|      {"GOST.INN", OID({1, 2, 643, 3, 131, 1, 1})},
  396|      1|      {"GOST.IssuerSigningTool", OID({1, 2, 643, 100, 112})},
  397|      1|      {"GOST.OGRN", OID({1, 2, 643, 100, 1})},
  398|      1|      {"GOST.SubjectSigningTool", OID({1, 2, 643, 100, 111})},
  399|      1|      {"HMAC(SHA-1)", OID({1, 2, 840, 113549, 2, 7})},
  400|      1|      {"HMAC(SHA-224)", OID({1, 2, 840, 113549, 2, 8})},
  401|      1|      {"HMAC(SHA-256)", OID({1, 2, 840, 113549, 2, 9})},
  402|      1|      {"HMAC(SHA-384)", OID({1, 2, 840, 113549, 2, 10})},
  403|      1|      {"HMAC(SHA-512)", OID({1, 2, 840, 113549, 2, 11})},
  404|      1|      {"HMAC(SHA-512-256)", OID({1, 2, 840, 113549, 2, 13})},
  405|      1|      {"KeyWrap.AES-128", OID({2, 16, 840, 1, 101, 3, 4, 1, 5})},
  406|      1|      {"KeyWrap.AES-192", OID({2, 16, 840, 1, 101, 3, 4, 1, 25})},
  407|      1|      {"KeyWrap.AES-256", OID({2, 16, 840, 1, 101, 3, 4, 1, 45})},
  408|      1|      {"KeyWrap.CAST-128", OID({1, 2, 840, 113533, 7, 66, 15})},
  409|      1|      {"KeyWrap.TripleDES", OID({1, 2, 840, 113549, 1, 9, 16, 3, 6})},
  410|      1|      {"Kyber-1024-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 3})},
  411|      1|      {"Kyber-1024-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 3})},
  412|      1|      {"Kyber-512-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 1})},
  413|      1|      {"Kyber-512-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 1})},
  414|      1|      {"Kyber-768-90s-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 11, 2})},
  415|      1|      {"Kyber-768-r3", OID({1, 3, 6, 1, 4, 1, 25258, 1, 7, 2})},
  416|      1|      {"MD5", OID({1, 2, 840, 113549, 2, 5})},
  417|      1|      {"MGF1", OID({1, 2, 840, 113549, 1, 1, 8})},
  418|      1|      {"McEliece", OID({1, 3, 6, 1, 4, 1, 25258, 1, 3})},
  419|      1|      {"Microsoft SmartcardLogon", OID({1, 3, 6, 1, 4, 1, 311, 20, 2, 2})},
  420|      1|      {"Microsoft UPN", OID({1, 3, 6, 1, 4, 1, 311, 20, 2, 3})},
  421|      1|      {"OpenPGP.Curve25519", OID({1, 3, 6, 1, 4, 1, 3029, 1, 5, 1})},
  422|      1|      {"OpenPGP.Ed25519", OID({1, 3, 6, 1, 4, 1, 11591, 15, 1})},
  423|      1|      {"PBE-PKCS5v20", OID({1, 2, 840, 113549, 1, 5, 13})},
  424|      1|      {"PBES2", OID({1, 2, 840, 113549, 1, 5, 13})},
  425|      1|      {"PKCS5.PBKDF2", OID({1, 2, 840, 113549, 1, 5, 12})},
  426|      1|      {"PKCS9.ChallengePassword", OID({1, 2, 840, 113549, 1, 9, 7})},
  427|      1|      {"PKCS9.ContentType", OID({1, 2, 840, 113549, 1, 9, 3})},
  428|      1|      {"PKCS9.EmailAddress", OID({1, 2, 840, 113549, 1, 9, 1})},
  429|      1|      {"PKCS9.ExtensionRequest", OID({1, 2, 840, 113549, 1, 9, 14})},
  430|      1|      {"PKCS9.MessageDigest", OID({1, 2, 840, 113549, 1, 9, 4})},
  431|      1|      {"PKCS9.UnstructuredName", OID({1, 2, 840, 113549, 1, 9, 2})},
  432|      1|      {"PKIX.AuthorityInformationAccess", OID({1, 3, 6, 1, 5, 5, 7, 1, 1})},
  433|      1|      {"PKIX.CertificateAuthorityIssuers", OID({1, 3, 6, 1, 5, 5, 7, 48, 2})},
  434|      1|      {"PKIX.ClientAuth", OID({1, 3, 6, 1, 5, 5, 7, 3, 2})},
  435|      1|      {"PKIX.CodeSigning", OID({1, 3, 6, 1, 5, 5, 7, 3, 3})},
  436|      1|      {"PKIX.EmailProtection", OID({1, 3, 6, 1, 5, 5, 7, 3, 4})},
  437|      1|      {"PKIX.IPsecEndSystem", OID({1, 3, 6, 1, 5, 5, 7, 3, 5})},
  438|      1|      {"PKIX.IPsecTunnel", OID({1, 3, 6, 1, 5, 5, 7, 3, 6})},
  439|      1|      {"PKIX.IPsecUser", OID({1, 3, 6, 1, 5, 5, 7, 3, 7})},
  440|      1|      {"PKIX.OCSP", OID({1, 3, 6, 1, 5, 5, 7, 48, 1})},
  441|      1|      {"PKIX.OCSP.BasicResponse", OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 1})},
  442|      1|      {"PKIX.OCSP.NoCheck", OID({1, 3, 6, 1, 5, 5, 7, 48, 1, 5})},
  443|      1|      {"PKIX.OCSPSigning", OID({1, 3, 6, 1, 5, 5, 7, 3, 9})},
  444|      1|      {"PKIX.ServerAuth", OID({1, 3, 6, 1, 5, 5, 7, 3, 1})},
  445|      1|      {"PKIX.TimeStamping", OID({1, 3, 6, 1, 5, 5, 7, 3, 8})},
  446|      1|      {"PKIX.XMPPAddr", OID({1, 3, 6, 1, 5, 5, 7, 8, 5})},
  447|      1|      {"RIPEMD-160", OID({1, 3, 36, 3, 2, 1})},
  448|      1|      {"RSA", OID({1, 2, 840, 113549, 1, 1, 1})},
  449|      1|      {"RSA/EMSA3(MD5)", OID({1, 2, 840, 113549, 1, 1, 4})},
  450|      1|      {"RSA/EMSA3(RIPEMD-160)", OID({1, 3, 36, 3, 3, 1, 2})},
  451|      1|      {"RSA/EMSA3(SHA-1)", OID({1, 2, 840, 113549, 1, 1, 5})},
  452|      1|      {"RSA/EMSA3(SHA-224)", OID({1, 2, 840, 113549, 1, 1, 14})},
  453|      1|      {"RSA/EMSA3(SHA-256)", OID({1, 2, 840, 113549, 1, 1, 11})},
  454|      1|      {"RSA/EMSA3(SHA-3(224))", OID({2, 16, 840, 1, 101, 3, 4, 3, 13})},
  455|      1|      {"RSA/EMSA3(SHA-3(256))", OID({2, 16, 840, 1, 101, 3, 4, 3, 14})},
  456|      1|      {"RSA/EMSA3(SHA-3(384))", OID({2, 16, 840, 1, 101, 3, 4, 3, 15})},
  457|      1|      {"RSA/EMSA3(SHA-3(512))", OID({2, 16, 840, 1, 101, 3, 4, 3, 16})},
  458|      1|      {"RSA/EMSA3(SHA-384)", OID({1, 2, 840, 113549, 1, 1, 12})},
  459|      1|      {"RSA/EMSA3(SHA-512)", OID({1, 2, 840, 113549, 1, 1, 13})},
  460|      1|      {"RSA/EMSA3(SHA-512-256)", OID({1, 2, 840, 113549, 1, 1, 16})},
  461|      1|      {"RSA/EMSA3(SM3)", OID({1, 2, 156, 10197, 1, 504})},
  462|      1|      {"RSA/EMSA4", OID({1, 2, 840, 113549, 1, 1, 10})},
  463|      1|      {"RSA/OAEP", OID({1, 2, 840, 113549, 1, 1, 7})},
  464|      1|      {"SEED/CBC", OID({1, 2, 410, 200004, 1, 4})},
  465|      1|      {"SHA-1", OID({1, 3, 14, 3, 2, 26})},
  466|      1|      {"SHA-224", OID({2, 16, 840, 1, 101, 3, 4, 2, 4})},
  467|      1|      {"SHA-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 1})},
  468|      1|      {"SHA-3(224)", OID({2, 16, 840, 1, 101, 3, 4, 2, 7})},
  469|      1|      {"SHA-3(256)", OID({2, 16, 840, 1, 101, 3, 4, 2, 8})},
  470|      1|      {"SHA-3(384)", OID({2, 16, 840, 1, 101, 3, 4, 2, 9})},
  471|      1|      {"SHA-3(512)", OID({2, 16, 840, 1, 101, 3, 4, 2, 10})},
  472|      1|      {"SHA-384", OID({2, 16, 840, 1, 101, 3, 4, 2, 2})},
  473|      1|      {"SHA-512", OID({2, 16, 840, 1, 101, 3, 4, 2, 3})},
  474|      1|      {"SHA-512-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 6})},
  475|      1|      {"SHAKE-128", OID({2, 16, 840, 1, 101, 3, 4, 2, 11})},
  476|      1|      {"SHAKE-256", OID({2, 16, 840, 1, 101, 3, 4, 2, 12})},
  477|      1|      {"SM2", OID({1, 2, 156, 10197, 1, 301, 1})},
  478|      1|      {"SM2_Enc", OID({1, 2, 156, 10197, 1, 301, 3})},
  479|      1|      {"SM2_Kex", OID({1, 2, 156, 10197, 1, 301, 2})},
  480|      1|      {"SM2_Sig", OID({1, 2, 156, 10197, 1, 301, 1})},
  481|      1|      {"SM2_Sig/SM3", OID({1, 2, 156, 10197, 1, 501})},
  482|      1|      {"SM3", OID({1, 2, 156, 10197, 1, 401})},
  483|      1|      {"SM4/CBC", OID({1, 2, 156, 10197, 1, 104, 2})},
  484|      1|      {"SM4/GCM", OID({1, 2, 156, 10197, 1, 104, 8})},
  485|      1|      {"SM4/OCB", OID({1, 2, 156, 10197, 1, 104, 100})},
  486|      1|      {"SM4/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 9})},
  487|      1|      {"Scrypt", OID({1, 3, 6, 1, 4, 1, 11591, 4, 11})},
  488|      1|      {"Serpent/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 1})},
  489|      1|      {"Serpent/GCM", OID({1, 3, 6, 1, 4, 1, 25258, 3, 101})},
  490|      1|      {"Serpent/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 4})},
  491|      1|      {"Serpent/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 4})},
  492|      1|      {"SphincsPlus-haraka-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 2})},
  493|      1|      {"SphincsPlus-haraka-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 1})},
  494|      1|      {"SphincsPlus-haraka-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 4})},
  495|      1|      {"SphincsPlus-haraka-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 3})},
  496|      1|      {"SphincsPlus-haraka-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 6})},
  497|      1|      {"SphincsPlus-haraka-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 3, 5})},
  498|      1|      {"SphincsPlus-sha2-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 2})},
  499|      1|      {"SphincsPlus-sha2-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 1})},
  500|      1|      {"SphincsPlus-sha2-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 4})},
  501|      1|      {"SphincsPlus-sha2-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 3})},
  502|      1|      {"SphincsPlus-sha2-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 6})},
  503|      1|      {"SphincsPlus-sha2-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 2, 5})},
  504|      1|      {"SphincsPlus-shake-128f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 2})},
  505|      1|      {"SphincsPlus-shake-128s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 1})},
  506|      1|      {"SphincsPlus-shake-192f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 4})},
  507|      1|      {"SphincsPlus-shake-192s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 3})},
  508|      1|      {"SphincsPlus-shake-256f-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 6})},
  509|      1|      {"SphincsPlus-shake-256s-r3.1", OID({1, 3, 6, 1, 4, 1, 25258, 1, 12, 1, 5})},
  510|      1|      {"Streebog-256", OID({1, 2, 643, 7, 1, 1, 2, 2})},
  511|      1|      {"Streebog-512", OID({1, 2, 643, 7, 1, 1, 2, 3})},
  512|      1|      {"Threefish-512/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2})},
  513|      1|      {"TripleDES/CBC", OID({1, 2, 840, 113549, 3, 7})},
  514|      1|      {"Twofish/CBC", OID({1, 3, 6, 1, 4, 1, 25258, 3, 3})},
  515|      1|      {"Twofish/GCM", OID({1, 3, 6, 1, 4, 1, 25258, 3, 102})},
  516|      1|      {"Twofish/OCB", OID({1, 3, 6, 1, 4, 1, 25258, 3, 2, 5})},
  517|      1|      {"Twofish/SIV", OID({1, 3, 6, 1, 4, 1, 25258, 3, 4, 5})},
  518|      1|      {"X509v3.AnyPolicy", OID({2, 5, 29, 32, 0})},
  519|      1|      {"X509v3.AuthorityKeyIdentifier", OID({2, 5, 29, 35})},
  520|      1|      {"X509v3.BasicConstraints", OID({2, 5, 29, 19})},
  521|      1|      {"X509v3.CRLDistributionPoints", OID({2, 5, 29, 31})},
  522|      1|      {"X509v3.CRLIssuingDistributionPoint", OID({2, 5, 29, 28})},
  523|      1|      {"X509v3.CRLNumber", OID({2, 5, 29, 20})},
  524|      1|      {"X509v3.CertificatePolicies", OID({2, 5, 29, 32})},
  525|      1|      {"X509v3.ExtendedKeyUsage", OID({2, 5, 29, 37})},
  526|      1|      {"X509v3.HoldInstructionCode", OID({2, 5, 29, 23})},
  527|      1|      {"X509v3.InvalidityDate", OID({2, 5, 29, 24})},
  528|      1|      {"X509v3.IssuerAlternativeName", OID({2, 5, 29, 18})},
  529|      1|      {"X509v3.KeyUsage", OID({2, 5, 29, 15})},
  530|      1|      {"X509v3.NameConstraints", OID({2, 5, 29, 30})},
  531|      1|      {"X509v3.PolicyConstraints", OID({2, 5, 29, 36})},
  532|      1|      {"X509v3.PrivateKeyUsagePeriod", OID({2, 5, 29, 16})},
  533|      1|      {"X509v3.ReasonCode", OID({2, 5, 29, 21})},
  534|      1|      {"X509v3.SubjectAlternativeName", OID({2, 5, 29, 17})},
  535|      1|      {"X509v3.SubjectKeyIdentifier", OID({2, 5, 29, 14})},
  536|      1|      {"X520.CommonName", OID({2, 5, 4, 3})},
  537|      1|      {"X520.Country", OID({2, 5, 4, 6})},
  538|      1|      {"X520.DNQualifier", OID({2, 5, 4, 46})},
  539|      1|      {"X520.GenerationalQualifier", OID({2, 5, 4, 44})},
  540|      1|      {"X520.GivenName", OID({2, 5, 4, 42})},
  541|      1|      {"X520.Initials", OID({2, 5, 4, 43})},
  542|      1|      {"X520.Locality", OID({2, 5, 4, 7})},
  543|      1|      {"X520.Organization", OID({2, 5, 4, 10})},
  544|      1|      {"X520.OrganizationalUnit", OID({2, 5, 4, 11})},
  545|      1|      {"X520.Pseudonym", OID({2, 5, 4, 65})},
  546|      1|      {"X520.SerialNumber", OID({2, 5, 4, 5})},
  547|      1|      {"X520.State", OID({2, 5, 4, 8})},
  548|      1|      {"X520.StreetAddress", OID({2, 5, 4, 9})},
  549|      1|      {"X520.Surname", OID({2, 5, 4, 4})},
  550|      1|      {"X520.Title", OID({2, 5, 4, 12})},
  551|      1|      {"XMSS", OID({0, 4, 0, 127, 0, 15, 1, 1, 13, 0})},
  552|      1|      {"XMSS-draft12", OID({1, 3, 6, 1, 4, 1, 25258, 1, 8})},
  553|      1|      {"XMSS-draft6", OID({1, 3, 6, 1, 4, 1, 25258, 1, 5})},
  554|      1|      {"brainpool160r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 1})},
  555|      1|      {"brainpool192r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 3})},
  556|      1|      {"brainpool224r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 5})},
  557|      1|      {"brainpool256r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 7})},
  558|      1|      {"brainpool320r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 9})},
  559|      1|      {"brainpool384r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 11})},
  560|      1|      {"brainpool512r1", OID({1, 3, 36, 3, 3, 2, 8, 1, 1, 13})},
  561|      1|      {"eFrodoKEM-1344-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 3})},
  562|      1|      {"eFrodoKEM-1344-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 3})},
  563|      1|      {"eFrodoKEM-640-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 1})},
  564|      1|      {"eFrodoKEM-640-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 1})},
  565|      1|      {"eFrodoKEM-976-AES", OID({1, 3, 6, 1, 4, 1, 25258, 1, 17, 2})},
  566|      1|      {"eFrodoKEM-976-SHAKE", OID({1, 3, 6, 1, 4, 1, 25258, 1, 16, 2})},
  567|      1|      {"frp256v1", OID({1, 2, 250, 1, 223, 101, 256, 1})},
  568|      1|      {"gost_256A", OID({1, 2, 643, 7, 1, 2, 1, 1, 1})},
  569|      1|      {"gost_256B", OID({1, 2, 643, 7, 1, 2, 1, 1, 2})},
  570|      1|      {"gost_512A", OID({1, 2, 643, 7, 1, 2, 1, 2, 1})},
  571|      1|      {"gost_512B", OID({1, 2, 643, 7, 1, 2, 1, 2, 2})},
  572|      1|      {"secp160k1", OID({1, 3, 132, 0, 9})},
  573|      1|      {"secp160r1", OID({1, 3, 132, 0, 8})},
  574|      1|      {"secp160r2", OID({1, 3, 132, 0, 30})},
  575|      1|      {"secp192k1", OID({1, 3, 132, 0, 31})},
  576|      1|      {"secp192r1", OID({1, 2, 840, 10045, 3, 1, 1})},
  577|      1|      {"secp224k1", OID({1, 3, 132, 0, 32})},
  578|      1|      {"secp224r1", OID({1, 3, 132, 0, 33})},
  579|      1|      {"secp256k1", OID({1, 3, 132, 0, 10})},
  580|      1|      {"secp256r1", OID({1, 2, 840, 10045, 3, 1, 7})},
  581|      1|      {"secp384r1", OID({1, 3, 132, 0, 34})},
  582|      1|      {"secp521r1", OID({1, 3, 132, 0, 35})},
  583|      1|      {"sm2p256v1", OID({1, 2, 156, 10197, 1, 301})},
  584|      1|      {"x962_p192v2", OID({1, 2, 840, 10045, 3, 1, 2})},
  585|      1|      {"x962_p192v3", OID({1, 2, 840, 10045, 3, 1, 3})},
  586|      1|      {"x962_p239v1", OID({1, 2, 840, 10045, 3, 1, 4})},
  587|      1|      {"x962_p239v2", OID({1, 2, 840, 10045, 3, 1, 5})},
  588|      1|      {"x962_p239v3", OID({1, 2, 840, 10045, 3, 1, 6})}};
  589|      1|}

_ZN5Botan10PSS_ParamsC2EPKhm:
   37|      3|PSS_Params::PSS_Params(const uint8_t der[], size_t der_len) {
   38|      3|   BER_Decoder decoder(der, der_len);
   39|      3|   this->decode_from(decoder);
   40|      3|}
_ZN5Botan10PSS_Params11decode_fromERNS_11BER_DecoderE:
   67|      3|void PSS_Params::decode_from(BER_Decoder& from) {
   68|      3|   const AlgorithmIdentifier default_hash("SHA-1", AlgorithmIdentifier::USE_NULL_PARAM);
   69|      3|   const AlgorithmIdentifier default_mgf("MGF1", default_hash.BER_encode());
   70|      3|   const size_t default_salt_len = 20;
   71|      3|   const size_t default_trailer = 1;
   72|       |
   73|      3|   from.start_sequence()
   74|      3|      .decode_optional(m_hash, ASN1_Type(0), ASN1_Class::ExplicitContextSpecific, default_hash)
   75|      3|      .decode_optional(m_mgf, ASN1_Type(1), ASN1_Class::ExplicitContextSpecific, default_mgf)
   76|      3|      .decode_optional(m_salt_len, ASN1_Type(2), ASN1_Class::ExplicitContextSpecific, default_salt_len)
   77|      3|      .decode_optional(m_trailer_field, ASN1_Type(3), ASN1_Class::ExplicitContextSpecific, default_trailer)
   78|      3|      .end_cons();
   79|       |
   80|      3|   BER_Decoder(m_mgf.parameters()).decode(m_mgf_hash);
   81|      3|}

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

_ZN5Botan10hex_encodeEPcPKhmb:
   33|  6.77k|void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase) {
   34|   182k|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (34:22): [True: 176k, False: 6.77k]
  ------------------
   35|   176k|      const uint8_t n0 = (input[i] >> 4) & 0xF;
   36|   176k|      const uint8_t n1 = (input[i]) & 0xF;
   37|       |
   38|   176k|      output[2 * i] = hex_encode_nibble(n0, uppercase);
   39|   176k|      output[2 * i + 1] = hex_encode_nibble(n1, uppercase);
   40|   176k|   }
   41|  6.77k|}
_ZN5Botan10hex_encodeEPKhmb:
   43|  6.77k|std::string hex_encode(const uint8_t input[], size_t input_length, bool uppercase) {
   44|  6.77k|   std::string output(2 * input_length, 0);
   45|       |
   46|  6.77k|   if(input_length) {
  ------------------
  |  Branch (46:7): [True: 6.77k, False: 0]
  ------------------
   47|  6.77k|      hex_encode(&output.front(), input, input_length, uppercase);
   48|  6.77k|   }
   49|       |
   50|  6.77k|   return output;
   51|  6.77k|}
hex.cpp:_ZN5Botan12_GLOBAL__N_117hex_encode_nibbleEhb:
   20|   352k|char hex_encode_nibble(uint8_t n, bool uppercase) {
   21|   352k|   BOTAN_DEBUG_ASSERT(n <= 15);
  ------------------
  |  |   99|   352k|      do {                          \
  |  |  100|   352k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   22|       |
   23|   352k|   const auto in_09 = CT::Mask<uint8_t>::is_lt(n, 10);
   24|       |
   25|   352k|   const char c_09 = n + '0';
   26|   352k|   const char c_af = n + (uppercase ? 'A' : 'a') - 10;
  ------------------
  |  Branch (26:27): [True: 352k, False: 0]
  ------------------
   27|       |
   28|   352k|   return in_09.select(c_09, c_af);
   29|   352k|}

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

_ZN5Botan3MD510compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   62|  2.46k|void MD5::compress_n(MD5::digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   63|  2.46k|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3];
   64|  2.46k|   std::array<uint32_t, 16> M;
   65|       |
   66|  2.46k|   BufferSlicer in(input);
   67|       |
   68|  18.1k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (68:22): [True: 15.6k, False: 2.46k]
  ------------------
   69|  15.6k|      load_le(M.data(), in.take(block_bytes).data(), M.size());
   70|       |
   71|  15.6k|      FF<7>(A, B, C, D, M[0] + 0xD76AA478);
   72|  15.6k|      FF<12>(D, A, B, C, M[1] + 0xE8C7B756);
   73|  15.6k|      FF<17>(C, D, A, B, M[2] + 0x242070DB);
   74|  15.6k|      FF<22>(B, C, D, A, M[3] + 0xC1BDCEEE);
   75|  15.6k|      FF<7>(A, B, C, D, M[4] + 0xF57C0FAF);
   76|  15.6k|      FF<12>(D, A, B, C, M[5] + 0x4787C62A);
   77|  15.6k|      FF<17>(C, D, A, B, M[6] + 0xA8304613);
   78|  15.6k|      FF<22>(B, C, D, A, M[7] + 0xFD469501);
   79|  15.6k|      FF<7>(A, B, C, D, M[8] + 0x698098D8);
   80|  15.6k|      FF<12>(D, A, B, C, M[9] + 0x8B44F7AF);
   81|  15.6k|      FF<17>(C, D, A, B, M[10] + 0xFFFF5BB1);
   82|  15.6k|      FF<22>(B, C, D, A, M[11] + 0x895CD7BE);
   83|  15.6k|      FF<7>(A, B, C, D, M[12] + 0x6B901122);
   84|  15.6k|      FF<12>(D, A, B, C, M[13] + 0xFD987193);
   85|  15.6k|      FF<17>(C, D, A, B, M[14] + 0xA679438E);
   86|  15.6k|      FF<22>(B, C, D, A, M[15] + 0x49B40821);
   87|       |
   88|  15.6k|      GG<5>(A, B, C, D, M[1] + 0xF61E2562);
   89|  15.6k|      GG<9>(D, A, B, C, M[6] + 0xC040B340);
   90|  15.6k|      GG<14>(C, D, A, B, M[11] + 0x265E5A51);
   91|  15.6k|      GG<20>(B, C, D, A, M[0] + 0xE9B6C7AA);
   92|  15.6k|      GG<5>(A, B, C, D, M[5] + 0xD62F105D);
   93|  15.6k|      GG<9>(D, A, B, C, M[10] + 0x02441453);
   94|  15.6k|      GG<14>(C, D, A, B, M[15] + 0xD8A1E681);
   95|  15.6k|      GG<20>(B, C, D, A, M[4] + 0xE7D3FBC8);
   96|  15.6k|      GG<5>(A, B, C, D, M[9] + 0x21E1CDE6);
   97|  15.6k|      GG<9>(D, A, B, C, M[14] + 0xC33707D6);
   98|  15.6k|      GG<14>(C, D, A, B, M[3] + 0xF4D50D87);
   99|  15.6k|      GG<20>(B, C, D, A, M[8] + 0x455A14ED);
  100|  15.6k|      GG<5>(A, B, C, D, M[13] + 0xA9E3E905);
  101|  15.6k|      GG<9>(D, A, B, C, M[2] + 0xFCEFA3F8);
  102|  15.6k|      GG<14>(C, D, A, B, M[7] + 0x676F02D9);
  103|  15.6k|      GG<20>(B, C, D, A, M[12] + 0x8D2A4C8A);
  104|       |
  105|  15.6k|      HH<4>(A, B, C, D, M[5] + 0xFFFA3942);
  106|  15.6k|      HH<11>(D, A, B, C, M[8] + 0x8771F681);
  107|  15.6k|      HH<16>(C, D, A, B, M[11] + 0x6D9D6122);
  108|  15.6k|      HH<23>(B, C, D, A, M[14] + 0xFDE5380C);
  109|  15.6k|      HH<4>(A, B, C, D, M[1] + 0xA4BEEA44);
  110|  15.6k|      HH<11>(D, A, B, C, M[4] + 0x4BDECFA9);
  111|  15.6k|      HH<16>(C, D, A, B, M[7] + 0xF6BB4B60);
  112|  15.6k|      HH<23>(B, C, D, A, M[10] + 0xBEBFBC70);
  113|  15.6k|      HH<4>(A, B, C, D, M[13] + 0x289B7EC6);
  114|  15.6k|      HH<11>(D, A, B, C, M[0] + 0xEAA127FA);
  115|  15.6k|      HH<16>(C, D, A, B, M[3] + 0xD4EF3085);
  116|  15.6k|      HH<23>(B, C, D, A, M[6] + 0x04881D05);
  117|  15.6k|      HH<4>(A, B, C, D, M[9] + 0xD9D4D039);
  118|  15.6k|      HH<11>(D, A, B, C, M[12] + 0xE6DB99E5);
  119|  15.6k|      HH<16>(C, D, A, B, M[15] + 0x1FA27CF8);
  120|  15.6k|      HH<23>(B, C, D, A, M[2] + 0xC4AC5665);
  121|       |
  122|  15.6k|      II<6>(A, B, C, D, M[0] + 0xF4292244);
  123|  15.6k|      II<10>(D, A, B, C, M[7] + 0x432AFF97);
  124|  15.6k|      II<15>(C, D, A, B, M[14] + 0xAB9423A7);
  125|  15.6k|      II<21>(B, C, D, A, M[5] + 0xFC93A039);
  126|  15.6k|      II<6>(A, B, C, D, M[12] + 0x655B59C3);
  127|  15.6k|      II<10>(D, A, B, C, M[3] + 0x8F0CCC92);
  128|  15.6k|      II<15>(C, D, A, B, M[10] + 0xFFEFF47D);
  129|  15.6k|      II<21>(B, C, D, A, M[1] + 0x85845DD1);
  130|  15.6k|      II<6>(A, B, C, D, M[8] + 0x6FA87E4F);
  131|  15.6k|      II<10>(D, A, B, C, M[15] + 0xFE2CE6E0);
  132|  15.6k|      II<15>(C, D, A, B, M[6] + 0xA3014314);
  133|  15.6k|      II<21>(B, C, D, A, M[13] + 0x4E0811A1);
  134|  15.6k|      II<6>(A, B, C, D, M[4] + 0xF7537E82);
  135|  15.6k|      II<10>(D, A, B, C, M[11] + 0xBD3AF235);
  136|  15.6k|      II<15>(C, D, A, B, M[2] + 0x2AD7D2BB);
  137|  15.6k|      II<21>(B, C, D, A, M[9] + 0xEB86D391);
  138|       |
  139|  15.6k|      A = (digest[0] += A);
  140|  15.6k|      B = (digest[1] += B);
  141|  15.6k|      C = (digest[2] += C);
  142|  15.6k|      D = (digest[3] += D);
  143|  15.6k|   }
  144|  2.46k|}
_ZN5Botan3MD54initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  146|  2.42k|void MD5::init(digest_type& digest) {
  147|  2.42k|   digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476});
  148|  2.42k|}
_ZN5Botan3MD58add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  158|  1.21k|void MD5::add_data(std::span<const uint8_t> input) {
  159|  1.21k|   m_md.update(input);
  160|  1.21k|}
_ZN5Botan3MD512final_resultENSt3__14spanIhLm18446744073709551615EEE:
  162|  1.21k|void MD5::final_result(std::span<uint8_t> output) {
  163|  1.21k|   m_md.final(output);
  164|  1.21k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm7EEEvRjjjjj:
   24|  62.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  62.5k|   A += choose(B, C, D) + M;
   26|  62.5k|   A = rotl<S>(A) + B;
   27|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm12EEEvRjjjjj:
   24|  62.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  62.5k|   A += choose(B, C, D) + M;
   26|  62.5k|   A = rotl<S>(A) + B;
   27|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm17EEEvRjjjjj:
   24|  62.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  62.5k|   A += choose(B, C, D) + M;
   26|  62.5k|   A = rotl<S>(A) + B;
   27|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm22EEEvRjjjjj:
   24|  62.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  62.5k|   A += choose(B, C, D) + M;
   26|  62.5k|   A = rotl<S>(A) + B;
   27|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm5EEEvRjjjjj:
   33|  62.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  62.5k|   A += choose(D, B, C) + M;
   35|  62.5k|   A = rotl<S>(A) + B;
   36|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm9EEEvRjjjjj:
   33|  62.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  62.5k|   A += choose(D, B, C) + M;
   35|  62.5k|   A = rotl<S>(A) + B;
   36|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm14EEEvRjjjjj:
   33|  62.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  62.5k|   A += choose(D, B, C) + M;
   35|  62.5k|   A = rotl<S>(A) + B;
   36|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm20EEEvRjjjjj:
   33|  62.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  62.5k|   A += choose(D, B, C) + M;
   35|  62.5k|   A = rotl<S>(A) + B;
   36|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm4EEEvRjjjjj:
   42|  62.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  62.5k|   A += (B ^ C ^ D) + M;
   44|  62.5k|   A = rotl<S>(A) + B;
   45|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm11EEEvRjjjjj:
   42|  62.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  62.5k|   A += (B ^ C ^ D) + M;
   44|  62.5k|   A = rotl<S>(A) + B;
   45|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm16EEEvRjjjjj:
   42|  62.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  62.5k|   A += (B ^ C ^ D) + M;
   44|  62.5k|   A = rotl<S>(A) + B;
   45|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm23EEEvRjjjjj:
   42|  62.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  62.5k|   A += (B ^ C ^ D) + M;
   44|  62.5k|   A = rotl<S>(A) + B;
   45|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm6EEEvRjjjjj:
   51|  62.5k|inline void II(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   52|       |   // This expr is choose(D, B ^ C, ~C), but that is slower
   53|  62.5k|   A += (C ^ (B | ~D)) + M;
   54|  62.5k|   A = rotl<S>(A) + B;
   55|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm10EEEvRjjjjj:
   51|  62.5k|inline void II(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   52|       |   // This expr is choose(D, B ^ C, ~C), but that is slower
   53|  62.5k|   A += (C ^ (B | ~D)) + M;
   54|  62.5k|   A = rotl<S>(A) + B;
   55|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm15EEEvRjjjjj:
   51|  62.5k|inline void II(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   52|       |   // This expr is choose(D, B ^ C, ~C), but that is slower
   53|  62.5k|   A += (C ^ (B | ~D)) + M;
   54|  62.5k|   A = rotl<S>(A) + B;
   55|  62.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm21EEEvRjjjjj:
   51|  62.5k|inline void II(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   52|       |   // This expr is choose(D, B ^ C, ~C), but that is slower
   53|  62.5k|   A += (C ^ (B | ~D)) + M;
   54|  62.5k|   A = rotl<S>(A) + B;
   55|  62.5k|}

_ZN5Botan5SHA_110compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   63|  13.8k|void SHA_1::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   64|  13.8k|   using namespace SHA1_F;
   65|       |
   66|  13.8k|#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
   67|  13.8k|   if(CPUID::has_intel_sha()) {
  ------------------
  |  Branch (67:7): [True: 0, False: 13.8k]
  ------------------
   68|      0|      return sha1_compress_x86(digest, input, blocks);
   69|      0|   }
   70|  13.8k|#endif
   71|       |
   72|       |#if defined(BOTAN_HAS_SHA1_ARMV8)
   73|       |   if(CPUID::has_arm_sha1()) {
   74|       |      return sha1_armv8_compress_n(digest, input, blocks);
   75|       |   }
   76|       |#endif
   77|       |
   78|  13.8k|#if defined(BOTAN_HAS_SHA1_SSE2)
   79|  13.8k|   if(CPUID::has_sse2()) {
  ------------------
  |  Branch (79:7): [True: 13.8k, False: 0]
  ------------------
   80|  13.8k|      return sse2_compress_n(digest, input, blocks);
   81|  13.8k|   }
   82|       |
   83|      0|#endif
   84|       |
   85|      0|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4];
   86|      0|   std::array<uint32_t, 80> W;
   87|       |
   88|      0|   BufferSlicer in(input);
   89|       |
   90|      0|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (90:22): [True: 0, False: 0]
  ------------------
   91|      0|      load_be(W.data(), in.take(block_bytes).data(), 16);
   92|       |
   93|      0|      for(size_t j = 16; j != 80; j += 8) {
  ------------------
  |  Branch (93:26): [True: 0, False: 0]
  ------------------
   94|      0|         W[j] = rotl<1>(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16]);
   95|      0|         W[j + 1] = rotl<1>(W[j - 2] ^ W[j - 7] ^ W[j - 13] ^ W[j - 15]);
   96|      0|         W[j + 2] = rotl<1>(W[j - 1] ^ W[j - 6] ^ W[j - 12] ^ W[j - 14]);
   97|      0|         W[j + 3] = rotl<1>(W[j] ^ W[j - 5] ^ W[j - 11] ^ W[j - 13]);
   98|      0|         W[j + 4] = rotl<1>(W[j + 1] ^ W[j - 4] ^ W[j - 10] ^ W[j - 12]);
   99|      0|         W[j + 5] = rotl<1>(W[j + 2] ^ W[j - 3] ^ W[j - 9] ^ W[j - 11]);
  100|      0|         W[j + 6] = rotl<1>(W[j + 3] ^ W[j - 2] ^ W[j - 8] ^ W[j - 10]);
  101|      0|         W[j + 7] = rotl<1>(W[j + 4] ^ W[j - 1] ^ W[j - 7] ^ W[j - 9]);
  102|      0|      }
  103|       |
  104|      0|      F1(A, B, C, D, E, W[0]);
  105|      0|      F1(E, A, B, C, D, W[1]);
  106|      0|      F1(D, E, A, B, C, W[2]);
  107|      0|      F1(C, D, E, A, B, W[3]);
  108|      0|      F1(B, C, D, E, A, W[4]);
  109|      0|      F1(A, B, C, D, E, W[5]);
  110|      0|      F1(E, A, B, C, D, W[6]);
  111|      0|      F1(D, E, A, B, C, W[7]);
  112|      0|      F1(C, D, E, A, B, W[8]);
  113|      0|      F1(B, C, D, E, A, W[9]);
  114|      0|      F1(A, B, C, D, E, W[10]);
  115|      0|      F1(E, A, B, C, D, W[11]);
  116|      0|      F1(D, E, A, B, C, W[12]);
  117|      0|      F1(C, D, E, A, B, W[13]);
  118|      0|      F1(B, C, D, E, A, W[14]);
  119|      0|      F1(A, B, C, D, E, W[15]);
  120|      0|      F1(E, A, B, C, D, W[16]);
  121|      0|      F1(D, E, A, B, C, W[17]);
  122|      0|      F1(C, D, E, A, B, W[18]);
  123|      0|      F1(B, C, D, E, A, W[19]);
  124|       |
  125|      0|      F2(A, B, C, D, E, W[20]);
  126|      0|      F2(E, A, B, C, D, W[21]);
  127|      0|      F2(D, E, A, B, C, W[22]);
  128|      0|      F2(C, D, E, A, B, W[23]);
  129|      0|      F2(B, C, D, E, A, W[24]);
  130|      0|      F2(A, B, C, D, E, W[25]);
  131|      0|      F2(E, A, B, C, D, W[26]);
  132|      0|      F2(D, E, A, B, C, W[27]);
  133|      0|      F2(C, D, E, A, B, W[28]);
  134|      0|      F2(B, C, D, E, A, W[29]);
  135|      0|      F2(A, B, C, D, E, W[30]);
  136|      0|      F2(E, A, B, C, D, W[31]);
  137|      0|      F2(D, E, A, B, C, W[32]);
  138|      0|      F2(C, D, E, A, B, W[33]);
  139|      0|      F2(B, C, D, E, A, W[34]);
  140|      0|      F2(A, B, C, D, E, W[35]);
  141|      0|      F2(E, A, B, C, D, W[36]);
  142|      0|      F2(D, E, A, B, C, W[37]);
  143|      0|      F2(C, D, E, A, B, W[38]);
  144|      0|      F2(B, C, D, E, A, W[39]);
  145|       |
  146|      0|      F3(A, B, C, D, E, W[40]);
  147|      0|      F3(E, A, B, C, D, W[41]);
  148|      0|      F3(D, E, A, B, C, W[42]);
  149|      0|      F3(C, D, E, A, B, W[43]);
  150|      0|      F3(B, C, D, E, A, W[44]);
  151|      0|      F3(A, B, C, D, E, W[45]);
  152|      0|      F3(E, A, B, C, D, W[46]);
  153|      0|      F3(D, E, A, B, C, W[47]);
  154|      0|      F3(C, D, E, A, B, W[48]);
  155|      0|      F3(B, C, D, E, A, W[49]);
  156|      0|      F3(A, B, C, D, E, W[50]);
  157|      0|      F3(E, A, B, C, D, W[51]);
  158|      0|      F3(D, E, A, B, C, W[52]);
  159|      0|      F3(C, D, E, A, B, W[53]);
  160|      0|      F3(B, C, D, E, A, W[54]);
  161|      0|      F3(A, B, C, D, E, W[55]);
  162|      0|      F3(E, A, B, C, D, W[56]);
  163|      0|      F3(D, E, A, B, C, W[57]);
  164|      0|      F3(C, D, E, A, B, W[58]);
  165|      0|      F3(B, C, D, E, A, W[59]);
  166|       |
  167|      0|      F4(A, B, C, D, E, W[60]);
  168|      0|      F4(E, A, B, C, D, W[61]);
  169|      0|      F4(D, E, A, B, C, W[62]);
  170|      0|      F4(C, D, E, A, B, W[63]);
  171|      0|      F4(B, C, D, E, A, W[64]);
  172|      0|      F4(A, B, C, D, E, W[65]);
  173|      0|      F4(E, A, B, C, D, W[66]);
  174|      0|      F4(D, E, A, B, C, W[67]);
  175|      0|      F4(C, D, E, A, B, W[68]);
  176|      0|      F4(B, C, D, E, A, W[69]);
  177|      0|      F4(A, B, C, D, E, W[70]);
  178|      0|      F4(E, A, B, C, D, W[71]);
  179|      0|      F4(D, E, A, B, C, W[72]);
  180|      0|      F4(C, D, E, A, B, W[73]);
  181|      0|      F4(B, C, D, E, A, W[74]);
  182|      0|      F4(A, B, C, D, E, W[75]);
  183|      0|      F4(E, A, B, C, D, W[76]);
  184|      0|      F4(D, E, A, B, C, W[77]);
  185|      0|      F4(C, D, E, A, B, W[78]);
  186|      0|      F4(B, C, D, E, A, W[79]);
  187|       |
  188|      0|      A = (digest[0] += A);
  189|      0|      B = (digest[1] += B);
  190|      0|      C = (digest[2] += C);
  191|      0|      D = (digest[3] += D);
  192|      0|      E = (digest[4] += E);
  193|      0|   }
  194|      0|}
_ZN5Botan5SHA_14initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  199|  13.5k|void SHA_1::init(digest_type& digest) {
  200|  13.5k|   digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0});
  201|  13.5k|}
_ZN5Botan5SHA_18add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  233|  6.77k|void SHA_1::add_data(std::span<const uint8_t> input) {
  234|  6.77k|   m_md.update(input);
  235|  6.77k|}
_ZN5Botan5SHA_112final_resultENSt3__14spanIhLm18446744073709551615EEE:
  237|  6.77k|void SHA_1::final_result(std::span<uint8_t> output) {
  238|  6.77k|   m_md.final(output);
  239|  6.77k|}

_ZN5Botan5SHA_115sse2_compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
  115|  13.8k|BOTAN_FUNC_ISA("sse2") void SHA_1::sse2_compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  116|  13.8k|   using namespace SHA1_SSE2_F;
  117|       |
  118|  13.8k|   const SIMD_4x32 K00_19 = SIMD_4x32::splat(0x5A827999);
  119|  13.8k|   const SIMD_4x32 K20_39 = SIMD_4x32::splat(0x6ED9EBA1);
  120|  13.8k|   const SIMD_4x32 K40_59 = SIMD_4x32::splat(0x8F1BBCDC);
  121|  13.8k|   const SIMD_4x32 K60_79 = SIMD_4x32::splat(0xCA62C1D6);
  122|       |
  123|  13.8k|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4];
  124|       |
  125|  13.8k|   BufferSlicer in(input);
  126|       |
  127|  79.6k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (127:22): [True: 65.7k, False: 13.8k]
  ------------------
  128|  65.7k|      uint32_t PT[4];
  129|       |
  130|  65.7k|      const auto block = in.take(block_bytes);
  131|       |
  132|  65.7k|      SIMD_4x32 W0 = SIMD_4x32::load_be(&block[0]);
  133|  65.7k|      SIMD_4x32 W1 = SIMD_4x32::load_be(&block[16]);
  134|  65.7k|      SIMD_4x32 W2 = SIMD_4x32::load_be(&block[32]);
  135|  65.7k|      SIMD_4x32 W3 = SIMD_4x32::load_be(&block[48]);
  136|       |
  137|  65.7k|      SIMD_4x32 P0 = W0 + K00_19;
  138|  65.7k|      SIMD_4x32 P1 = W1 + K00_19;
  139|  65.7k|      SIMD_4x32 P2 = W2 + K00_19;
  140|  65.7k|      SIMD_4x32 P3 = W3 + K00_19;
  141|       |
  142|  65.7k|      SIMD_4x32(P0).store_le(PT);
  143|  65.7k|      F1(A, B, C, D, E, PT[0]);
  144|  65.7k|      F1(E, A, B, C, D, PT[1]);
  145|  65.7k|      F1(D, E, A, B, C, PT[2]);
  146|  65.7k|      F1(C, D, E, A, B, PT[3]);
  147|  65.7k|      P0 = prep(W0, W1, W2, W3, K00_19);
  148|       |
  149|  65.7k|      SIMD_4x32(P1).store_le(PT);
  150|  65.7k|      F1(B, C, D, E, A, PT[0]);
  151|  65.7k|      F1(A, B, C, D, E, PT[1]);
  152|  65.7k|      F1(E, A, B, C, D, PT[2]);
  153|  65.7k|      F1(D, E, A, B, C, PT[3]);
  154|  65.7k|      P1 = prep(W1, W2, W3, W0, K20_39);
  155|       |
  156|  65.7k|      SIMD_4x32(P2).store_le(PT);
  157|  65.7k|      F1(C, D, E, A, B, PT[0]);
  158|  65.7k|      F1(B, C, D, E, A, PT[1]);
  159|  65.7k|      F1(A, B, C, D, E, PT[2]);
  160|  65.7k|      F1(E, A, B, C, D, PT[3]);
  161|  65.7k|      P2 = prep(W2, W3, W0, W1, K20_39);
  162|       |
  163|  65.7k|      SIMD_4x32(P3).store_le(PT);
  164|  65.7k|      F1(D, E, A, B, C, PT[0]);
  165|  65.7k|      F1(C, D, E, A, B, PT[1]);
  166|  65.7k|      F1(B, C, D, E, A, PT[2]);
  167|  65.7k|      F1(A, B, C, D, E, PT[3]);
  168|  65.7k|      P3 = prep(W3, W0, W1, W2, K20_39);
  169|       |
  170|  65.7k|      SIMD_4x32(P0).store_le(PT);
  171|  65.7k|      F1(E, A, B, C, D, PT[0]);
  172|  65.7k|      F1(D, E, A, B, C, PT[1]);
  173|  65.7k|      F1(C, D, E, A, B, PT[2]);
  174|  65.7k|      F1(B, C, D, E, A, PT[3]);
  175|  65.7k|      P0 = prep(W0, W1, W2, W3, K20_39);
  176|       |
  177|  65.7k|      SIMD_4x32(P1).store_le(PT);
  178|  65.7k|      F2(A, B, C, D, E, PT[0]);
  179|  65.7k|      F2(E, A, B, C, D, PT[1]);
  180|  65.7k|      F2(D, E, A, B, C, PT[2]);
  181|  65.7k|      F2(C, D, E, A, B, PT[3]);
  182|  65.7k|      P1 = prep(W1, W2, W3, W0, K20_39);
  183|       |
  184|  65.7k|      SIMD_4x32(P2).store_le(PT);
  185|  65.7k|      F2(B, C, D, E, A, PT[0]);
  186|  65.7k|      F2(A, B, C, D, E, PT[1]);
  187|  65.7k|      F2(E, A, B, C, D, PT[2]);
  188|  65.7k|      F2(D, E, A, B, C, PT[3]);
  189|  65.7k|      P2 = prep(W2, W3, W0, W1, K40_59);
  190|       |
  191|  65.7k|      SIMD_4x32(P3).store_le(PT);
  192|  65.7k|      F2(C, D, E, A, B, PT[0]);
  193|  65.7k|      F2(B, C, D, E, A, PT[1]);
  194|  65.7k|      F2(A, B, C, D, E, PT[2]);
  195|  65.7k|      F2(E, A, B, C, D, PT[3]);
  196|  65.7k|      P3 = prep(W3, W0, W1, W2, K40_59);
  197|       |
  198|  65.7k|      SIMD_4x32(P0).store_le(PT);
  199|  65.7k|      F2(D, E, A, B, C, PT[0]);
  200|  65.7k|      F2(C, D, E, A, B, PT[1]);
  201|  65.7k|      F2(B, C, D, E, A, PT[2]);
  202|  65.7k|      F2(A, B, C, D, E, PT[3]);
  203|  65.7k|      P0 = prep(W0, W1, W2, W3, K40_59);
  204|       |
  205|  65.7k|      SIMD_4x32(P1).store_le(PT);
  206|  65.7k|      F2(E, A, B, C, D, PT[0]);
  207|  65.7k|      F2(D, E, A, B, C, PT[1]);
  208|  65.7k|      F2(C, D, E, A, B, PT[2]);
  209|  65.7k|      F2(B, C, D, E, A, PT[3]);
  210|  65.7k|      P1 = prep(W1, W2, W3, W0, K40_59);
  211|       |
  212|  65.7k|      SIMD_4x32(P2).store_le(PT);
  213|  65.7k|      F3(A, B, C, D, E, PT[0]);
  214|  65.7k|      F3(E, A, B, C, D, PT[1]);
  215|  65.7k|      F3(D, E, A, B, C, PT[2]);
  216|  65.7k|      F3(C, D, E, A, B, PT[3]);
  217|  65.7k|      P2 = prep(W2, W3, W0, W1, K40_59);
  218|       |
  219|  65.7k|      SIMD_4x32(P3).store_le(PT);
  220|  65.7k|      F3(B, C, D, E, A, PT[0]);
  221|  65.7k|      F3(A, B, C, D, E, PT[1]);
  222|  65.7k|      F3(E, A, B, C, D, PT[2]);
  223|  65.7k|      F3(D, E, A, B, C, PT[3]);
  224|  65.7k|      P3 = prep(W3, W0, W1, W2, K60_79);
  225|       |
  226|  65.7k|      SIMD_4x32(P0).store_le(PT);
  227|  65.7k|      F3(C, D, E, A, B, PT[0]);
  228|  65.7k|      F3(B, C, D, E, A, PT[1]);
  229|  65.7k|      F3(A, B, C, D, E, PT[2]);
  230|  65.7k|      F3(E, A, B, C, D, PT[3]);
  231|  65.7k|      P0 = prep(W0, W1, W2, W3, K60_79);
  232|       |
  233|  65.7k|      SIMD_4x32(P1).store_le(PT);
  234|  65.7k|      F3(D, E, A, B, C, PT[0]);
  235|  65.7k|      F3(C, D, E, A, B, PT[1]);
  236|  65.7k|      F3(B, C, D, E, A, PT[2]);
  237|  65.7k|      F3(A, B, C, D, E, PT[3]);
  238|  65.7k|      P1 = prep(W1, W2, W3, W0, K60_79);
  239|       |
  240|  65.7k|      SIMD_4x32(P2).store_le(PT);
  241|  65.7k|      F3(E, A, B, C, D, PT[0]);
  242|  65.7k|      F3(D, E, A, B, C, PT[1]);
  243|  65.7k|      F3(C, D, E, A, B, PT[2]);
  244|  65.7k|      F3(B, C, D, E, A, PT[3]);
  245|  65.7k|      P2 = prep(W2, W3, W0, W1, K60_79);
  246|       |
  247|  65.7k|      SIMD_4x32(P3).store_le(PT);
  248|  65.7k|      F4(A, B, C, D, E, PT[0]);
  249|  65.7k|      F4(E, A, B, C, D, PT[1]);
  250|  65.7k|      F4(D, E, A, B, C, PT[2]);
  251|  65.7k|      F4(C, D, E, A, B, PT[3]);
  252|  65.7k|      P3 = prep(W3, W0, W1, W2, K60_79);
  253|       |
  254|  65.7k|      SIMD_4x32(P0).store_le(PT);
  255|  65.7k|      F4(B, C, D, E, A, PT[0]);
  256|  65.7k|      F4(A, B, C, D, E, PT[1]);
  257|  65.7k|      F4(E, A, B, C, D, PT[2]);
  258|  65.7k|      F4(D, E, A, B, C, PT[3]);
  259|       |
  260|  65.7k|      SIMD_4x32(P1).store_le(PT);
  261|  65.7k|      F4(C, D, E, A, B, PT[0]);
  262|  65.7k|      F4(B, C, D, E, A, PT[1]);
  263|  65.7k|      F4(A, B, C, D, E, PT[2]);
  264|  65.7k|      F4(E, A, B, C, D, PT[3]);
  265|       |
  266|  65.7k|      SIMD_4x32(P2).store_le(PT);
  267|  65.7k|      F4(D, E, A, B, C, PT[0]);
  268|  65.7k|      F4(C, D, E, A, B, PT[1]);
  269|  65.7k|      F4(B, C, D, E, A, PT[2]);
  270|  65.7k|      F4(A, B, C, D, E, PT[3]);
  271|       |
  272|  65.7k|      SIMD_4x32(P3).store_le(PT);
  273|  65.7k|      F4(E, A, B, C, D, PT[0]);
  274|  65.7k|      F4(D, E, A, B, C, PT[1]);
  275|  65.7k|      F4(C, D, E, A, B, PT[2]);
  276|  65.7k|      F4(B, C, D, E, A, PT[3]);
  277|       |
  278|  65.7k|      A = (digest[0] += A);
  279|  65.7k|      B = (digest[1] += B);
  280|  65.7k|      C = (digest[2] += C);
  281|  65.7k|      D = (digest[3] += D);
  282|  65.7k|      E = (digest[4] += E);
  283|  65.7k|   }
  284|  13.8k|}
sha1_sse2.cpp:_ZN5Botan11SHA1_SSE2_F12_GLOBAL__N_12F1EjRjjjS2_j:
   78|  1.31M|inline void F1(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {
   79|  1.31M|   E += choose(B, C, D) + msg + rotl<5>(A);
   80|  1.31M|   B = rotl<30>(B);
   81|  1.31M|}
sha1_sse2.cpp:_ZN5Botan11SHA1_SSE2_F12_GLOBAL__N_14prepERNS_9SIMD_4x32ES2_S2_S2_S2_:
   51|  1.05M|BOTAN_FORCE_INLINE SIMD_4x32 prep(SIMD_4x32& XW0, SIMD_4x32 XW1, SIMD_4x32 XW2, SIMD_4x32 XW3, SIMD_4x32 K) {
   52|  1.05M|   SIMD_4x32 T0 = XW0;
   53|       |   /* load W[t-4] 16-byte aligned, and shift */
   54|  1.05M|   SIMD_4x32 T2 = XW3.shift_elems_right<1>();
   55|       |   /* get high 64-bits of XW0 into low 64-bits */
   56|  1.05M|   SIMD_4x32 T1 = SIMD_4x32(_mm_shuffle_epi32(XW0.raw(), _MM_SHUFFLE(1, 0, 3, 2)));
   57|       |   /* load high 64-bits of T1 */
   58|  1.05M|   T1 = SIMD_4x32(_mm_unpacklo_epi64(T1.raw(), XW1.raw()));
   59|       |
   60|  1.05M|   T0 ^= T1;
   61|  1.05M|   T2 ^= XW2;
   62|  1.05M|   T0 ^= T2;
   63|       |   /* unrotated W[t]..W[t+2] in T0 ... still need W[t+3] */
   64|       |
   65|  1.05M|   T2 = T0.shift_elems_left<3>();
   66|  1.05M|   T0 = T0.rotl<1>();
   67|  1.05M|   T2 = T2.rotl<2>();
   68|       |
   69|  1.05M|   T0 ^= T2; /* T0 now has W[t+3] */
   70|       |
   71|  1.05M|   XW0 = T0;
   72|  1.05M|   return T0 + K;
   73|  1.05M|}
sha1_sse2.cpp:_ZN5Botan11SHA1_SSE2_F12_GLOBAL__N_12F2EjRjjjS2_j:
   86|  1.31M|inline void F2(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {
   87|  1.31M|   E += (B ^ C ^ D) + msg + rotl<5>(A);
   88|  1.31M|   B = rotl<30>(B);
   89|  1.31M|}
sha1_sse2.cpp:_ZN5Botan11SHA1_SSE2_F12_GLOBAL__N_12F3EjRjjjS2_j:
   94|  1.31M|inline void F3(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {
   95|  1.31M|   E += majority(B, C, D) + msg + rotl<5>(A);
   96|  1.31M|   B = rotl<30>(B);
   97|  1.31M|}
sha1_sse2.cpp:_ZN5Botan11SHA1_SSE2_F12_GLOBAL__N_12F4EjRjjjS2_j:
  102|  1.31M|inline void F4(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {
  103|  1.31M|   E += (B ^ C ^ D) + msg + rotl<5>(A);
  104|  1.31M|   B = rotl<30>(B);
  105|  1.31M|}

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

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

_ZN5Botan7SHA_51215compress_digestERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
   43|    106|void SHA_512::compress_digest(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   44|    106|#if defined(BOTAN_HAS_SHA2_64_BMI2)
   45|    106|   if(CPUID::has_bmi2()) {
  ------------------
  |  Branch (45:7): [True: 106, False: 0]
  ------------------
   46|    106|      return compress_digest_bmi2(digest, input, blocks);
   47|    106|   }
   48|      0|#endif
   49|       |
   50|       |#if defined(BOTAN_HAS_SHA2_64_ARMV8)
   51|       |   if(CPUID::has_arm_sha2_512()) {
   52|       |      return compress_digest_armv8(digest, input, blocks);
   53|       |   }
   54|       |#endif
   55|       |
   56|      0|   uint64_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4], F = digest[5], G = digest[6],
   57|      0|            H = digest[7];
   58|       |
   59|      0|   BufferSlicer in(input);
   60|       |
   61|      0|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (61:22): [True: 0, False: 0]
  ------------------
   62|      0|      const auto block = in.take(block_bytes);
   63|       |
   64|      0|      uint64_t W00 = load_be<uint64_t>(block.data(), 0);
   65|      0|      uint64_t W01 = load_be<uint64_t>(block.data(), 1);
   66|      0|      uint64_t W02 = load_be<uint64_t>(block.data(), 2);
   67|      0|      uint64_t W03 = load_be<uint64_t>(block.data(), 3);
   68|      0|      uint64_t W04 = load_be<uint64_t>(block.data(), 4);
   69|      0|      uint64_t W05 = load_be<uint64_t>(block.data(), 5);
   70|      0|      uint64_t W06 = load_be<uint64_t>(block.data(), 6);
   71|      0|      uint64_t W07 = load_be<uint64_t>(block.data(), 7);
   72|      0|      uint64_t W08 = load_be<uint64_t>(block.data(), 8);
   73|      0|      uint64_t W09 = load_be<uint64_t>(block.data(), 9);
   74|      0|      uint64_t W10 = load_be<uint64_t>(block.data(), 10);
   75|      0|      uint64_t W11 = load_be<uint64_t>(block.data(), 11);
   76|      0|      uint64_t W12 = load_be<uint64_t>(block.data(), 12);
   77|      0|      uint64_t W13 = load_be<uint64_t>(block.data(), 13);
   78|      0|      uint64_t W14 = load_be<uint64_t>(block.data(), 14);
   79|      0|      uint64_t W15 = load_be<uint64_t>(block.data(), 15);
   80|       |
   81|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98D728AE22);
   82|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x7137449123EF65CD);
   83|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCFEC4D3B2F);
   84|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA58189DBBC);
   85|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25BF348B538);
   86|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1B605D019);
   87|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4AF194F9B);
   88|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5DA6D8118);
   89|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98A3030242);
   90|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B0145706FBE);
   91|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE4EE4B28C);
   92|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3D5FFB4E2);
   93|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74F27B896F);
   94|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE3B1696B1);
   95|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A725C71235);
   96|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174CF692694);
   97|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C19EF14AD2);
   98|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786384F25E3);
   99|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC68B8CD5B5);
  100|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC77AC9C65);
  101|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F592B0275);
  102|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA6EA6E483);
  103|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DCBD41FBD4);
  104|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA831153B5);
  105|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152EE66DFAB);
  106|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D2DB43210);
  107|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C898FB213F);
  108|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7BEEF0EE4);
  109|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF33DA88FC2);
  110|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147930AA725);
  111|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351E003826F);
  112|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x142929670A0E6E70);
  113|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A8546D22FFC);
  114|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B21385C26C926);
  115|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC5AC42AED);
  116|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D139D95B3DF);
  117|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A73548BAF63DE);
  118|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB3C77B2A8);
  119|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E47EDAEE6);
  120|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C851482353B);
  121|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A14CF10364);
  122|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664BBC423001);
  123|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70D0F89791);
  124|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A30654BE30);
  125|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819D6EF5218);
  126|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD69906245565A910);
  127|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E35855771202A);
  128|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA07032BBD1B8);
  129|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116B8D2D0C8);
  130|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C085141AB53);
  131|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774CDF8EEB99);
  132|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5E19B48A8);
  133|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3C5C95A63);
  134|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4AE3418ACB);
  135|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F7763E373);
  136|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3D6B2B8A3);
  137|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE5DEFB2FC);
  138|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F43172F60);
  139|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814A1F0AB72);
  140|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC702081A6439EC);
  141|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA23631E28);
  142|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEBDE82BDE9);
  143|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7B2C67915);
  144|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2E372532B);
  145|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xCA273ECEEA26619C);
  146|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xD186B8C721C0C207);
  147|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xEADA7DD6CDE0EB1E);
  148|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xF57D4F7FEE6ED178);
  149|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x06F067AA72176FBA);
  150|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x0A637DC5A2C898A6);
  151|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x113F9804BEF90DAE);
  152|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x1B710B35131C471B);
  153|      0|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x28DB77F523047D84);
  154|      0|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x32CAAB7B40C72493);
  155|      0|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x3C9EBE0A15C9BEBC);
  156|      0|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x431D67C49C100D4C);
  157|      0|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x4CC5D4BECB3E42B6);
  158|      0|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x597F299CFC657E2A);
  159|      0|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x5FCB6FAB3AD6FAEC);
  160|      0|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x6C44198C4A475817);
  161|       |
  162|      0|      A = (digest[0] += A);
  163|      0|      B = (digest[1] += B);
  164|      0|      C = (digest[2] += C);
  165|      0|      D = (digest[3] += D);
  166|      0|      E = (digest[4] += E);
  167|      0|      F = (digest[5] += F);
  168|      0|      G = (digest[6] += G);
  169|      0|      H = (digest[7] += H);
  170|      0|   }
  171|      0|}
_ZN5Botan11SHA_512_25610compress_nERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
  185|      4|void SHA_512_256::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  186|      4|   SHA_512::compress_digest(digest, input, blocks);
  187|      4|}
_ZN5Botan7SHA_38410compress_nERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
  189|     84|void SHA_384::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  190|     84|   SHA_512::compress_digest(digest, input, blocks);
  191|     84|}
_ZN5Botan7SHA_51210compress_nERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
  193|     18|void SHA_512::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  194|     18|   SHA_512::compress_digest(digest, input, blocks);
  195|     18|}
_ZN5Botan11SHA_512_2564initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  197|      4|void SHA_512_256::init(digest_type& digest) {
  198|      4|   digest.assign({0x22312194FC2BF72C,
  199|      4|                  0x9F555FA3C84C64C2,
  200|      4|                  0x2393B86B6F53B151,
  201|      4|                  0x963877195940EABD,
  202|      4|                  0x96283EE2A88EFFE3,
  203|      4|                  0xBE5E1E2553863992,
  204|      4|                  0x2B0199FC2C85B8AA,
  205|      4|                  0x0EB72DDC81C52CA2});
  206|      4|}
_ZN5Botan7SHA_3844initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  208|     84|void SHA_384::init(digest_type& digest) {
  209|     84|   digest.assign({0xCBBB9D5DC1059ED8,
  210|     84|                  0x629A292A367CD507,
  211|     84|                  0x9159015A3070DD17,
  212|     84|                  0x152FECD8F70E5939,
  213|     84|                  0x67332667FFC00B31,
  214|     84|                  0x8EB44A8768581511,
  215|     84|                  0xDB0C2E0D64F98FA7,
  216|     84|                  0x47B5481DBEFA4FA4});
  217|     84|}
_ZN5Botan7SHA_5124initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  219|     18|void SHA_512::init(digest_type& digest) {
  220|     18|   digest.assign({0x6A09E667F3BCC908,
  221|     18|                  0xBB67AE8584CAA73B,
  222|     18|                  0x3C6EF372FE94F82B,
  223|     18|                  0xA54FF53A5F1D36F1,
  224|     18|                  0x510E527FADE682D1,
  225|     18|                  0x9B05688C2B3E6C1F,
  226|     18|                  0x1F83D9ABFB41BD6B,
  227|     18|                  0x5BE0CD19137E2179});
  228|     18|}
_ZN5Botan7SHA_3848add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  254|     42|void SHA_384::add_data(std::span<const uint8_t> input) {
  255|     42|   m_md.update(input);
  256|     42|}
_ZN5Botan7SHA_5128add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  258|      9|void SHA_512::add_data(std::span<const uint8_t> input) {
  259|      9|   m_md.update(input);
  260|      9|}
_ZN5Botan11SHA_512_2568add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  262|      2|void SHA_512_256::add_data(std::span<const uint8_t> input) {
  263|      2|   m_md.update(input);
  264|      2|}
_ZN5Botan7SHA_38412final_resultENSt3__14spanIhLm18446744073709551615EEE:
  266|     42|void SHA_384::final_result(std::span<uint8_t> output) {
  267|     42|   m_md.final(output);
  268|     42|}
_ZN5Botan7SHA_51212final_resultENSt3__14spanIhLm18446744073709551615EEE:
  270|      9|void SHA_512::final_result(std::span<uint8_t> output) {
  271|      9|   m_md.final(output);
  272|      9|}
_ZN5Botan11SHA_512_25612final_resultENSt3__14spanIhLm18446744073709551615EEE:
  274|      2|void SHA_512_256::final_result(std::span<uint8_t> output) {
  275|      2|   m_md.final(output);
  276|      2|}

_ZN5Botan7SHA_51220compress_digest_bmi2ERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
   17|    106|void SHA_512::compress_digest_bmi2(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   18|    106|   uint64_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4], F = digest[5], G = digest[6],
   19|    106|            H = digest[7];
   20|       |
   21|    106|   BufferSlicer in(input);
   22|       |
   23|    467|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (23:22): [True: 361, False: 106]
  ------------------
   24|    361|      const auto block = in.take(block_bytes);
   25|       |
   26|    361|      uint64_t W00 = load_be<uint64_t>(block.data(), 0);
   27|    361|      uint64_t W01 = load_be<uint64_t>(block.data(), 1);
   28|    361|      uint64_t W02 = load_be<uint64_t>(block.data(), 2);
   29|    361|      uint64_t W03 = load_be<uint64_t>(block.data(), 3);
   30|    361|      uint64_t W04 = load_be<uint64_t>(block.data(), 4);
   31|    361|      uint64_t W05 = load_be<uint64_t>(block.data(), 5);
   32|    361|      uint64_t W06 = load_be<uint64_t>(block.data(), 6);
   33|    361|      uint64_t W07 = load_be<uint64_t>(block.data(), 7);
   34|    361|      uint64_t W08 = load_be<uint64_t>(block.data(), 8);
   35|    361|      uint64_t W09 = load_be<uint64_t>(block.data(), 9);
   36|    361|      uint64_t W10 = load_be<uint64_t>(block.data(), 10);
   37|    361|      uint64_t W11 = load_be<uint64_t>(block.data(), 11);
   38|    361|      uint64_t W12 = load_be<uint64_t>(block.data(), 12);
   39|    361|      uint64_t W13 = load_be<uint64_t>(block.data(), 13);
   40|    361|      uint64_t W14 = load_be<uint64_t>(block.data(), 14);
   41|    361|      uint64_t W15 = load_be<uint64_t>(block.data(), 15);
   42|       |
   43|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98D728AE22);
   44|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x7137449123EF65CD);
   45|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCFEC4D3B2F);
   46|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA58189DBBC);
   47|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25BF348B538);
   48|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1B605D019);
   49|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4AF194F9B);
   50|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5DA6D8118);
   51|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98A3030242);
   52|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B0145706FBE);
   53|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE4EE4B28C);
   54|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3D5FFB4E2);
   55|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74F27B896F);
   56|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE3B1696B1);
   57|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A725C71235);
   58|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174CF692694);
   59|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C19EF14AD2);
   60|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786384F25E3);
   61|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC68B8CD5B5);
   62|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC77AC9C65);
   63|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F592B0275);
   64|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA6EA6E483);
   65|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DCBD41FBD4);
   66|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA831153B5);
   67|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152EE66DFAB);
   68|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D2DB43210);
   69|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C898FB213F);
   70|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7BEEF0EE4);
   71|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF33DA88FC2);
   72|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147930AA725);
   73|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351E003826F);
   74|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x142929670A0E6E70);
   75|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A8546D22FFC);
   76|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B21385C26C926);
   77|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC5AC42AED);
   78|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D139D95B3DF);
   79|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A73548BAF63DE);
   80|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB3C77B2A8);
   81|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E47EDAEE6);
   82|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C851482353B);
   83|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A14CF10364);
   84|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664BBC423001);
   85|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70D0F89791);
   86|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A30654BE30);
   87|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819D6EF5218);
   88|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD69906245565A910);
   89|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E35855771202A);
   90|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA07032BBD1B8);
   91|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116B8D2D0C8);
   92|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C085141AB53);
   93|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774CDF8EEB99);
   94|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5E19B48A8);
   95|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3C5C95A63);
   96|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4AE3418ACB);
   97|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F7763E373);
   98|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3D6B2B8A3);
   99|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE5DEFB2FC);
  100|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F43172F60);
  101|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814A1F0AB72);
  102|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC702081A6439EC);
  103|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA23631E28);
  104|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEBDE82BDE9);
  105|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7B2C67915);
  106|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2E372532B);
  107|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xCA273ECEEA26619C);
  108|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xD186B8C721C0C207);
  109|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xEADA7DD6CDE0EB1E);
  110|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xF57D4F7FEE6ED178);
  111|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x06F067AA72176FBA);
  112|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x0A637DC5A2C898A6);
  113|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x113F9804BEF90DAE);
  114|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x1B710B35131C471B);
  115|    361|      SHA2_64_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x28DB77F523047D84);
  116|    361|      SHA2_64_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x32CAAB7B40C72493);
  117|    361|      SHA2_64_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x3C9EBE0A15C9BEBC);
  118|    361|      SHA2_64_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x431D67C49C100D4C);
  119|    361|      SHA2_64_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x4CC5D4BECB3E42B6);
  120|    361|      SHA2_64_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x597F299CFC657E2A);
  121|    361|      SHA2_64_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x5FCB6FAB3AD6FAEC);
  122|    361|      SHA2_64_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x6C44198C4A475817);
  123|       |
  124|    361|      A = (digest[0] += A);
  125|    361|      B = (digest[1] += B);
  126|    361|      C = (digest[2] += C);
  127|    361|      D = (digest[3] += D);
  128|    361|      E = (digest[4] += E);
  129|    361|      F = (digest[5] += F);
  130|    361|      G = (digest[6] += G);
  131|    361|      H = (digest[7] += H);
  132|    361|   }
  133|    106|}

_ZN5Botan6BigInt3addEPKmmNS0_4SignE:
   16|  4.37k|BigInt& BigInt::add(const word y[], size_t y_words, Sign y_sign) {
   17|  4.37k|   const size_t x_sw = sig_words();
   18|       |
   19|  4.37k|   grow_to(std::max(x_sw, y_words) + 1);
   20|       |
   21|  4.37k|   if(sign() == y_sign) {
  ------------------
  |  Branch (21:7): [True: 4.20k, False: 169]
  ------------------
   22|  4.20k|      bigint_add2(mutable_data(), size() - 1, y, y_words);
   23|  4.20k|   } else {
   24|    169|      const int32_t relative_size = bigint_cmp(data(), x_sw, y, y_words);
   25|       |
   26|    169|      if(relative_size >= 0) {
  ------------------
  |  Branch (26:10): [True: 0, False: 169]
  ------------------
   27|       |         // *this >= y
   28|      0|         bigint_sub2(mutable_data(), x_sw, y, y_words);
   29|    169|      } else {
   30|       |         // *this < y
   31|    169|         bigint_sub2_rev(mutable_data(), y, y_words);
   32|    169|      }
   33|       |
   34|       |      //this->sign_fixup(relative_size, y_sign);
   35|    169|      if(relative_size < 0) {
  ------------------
  |  Branch (35:10): [True: 169, False: 0]
  ------------------
   36|    169|         set_sign(y_sign);
   37|    169|      } else if(relative_size == 0) {
  ------------------
  |  Branch (37:17): [True: 0, False: 0]
  ------------------
   38|      0|         set_sign(Positive);
   39|      0|      }
   40|    169|   }
   41|       |
   42|  4.37k|   return (*this);
   43|  4.37k|}
_ZN5Botan6BigInt7rev_subEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
  130|  4.37k|BigInt& BigInt::rev_sub(const word y[], size_t y_sw, secure_vector<word>& ws) {
  131|  4.37k|   if(this->sign() != BigInt::Positive) {
  ------------------
  |  Branch (131:7): [True: 0, False: 4.37k]
  ------------------
  132|      0|      throw Invalid_State("BigInt::sub_rev requires this is positive");
  133|      0|   }
  134|       |
  135|  4.37k|   const size_t x_sw = this->sig_words();
  136|       |
  137|  4.37k|   ws.resize(std::max(x_sw, y_sw));
  138|  4.37k|   clear_mem(ws.data(), ws.size());
  139|       |
  140|  4.37k|   const int32_t relative_size = bigint_sub_abs(ws.data(), data(), x_sw, y, y_sw);
  141|       |
  142|  4.37k|   this->cond_flip_sign(relative_size > 0);
  143|  4.37k|   this->swap_reg(ws);
  144|       |
  145|  4.37k|   return (*this);
  146|  4.37k|}
_ZN5Botan6BigInt3mulERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  156|  8.74k|BigInt& BigInt::mul(const BigInt& y, secure_vector<word>& ws) {
  157|  8.74k|   const size_t x_sw = sig_words();
  158|  8.74k|   const size_t y_sw = y.sig_words();
  159|  8.74k|   set_sign((sign() == y.sign()) ? Positive : Negative);
  ------------------
  |  Branch (159:13): [True: 8.74k, False: 0]
  ------------------
  160|       |
  161|  8.74k|   if(x_sw == 0 || y_sw == 0) {
  ------------------
  |  Branch (161:7): [True: 415, False: 8.33k]
  |  Branch (161:20): [True: 0, False: 8.33k]
  ------------------
  162|    415|      clear();
  163|    415|      set_sign(Positive);
  164|  8.33k|   } else if(x_sw == 1 && y_sw) {
  ------------------
  |  Branch (164:14): [True: 1.98k, False: 6.35k]
  |  Branch (164:27): [True: 1.98k, False: 0]
  ------------------
  165|  1.98k|      grow_to(y_sw + 1);
  166|  1.98k|      bigint_linmul3(mutable_data(), y.data(), y_sw, word_at(0));
  167|  6.35k|   } else if(y_sw == 1 && x_sw) {
  ------------------
  |  Branch (167:14): [True: 0, False: 6.35k]
  |  Branch (167:27): [True: 0, False: 0]
  ------------------
  168|      0|      word carry = bigint_linmul2(mutable_data(), x_sw, y.word_at(0));
  169|      0|      set_word_at(x_sw, carry);
  170|  6.35k|   } else {
  171|  6.35k|      const size_t new_size = x_sw + y_sw + 1;
  172|  6.35k|      ws.resize(new_size);
  173|  6.35k|      secure_vector<word> z_reg(new_size);
  174|       |
  175|  6.35k|      bigint_mul(z_reg.data(), z_reg.size(), data(), size(), x_sw, y.data(), y.size(), y_sw, ws.data(), ws.size());
  176|       |
  177|  6.35k|      this->swap_reg(z_reg);
  178|  6.35k|   }
  179|       |
  180|  8.74k|   return (*this);
  181|  8.74k|}
_ZN5Botan6BigInt6squareERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  183|  1.45k|BigInt& BigInt::square(secure_vector<word>& ws) {
  184|  1.45k|   const size_t sw = sig_words();
  185|       |
  186|  1.45k|   secure_vector<word> z(2 * sw);
  187|  1.45k|   ws.resize(z.size());
  188|       |
  189|  1.45k|   bigint_sqr(z.data(), z.size(), data(), size(), sw, ws.data(), ws.size());
  190|       |
  191|  1.45k|   swap_reg(z);
  192|  1.45k|   set_sign(BigInt::Positive);
  193|       |
  194|  1.45k|   return (*this);
  195|  1.45k|}
_ZN5Botan6BigIntmLEm:
  197|  3.93M|BigInt& BigInt::operator*=(word y) {
  198|  3.93M|   if(y == 0) {
  ------------------
  |  Branch (198:7): [True: 0, False: 3.93M]
  ------------------
  199|      0|      clear();
  200|      0|      set_sign(Positive);
  201|      0|   }
  202|       |
  203|  3.93M|   const word carry = bigint_linmul2(mutable_data(), size(), y);
  204|  3.93M|   set_word_at(size(), carry);
  205|       |
  206|  3.93M|   return (*this);
  207|  3.93M|}
_ZN5Botan6BigIntrSEm:
  279|  8.74k|BigInt& BigInt::operator>>=(size_t shift) {
  280|  8.74k|   const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  8.74k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  281|  8.74k|   const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  8.74k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  282|       |
  283|  8.74k|   bigint_shr1(m_data.mutable_data(), m_data.size(), shift_words, shift_bits);
  284|       |
  285|  8.74k|   if(is_negative() && is_zero()) {
  ------------------
  |  Branch (285:7): [True: 0, False: 8.74k]
  |  Branch (285:24): [True: 0, False: 0]
  ------------------
  286|      0|      set_sign(Positive);
  287|      0|   }
  288|       |
  289|  8.74k|   return (*this);
  290|  8.74k|}

_ZN5BotanmlERKNS_6BigIntES2_:
   46|  1.45k|BigInt operator*(const BigInt& x, const BigInt& y) {
   47|  1.45k|   const size_t x_sw = x.sig_words();
   48|  1.45k|   const size_t y_sw = y.sig_words();
   49|       |
   50|  1.45k|   BigInt z = BigInt::with_capacity(x.size() + y.size());
   51|       |
   52|  1.45k|   if(x_sw == 1 && y_sw) {
  ------------------
  |  Branch (52:7): [True: 149, False: 1.30k]
  |  Branch (52:20): [True: 149, False: 0]
  ------------------
   53|    149|      bigint_linmul3(z.mutable_data(), y.data(), y_sw, x.word_at(0));
   54|  1.30k|   } else if(y_sw == 1 && x_sw) {
  ------------------
  |  Branch (54:14): [True: 37, False: 1.27k]
  |  Branch (54:27): [True: 37, False: 0]
  ------------------
   55|     37|      bigint_linmul3(z.mutable_data(), x.data(), x_sw, y.word_at(0));
   56|  1.27k|   } else if(x_sw && y_sw) {
  ------------------
  |  Branch (56:14): [True: 1.27k, False: 0]
  |  Branch (56:22): [True: 1.27k, False: 0]
  ------------------
   57|  1.27k|      secure_vector<word> workspace(z.size());
   58|       |
   59|  1.27k|      bigint_mul(z.mutable_data(),
   60|  1.27k|                 z.size(),
   61|  1.27k|                 x.data(),
   62|  1.27k|                 x.size(),
   63|  1.27k|                 x_sw,
   64|  1.27k|                 y.data(),
   65|  1.27k|                 y.size(),
   66|  1.27k|                 y_sw,
   67|  1.27k|                 workspace.data(),
   68|  1.27k|                 workspace.size());
   69|  1.27k|   }
   70|       |
   71|  1.45k|   z.cond_flip_sign(x_sw > 0 && y_sw > 0 && x.sign() != y.sign());
  ------------------
  |  Branch (71:21): [True: 1.45k, False: 0]
  |  Branch (71:33): [True: 1.45k, False: 0]
  |  Branch (71:45): [True: 0, False: 1.45k]
  ------------------
   72|       |
   73|  1.45k|   return z;
   74|  1.45k|}

_ZN5Botan6BigInt13with_capacityEm:
   58|  7.19k|BigInt BigInt::with_capacity(size_t size) {
   59|  7.19k|   BigInt bn;
   60|  7.19k|   bn.grow_to(size);
   61|  7.19k|   return bn;
   62|  7.19k|}
_ZN5Botan6BigIntC2EPKhm:
   91|  11.5k|BigInt::BigInt(const uint8_t input[], size_t length) {
   92|  11.5k|   binary_decode(input, length);
   93|  11.5k|}
_ZNK5Botan6BigInt7byte_atEm:
  125|  29.4k|uint8_t BigInt::byte_at(size_t n) const {
  126|  29.4k|   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));
  127|  29.4k|}
_ZNK5Botan6BigInt8cmp_wordEm:
  129|  4.37k|int32_t BigInt::cmp_word(word other) const {
  130|  4.37k|   if(is_negative()) {
  ------------------
  |  Branch (130:7): [True: 0, False: 4.37k]
  ------------------
  131|      0|      return -1;  // other is positive ...
  132|      0|   }
  133|       |
  134|  4.37k|   const size_t sw = this->sig_words();
  135|  4.37k|   if(sw > 1) {
  ------------------
  |  Branch (135:7): [True: 4.01k, False: 363]
  ------------------
  136|  4.01k|      return 1;  // must be larger since other is just one word ...
  137|  4.01k|   }
  138|       |
  139|    363|   return bigint_cmp(this->data(), sw, &other, 1);
  140|  4.37k|}
_ZNK5Botan6BigInt3cmpERKS0_b:
  145|  1.38k|int32_t BigInt::cmp(const BigInt& other, bool check_signs) const {
  146|  1.38k|   if(check_signs) {
  ------------------
  |  Branch (146:7): [True: 1.38k, False: 0]
  ------------------
  147|  1.38k|      if(other.is_positive() && this->is_negative()) {
  ------------------
  |  Branch (147:10): [True: 1.38k, False: 0]
  |  Branch (147:33): [True: 0, False: 1.38k]
  ------------------
  148|      0|         return -1;
  149|      0|      }
  150|       |
  151|  1.38k|      if(other.is_negative() && this->is_positive()) {
  ------------------
  |  Branch (151:10): [True: 0, False: 1.38k]
  |  Branch (151:33): [True: 0, False: 0]
  ------------------
  152|      0|         return 1;
  153|      0|      }
  154|       |
  155|  1.38k|      if(other.is_negative() && this->is_negative()) {
  ------------------
  |  Branch (155:10): [True: 0, False: 1.38k]
  |  Branch (155:33): [True: 0, False: 0]
  ------------------
  156|      0|         return (-bigint_cmp(this->data(), this->size(), other.data(), other.size()));
  157|      0|      }
  158|  1.38k|   }
  159|       |
  160|  1.38k|   return bigint_cmp(this->data(), this->size(), other.data(), other.size());
  161|  1.38k|}
_ZNK5Botan6BigInt12is_less_thanERKS0_:
  171|  2.73k|bool BigInt::is_less_than(const BigInt& other) const {
  172|  2.73k|   if(this->is_negative() && other.is_positive()) {
  ------------------
  |  Branch (172:7): [True: 0, False: 2.73k]
  |  Branch (172:30): [True: 0, False: 0]
  ------------------
  173|      0|      return true;
  174|      0|   }
  175|       |
  176|  2.73k|   if(this->is_positive() && other.is_negative()) {
  ------------------
  |  Branch (176:7): [True: 2.73k, False: 0]
  |  Branch (176:30): [True: 0, False: 2.73k]
  ------------------
  177|      0|      return false;
  178|      0|   }
  179|       |
  180|  2.73k|   if(other.is_negative() && this->is_negative()) {
  ------------------
  |  Branch (180:7): [True: 0, False: 2.73k]
  |  Branch (180:30): [True: 0, False: 0]
  ------------------
  181|      0|      return bigint_ct_is_lt(other.data(), other.sig_words(), this->data(), this->sig_words()).as_bool();
  182|      0|   }
  183|       |
  184|  2.73k|   return bigint_ct_is_lt(this->data(), this->sig_words(), other.data(), other.sig_words()).as_bool();
  185|  2.73k|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  198|  48.8k|size_t BigInt::Data::calc_sig_words() const {
  199|  48.8k|   const size_t sz = m_reg.size();
  200|  48.8k|   size_t sig = sz;
  201|       |
  202|  48.8k|   word sub = 1;
  203|       |
  204|  1.52M|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (204:22): [True: 1.47M, False: 48.8k]
  ------------------
  205|  1.47M|      const word w = m_reg[sz - i - 1];
  206|  1.47M|      sub &= ct_is_zero(w);
  207|  1.47M|      sig -= sub;
  208|  1.47M|   }
  209|       |
  210|       |   /*
  211|       |   * This depends on the data so is poisoned, but unpoison it here as
  212|       |   * later conditionals are made on the size.
  213|       |   */
  214|  48.8k|   CT::unpoison(sig);
  215|       |
  216|  48.8k|   return sig;
  217|  48.8k|}
_ZNK5Botan6BigInt13get_substringEmm:
  222|   331k|uint32_t BigInt::get_substring(size_t offset, size_t length) const {
  223|   331k|   if(length == 0 || length > 32) {
  ------------------
  |  Branch (223:7): [True: 0, False: 331k]
  |  Branch (223:22): [True: 0, False: 331k]
  ------------------
  224|      0|      throw Invalid_Argument("BigInt::get_substring invalid substring length");
  225|      0|   }
  226|       |
  227|   331k|   const uint32_t mask = 0xFFFFFFFF >> (32 - length);
  228|       |
  229|   331k|   const size_t word_offset = offset / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|   331k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  230|   331k|   const size_t wshift = (offset % BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|   331k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  231|       |
  232|       |   /*
  233|       |   * The substring is contained within one or at most two words. The
  234|       |   * offset and length are not secret, so we can perform conditional
  235|       |   * operations on those values.
  236|       |   */
  237|   331k|   const word w0 = word_at(word_offset);
  238|       |
  239|   331k|   if(wshift == 0 || (offset + length) / BOTAN_MP_WORD_BITS == word_offset) {
  ------------------
  |  |   50|   325k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  |  Branch (239:7): [True: 6.10k, False: 325k]
  |  Branch (239:22): [True: 320k, False: 4.73k]
  ------------------
  240|   326k|      return static_cast<uint32_t>(w0 >> wshift) & mask;
  241|   326k|   } else {
  242|  4.73k|      const word w1 = word_at(word_offset + 1);
  243|  4.73k|      return static_cast<uint32_t>((w0 >> wshift) | (w1 << (BOTAN_MP_WORD_BITS - wshift))) & mask;
  ------------------
  |  |   50|  4.73k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  244|  4.73k|   }
  245|   331k|}
_ZNK5Botan6BigInt5bytesEv:
  277|  11.3k|size_t BigInt::bytes() const {
  278|  11.3k|   return round_up(bits(), 8) / 8;
  279|  11.3k|}
_ZNK5Botan6BigInt13top_bits_freeEv:
  281|  18.0k|size_t BigInt::top_bits_free() const {
  282|  18.0k|   const size_t words = sig_words();
  283|       |
  284|  18.0k|   const word top_word = word_at(words - 1);
  285|  18.0k|   const size_t bits_used = high_bit(top_word);
  286|  18.0k|   CT::unpoison(bits_used);
  287|  18.0k|   return BOTAN_MP_WORD_BITS - bits_used;
  ------------------
  |  |   50|  18.0k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  288|  18.0k|}
_ZNK5Botan6BigInt4bitsEv:
  290|  24.6k|size_t BigInt::bits() const {
  291|  24.6k|   const size_t words = sig_words();
  292|       |
  293|  24.6k|   if(words == 0) {
  ------------------
  |  Branch (293:7): [True: 6.58k, False: 18.0k]
  ------------------
  294|  6.58k|      return 0;
  295|  6.58k|   }
  296|       |
  297|  18.0k|   const size_t full_words = (words - 1) * BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  18.0k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  298|  18.0k|   const size_t top_bits = BOTAN_MP_WORD_BITS - top_bits_free();
  ------------------
  |  |   50|  18.0k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  299|       |
  300|  18.0k|   return full_words + top_bits;
  301|  24.6k|}
_ZN5Botan6BigInt15ct_reduce_belowERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEEm:
  344|  4.37k|void BigInt::ct_reduce_below(const BigInt& mod, secure_vector<word>& ws, size_t bound) {
  345|  4.37k|   if(mod.is_negative() || this->is_negative()) {
  ------------------
  |  Branch (345:7): [True: 0, False: 4.37k]
  |  Branch (345:28): [True: 0, False: 4.37k]
  ------------------
  346|      0|      throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
  347|      0|   }
  348|       |
  349|  4.37k|   const size_t mod_words = mod.sig_words();
  350|       |
  351|  4.37k|   grow_to(mod_words);
  352|       |
  353|  4.37k|   const size_t sz = size();
  354|       |
  355|  4.37k|   ws.resize(sz);
  356|       |
  357|  4.37k|   clear_mem(ws.data(), sz);
  358|       |
  359|  13.1k|   for(size_t i = 0; i != bound; ++i) {
  ------------------
  |  Branch (359:22): [True: 8.74k, False: 4.37k]
  ------------------
  360|  8.74k|      word borrow = bigint_sub3(ws.data(), data(), sz, mod.data(), mod_words);
  361|       |
  362|  8.74k|      CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), data(), sz);
  363|  8.74k|   }
  364|  4.37k|}
_ZNK5Botan6BigInt13binary_encodeEPh:
  375|  4.94k|void BigInt::binary_encode(uint8_t buf[]) const {
  376|  4.94k|   this->binary_encode(buf, bytes());
  377|  4.94k|}
_ZNK5Botan6BigInt13binary_encodeEPhm:
  382|  4.94k|void BigInt::binary_encode(uint8_t output[], size_t len) const {
  383|  4.94k|   const size_t full_words = len / sizeof(word);
  384|  4.94k|   const size_t extra_bytes = len % sizeof(word);
  385|       |
  386|  32.3k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (386:22): [True: 27.3k, False: 4.94k]
  ------------------
  387|  27.3k|      const word w = word_at(i);
  388|  27.3k|      store_be(w, output + (len - (i + 1) * sizeof(word)));
  389|  27.3k|   }
  390|       |
  391|  4.94k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (391:7): [True: 2.91k, False: 2.03k]
  ------------------
  392|  2.91k|      const word w = word_at(full_words);
  393|       |
  394|  10.6k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (394:25): [True: 7.71k, False: 2.91k]
  ------------------
  395|  7.71k|         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);
  396|  7.71k|      }
  397|  2.91k|   }
  398|  4.94k|}
_ZN5Botan6BigInt13binary_decodeEPKhm:
  403|  11.5k|void BigInt::binary_decode(const uint8_t buf[], size_t length) {
  404|  11.5k|   clear();
  405|       |
  406|  11.5k|   const size_t full_words = length / sizeof(word);
  407|  11.5k|   const size_t extra_bytes = length % sizeof(word);
  408|       |
  409|  11.5k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (409:52): [True: 9.56k, False: 1.98k]
  ------------------
  410|       |
  411|  78.7k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (411:22): [True: 67.2k, False: 11.5k]
  ------------------
  412|  67.2k|      reg[i] = load_be<word>(buf + length - sizeof(word) * (i + 1), 0);
  413|  67.2k|   }
  414|       |
  415|  11.5k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (415:7): [True: 9.56k, False: 1.98k]
  ------------------
  416|  30.3k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (416:25): [True: 20.7k, False: 9.56k]
  ------------------
  417|  20.7k|         reg[full_words] = (reg[full_words] << 8) | buf[i];
  418|  20.7k|      }
  419|  9.56k|   }
  420|       |
  421|  11.5k|   m_data.swap(reg);
  422|  11.5k|}
_ZN5Botan6BigInt12ct_cond_swapEbRS0_:
  467|  3.93M|void BigInt::ct_cond_swap(bool predicate, BigInt& other) {
  468|  3.93M|   const size_t max_words = std::max(size(), other.size());
  469|  3.93M|   grow_to(max_words);
  470|  3.93M|   other.grow_to(max_words);
  471|       |
  472|  3.93M|   bigint_cnd_swap(predicate, this->mutable_data(), other.mutable_data(), max_words);
  473|  3.93M|}
_ZN5Botan6BigInt14cond_flip_signEb:
  475|  11.6k|void BigInt::cond_flip_sign(bool predicate) {
  476|       |   // This code is assuming Negative == 0, Positive == 1
  477|       |
  478|  11.6k|   const auto mask = CT::Mask<uint8_t>::expand(predicate);
  479|       |
  480|  11.6k|   const uint8_t current_sign = static_cast<uint8_t>(sign());
  481|       |
  482|  11.6k|   const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
  483|       |
  484|  11.6k|   set_sign(static_cast<Sign>(new_sign));
  485|  11.6k|}

_ZN5Botan9ct_divideERKNS_6BigIntES2_RS0_S3_:
   48|  1.45k|void ct_divide(const BigInt& x, const BigInt& y, BigInt& q_out, BigInt& r_out) {
   49|  1.45k|   if(y.is_zero()) {
  ------------------
  |  Branch (49:7): [True: 0, False: 1.45k]
  ------------------
   50|      0|      throw Invalid_Argument("ct_divide: cannot divide by zero");
   51|      0|   }
   52|       |
   53|  1.45k|   const size_t x_words = x.sig_words();
   54|  1.45k|   const size_t y_words = y.sig_words();
   55|       |
   56|  1.45k|   const size_t x_bits = x.bits();
   57|       |
   58|  1.45k|   BigInt q = BigInt::with_capacity(x_words);
   59|  1.45k|   BigInt r = BigInt::with_capacity(y_words);
   60|  1.45k|   BigInt t = BigInt::with_capacity(y_words);  // a temporary
   61|       |
   62|  3.93M|   for(size_t i = 0; i != x_bits; ++i) {
  ------------------
  |  Branch (62:22): [True: 3.93M, False: 1.45k]
  ------------------
   63|  3.93M|      const size_t b = x_bits - 1 - i;
   64|  3.93M|      const bool x_b = x.get_bit(b);
   65|       |
   66|  3.93M|      r *= 2;
   67|  3.93M|      r.conditionally_set_bit(0, x_b);
   68|       |
   69|  3.93M|      const bool r_gte_y = bigint_sub3(t.mutable_data(), r.data(), r.size(), y.data(), y_words) == 0;
   70|       |
   71|  3.93M|      q.conditionally_set_bit(b, r_gte_y);
   72|  3.93M|      r.ct_cond_swap(r_gte_y, t);
   73|  3.93M|   }
   74|       |
   75|  1.45k|   sign_fixup(x, y, q, r);
   76|  1.45k|   r_out = r;
   77|  1.45k|   q_out = q;
   78|  1.45k|}
divide.cpp:_ZN5Botan12_GLOBAL__N_110sign_fixupERKNS_6BigIntES3_RS1_S4_:
   21|  1.45k|void sign_fixup(const BigInt& x, const BigInt& y, BigInt& q, BigInt& r) {
   22|  1.45k|   q.cond_flip_sign(x.sign() != y.sign());
   23|       |
   24|  1.45k|   if(x.is_negative() && r.is_nonzero()) {
  ------------------
  |  Branch (24:7): [True: 0, False: 1.45k]
  |  Branch (24:26): [True: 0, False: 0]
  ------------------
   25|      0|      q -= 1;
   26|      0|      r = y.abs() - r;
   27|      0|   }
   28|  1.45k|}

_ZN5Botan17bigint_comba_sqr4EPmPKm:
   16|  23.7k|void bigint_comba_sqr4(word z[8], const word x[4]) {
   17|  23.7k|   word w2 = 0, w1 = 0, w0 = 0;
   18|       |
   19|  23.7k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
   20|  23.7k|   z[0] = w0;
   21|  23.7k|   w0 = 0;
   22|       |
   23|  23.7k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
   24|  23.7k|   z[1] = w1;
   25|  23.7k|   w1 = 0;
   26|       |
   27|  23.7k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
   28|  23.7k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
   29|  23.7k|   z[2] = w2;
   30|  23.7k|   w2 = 0;
   31|       |
   32|  23.7k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
   33|  23.7k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
   34|  23.7k|   z[3] = w0;
   35|  23.7k|   w0 = 0;
   36|       |
   37|  23.7k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
   38|  23.7k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
   39|  23.7k|   z[4] = w1;
   40|  23.7k|   w1 = 0;
   41|       |
   42|  23.7k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
   43|  23.7k|   z[5] = w2;
   44|  23.7k|   w2 = 0;
   45|       |
   46|  23.7k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
   47|  23.7k|   z[6] = w0;
   48|  23.7k|   z[7] = w1;
   49|  23.7k|}
_ZN5Botan17bigint_comba_mul4EPmPKmS2_:
   54|  8.96k|void bigint_comba_mul4(word z[8], const word x[4], const word y[4]) {
   55|  8.96k|   word w2 = 0, w1 = 0, w0 = 0;
   56|       |
   57|  8.96k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
   58|  8.96k|   z[0] = w0;
   59|  8.96k|   w0 = 0;
   60|       |
   61|  8.96k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
   62|  8.96k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
   63|  8.96k|   z[1] = w1;
   64|  8.96k|   w1 = 0;
   65|       |
   66|  8.96k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
   67|  8.96k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
   68|  8.96k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
   69|  8.96k|   z[2] = w2;
   70|  8.96k|   w2 = 0;
   71|       |
   72|  8.96k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
   73|  8.96k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
   74|  8.96k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
   75|  8.96k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
   76|  8.96k|   z[3] = w0;
   77|  8.96k|   w0 = 0;
   78|       |
   79|  8.96k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
   80|  8.96k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
   81|  8.96k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
   82|  8.96k|   z[4] = w1;
   83|  8.96k|   w1 = 0;
   84|       |
   85|  8.96k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
   86|  8.96k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
   87|  8.96k|   z[5] = w2;
   88|  8.96k|   w2 = 0;
   89|       |
   90|  8.96k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
   91|  8.96k|   z[6] = w0;
   92|  8.96k|   z[7] = w1;
   93|  8.96k|}
_ZN5Botan17bigint_comba_sqr6EPmPKm:
   98|  11.7k|void bigint_comba_sqr6(word z[12], const word x[6]) {
   99|  11.7k|   word w2 = 0, w1 = 0, w0 = 0;
  100|       |
  101|  11.7k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
  102|  11.7k|   z[0] = w0;
  103|  11.7k|   w0 = 0;
  104|       |
  105|  11.7k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
  106|  11.7k|   z[1] = w1;
  107|  11.7k|   w1 = 0;
  108|       |
  109|  11.7k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
  110|  11.7k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
  111|  11.7k|   z[2] = w2;
  112|  11.7k|   w2 = 0;
  113|       |
  114|  11.7k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
  115|  11.7k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
  116|  11.7k|   z[3] = w0;
  117|  11.7k|   w0 = 0;
  118|       |
  119|  11.7k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[4]);
  120|  11.7k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
  121|  11.7k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
  122|  11.7k|   z[4] = w1;
  123|  11.7k|   w1 = 0;
  124|       |
  125|  11.7k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[5]);
  126|  11.7k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[4]);
  127|  11.7k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
  128|  11.7k|   z[5] = w2;
  129|  11.7k|   w2 = 0;
  130|       |
  131|  11.7k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[5]);
  132|  11.7k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[4]);
  133|  11.7k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
  134|  11.7k|   z[6] = w0;
  135|  11.7k|   w0 = 0;
  136|       |
  137|  11.7k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[5]);
  138|  11.7k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[4]);
  139|  11.7k|   z[7] = w1;
  140|  11.7k|   w1 = 0;
  141|       |
  142|  11.7k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[5]);
  143|  11.7k|   word3_muladd(&w1, &w0, &w2, x[4], x[4]);
  144|  11.7k|   z[8] = w2;
  145|  11.7k|   w2 = 0;
  146|       |
  147|  11.7k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[5]);
  148|  11.7k|   z[9] = w0;
  149|  11.7k|   w0 = 0;
  150|       |
  151|  11.7k|   word3_muladd(&w0, &w2, &w1, x[5], x[5]);
  152|  11.7k|   z[10] = w1;
  153|  11.7k|   z[11] = w2;
  154|  11.7k|}
_ZN5Botan17bigint_comba_mul6EPmPKmS2_:
  159|  4.65k|void bigint_comba_mul6(word z[12], const word x[6], const word y[6]) {
  160|  4.65k|   word w2 = 0, w1 = 0, w0 = 0;
  161|       |
  162|  4.65k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
  163|  4.65k|   z[0] = w0;
  164|  4.65k|   w0 = 0;
  165|       |
  166|  4.65k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
  167|  4.65k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
  168|  4.65k|   z[1] = w1;
  169|  4.65k|   w1 = 0;
  170|       |
  171|  4.65k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
  172|  4.65k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
  173|  4.65k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
  174|  4.65k|   z[2] = w2;
  175|  4.65k|   w2 = 0;
  176|       |
  177|  4.65k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
  178|  4.65k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
  179|  4.65k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
  180|  4.65k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
  181|  4.65k|   z[3] = w0;
  182|  4.65k|   w0 = 0;
  183|       |
  184|  4.65k|   word3_muladd(&w0, &w2, &w1, x[0], y[4]);
  185|  4.65k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
  186|  4.65k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
  187|  4.65k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
  188|  4.65k|   word3_muladd(&w0, &w2, &w1, x[4], y[0]);
  189|  4.65k|   z[4] = w1;
  190|  4.65k|   w1 = 0;
  191|       |
  192|  4.65k|   word3_muladd(&w1, &w0, &w2, x[0], y[5]);
  193|  4.65k|   word3_muladd(&w1, &w0, &w2, x[1], y[4]);
  194|  4.65k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
  195|  4.65k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
  196|  4.65k|   word3_muladd(&w1, &w0, &w2, x[4], y[1]);
  197|  4.65k|   word3_muladd(&w1, &w0, &w2, x[5], y[0]);
  198|  4.65k|   z[5] = w2;
  199|  4.65k|   w2 = 0;
  200|       |
  201|  4.65k|   word3_muladd(&w2, &w1, &w0, x[1], y[5]);
  202|  4.65k|   word3_muladd(&w2, &w1, &w0, x[2], y[4]);
  203|  4.65k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
  204|  4.65k|   word3_muladd(&w2, &w1, &w0, x[4], y[2]);
  205|  4.65k|   word3_muladd(&w2, &w1, &w0, x[5], y[1]);
  206|  4.65k|   z[6] = w0;
  207|  4.65k|   w0 = 0;
  208|       |
  209|  4.65k|   word3_muladd(&w0, &w2, &w1, x[2], y[5]);
  210|  4.65k|   word3_muladd(&w0, &w2, &w1, x[3], y[4]);
  211|  4.65k|   word3_muladd(&w0, &w2, &w1, x[4], y[3]);
  212|  4.65k|   word3_muladd(&w0, &w2, &w1, x[5], y[2]);
  213|  4.65k|   z[7] = w1;
  214|  4.65k|   w1 = 0;
  215|       |
  216|  4.65k|   word3_muladd(&w1, &w0, &w2, x[3], y[5]);
  217|  4.65k|   word3_muladd(&w1, &w0, &w2, x[4], y[4]);
  218|  4.65k|   word3_muladd(&w1, &w0, &w2, x[5], y[3]);
  219|  4.65k|   z[8] = w2;
  220|  4.65k|   w2 = 0;
  221|       |
  222|  4.65k|   word3_muladd(&w2, &w1, &w0, x[4], y[5]);
  223|  4.65k|   word3_muladd(&w2, &w1, &w0, x[5], y[4]);
  224|  4.65k|   z[9] = w0;
  225|  4.65k|   w0 = 0;
  226|       |
  227|  4.65k|   word3_muladd(&w0, &w2, &w1, x[5], y[5]);
  228|  4.65k|   z[10] = w1;
  229|  4.65k|   z[11] = w2;
  230|  4.65k|}
_ZN5Botan17bigint_comba_sqr8EPmPKm:
  235|  35.3k|void bigint_comba_sqr8(word z[16], const word x[8]) {
  236|  35.3k|   word w2 = 0, w1 = 0, w0 = 0;
  237|       |
  238|  35.3k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
  239|  35.3k|   z[0] = w0;
  240|  35.3k|   w0 = 0;
  241|       |
  242|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
  243|  35.3k|   z[1] = w1;
  244|  35.3k|   w1 = 0;
  245|       |
  246|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
  247|  35.3k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
  248|  35.3k|   z[2] = w2;
  249|  35.3k|   w2 = 0;
  250|       |
  251|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
  252|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
  253|  35.3k|   z[3] = w0;
  254|  35.3k|   w0 = 0;
  255|       |
  256|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[4]);
  257|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
  258|  35.3k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
  259|  35.3k|   z[4] = w1;
  260|  35.3k|   w1 = 0;
  261|       |
  262|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[5]);
  263|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[4]);
  264|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
  265|  35.3k|   z[5] = w2;
  266|  35.3k|   w2 = 0;
  267|       |
  268|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[6]);
  269|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[5]);
  270|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[4]);
  271|  35.3k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
  272|  35.3k|   z[6] = w0;
  273|  35.3k|   w0 = 0;
  274|       |
  275|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[7]);
  276|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[6]);
  277|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[5]);
  278|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[4]);
  279|  35.3k|   z[7] = w1;
  280|  35.3k|   w1 = 0;
  281|       |
  282|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[7]);
  283|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[6]);
  284|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[5]);
  285|  35.3k|   word3_muladd(&w1, &w0, &w2, x[4], x[4]);
  286|  35.3k|   z[8] = w2;
  287|  35.3k|   w2 = 0;
  288|       |
  289|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[7]);
  290|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[6]);
  291|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[5]);
  292|  35.3k|   z[9] = w0;
  293|  35.3k|   w0 = 0;
  294|       |
  295|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[7]);
  296|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[6]);
  297|  35.3k|   word3_muladd(&w0, &w2, &w1, x[5], x[5]);
  298|  35.3k|   z[10] = w1;
  299|  35.3k|   w1 = 0;
  300|       |
  301|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[7]);
  302|  35.3k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[6]);
  303|  35.3k|   z[11] = w2;
  304|  35.3k|   w2 = 0;
  305|       |
  306|  35.3k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[7]);
  307|  35.3k|   word3_muladd(&w2, &w1, &w0, x[6], x[6]);
  308|  35.3k|   z[12] = w0;
  309|  35.3k|   w0 = 0;
  310|       |
  311|  35.3k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[7]);
  312|  35.3k|   z[13] = w1;
  313|  35.3k|   w1 = 0;
  314|       |
  315|  35.3k|   word3_muladd(&w1, &w0, &w2, x[7], x[7]);
  316|  35.3k|   z[14] = w2;
  317|  35.3k|   z[15] = w0;
  318|  35.3k|}
_ZN5Botan17bigint_comba_mul8EPmPKmS2_:
  323|  10.7k|void bigint_comba_mul8(word z[16], const word x[8], const word y[8]) {
  324|  10.7k|   word w2 = 0, w1 = 0, w0 = 0;
  325|       |
  326|  10.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
  327|  10.7k|   z[0] = w0;
  328|  10.7k|   w0 = 0;
  329|       |
  330|  10.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
  331|  10.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
  332|  10.7k|   z[1] = w1;
  333|  10.7k|   w1 = 0;
  334|       |
  335|  10.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
  336|  10.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
  337|  10.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
  338|  10.7k|   z[2] = w2;
  339|  10.7k|   w2 = 0;
  340|       |
  341|  10.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
  342|  10.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
  343|  10.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
  344|  10.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
  345|  10.7k|   z[3] = w0;
  346|  10.7k|   w0 = 0;
  347|       |
  348|  10.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[4]);
  349|  10.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
  350|  10.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
  351|  10.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
  352|  10.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[0]);
  353|  10.7k|   z[4] = w1;
  354|  10.7k|   w1 = 0;
  355|       |
  356|  10.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[5]);
  357|  10.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[4]);
  358|  10.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
  359|  10.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
  360|  10.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[1]);
  361|  10.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[0]);
  362|  10.7k|   z[5] = w2;
  363|  10.7k|   w2 = 0;
  364|       |
  365|  10.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[6]);
  366|  10.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[5]);
  367|  10.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[4]);
  368|  10.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
  369|  10.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[2]);
  370|  10.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[1]);
  371|  10.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[0]);
  372|  10.7k|   z[6] = w0;
  373|  10.7k|   w0 = 0;
  374|       |
  375|  10.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[7]);
  376|  10.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[6]);
  377|  10.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[5]);
  378|  10.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[4]);
  379|  10.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[3]);
  380|  10.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[2]);
  381|  10.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[1]);
  382|  10.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[0]);
  383|  10.7k|   z[7] = w1;
  384|  10.7k|   w1 = 0;
  385|       |
  386|  10.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[7]);
  387|  10.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[6]);
  388|  10.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[5]);
  389|  10.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[4]);
  390|  10.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[3]);
  391|  10.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[2]);
  392|  10.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[1]);
  393|  10.7k|   z[8] = w2;
  394|  10.7k|   w2 = 0;
  395|       |
  396|  10.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[7]);
  397|  10.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[6]);
  398|  10.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[5]);
  399|  10.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[4]);
  400|  10.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[3]);
  401|  10.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[2]);
  402|  10.7k|   z[9] = w0;
  403|  10.7k|   w0 = 0;
  404|       |
  405|  10.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[7]);
  406|  10.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[6]);
  407|  10.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[5]);
  408|  10.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[4]);
  409|  10.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[3]);
  410|  10.7k|   z[10] = w1;
  411|  10.7k|   w1 = 0;
  412|       |
  413|  10.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[7]);
  414|  10.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[6]);
  415|  10.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[5]);
  416|  10.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[4]);
  417|  10.7k|   z[11] = w2;
  418|  10.7k|   w2 = 0;
  419|       |
  420|  10.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[7]);
  421|  10.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[6]);
  422|  10.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[5]);
  423|  10.7k|   z[12] = w0;
  424|  10.7k|   w0 = 0;
  425|       |
  426|  10.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[7]);
  427|  10.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[6]);
  428|  10.7k|   z[13] = w1;
  429|  10.7k|   w1 = 0;
  430|       |
  431|  10.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[7]);
  432|  10.7k|   z[14] = w2;
  433|  10.7k|   z[15] = w0;
  434|  10.7k|}
_ZN5Botan17bigint_comba_sqr9EPmPKm:
  439|  9.60k|void bigint_comba_sqr9(word z[18], const word x[9]) {
  440|  9.60k|   word w2 = 0, w1 = 0, w0 = 0;
  441|       |
  442|  9.60k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
  443|  9.60k|   z[0] = w0;
  444|  9.60k|   w0 = 0;
  445|       |
  446|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
  447|  9.60k|   z[1] = w1;
  448|  9.60k|   w1 = 0;
  449|       |
  450|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
  451|  9.60k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
  452|  9.60k|   z[2] = w2;
  453|  9.60k|   w2 = 0;
  454|       |
  455|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
  456|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
  457|  9.60k|   z[3] = w0;
  458|  9.60k|   w0 = 0;
  459|       |
  460|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[4]);
  461|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
  462|  9.60k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
  463|  9.60k|   z[4] = w1;
  464|  9.60k|   w1 = 0;
  465|       |
  466|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[5]);
  467|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[4]);
  468|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
  469|  9.60k|   z[5] = w2;
  470|  9.60k|   w2 = 0;
  471|       |
  472|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[6]);
  473|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[5]);
  474|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[4]);
  475|  9.60k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
  476|  9.60k|   z[6] = w0;
  477|  9.60k|   w0 = 0;
  478|       |
  479|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[7]);
  480|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[6]);
  481|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[5]);
  482|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[4]);
  483|  9.60k|   z[7] = w1;
  484|  9.60k|   w1 = 0;
  485|       |
  486|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[8]);
  487|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[7]);
  488|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[6]);
  489|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[5]);
  490|  9.60k|   word3_muladd(&w1, &w0, &w2, x[4], x[4]);
  491|  9.60k|   z[8] = w2;
  492|  9.60k|   w2 = 0;
  493|       |
  494|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[8]);
  495|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[7]);
  496|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[6]);
  497|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[5]);
  498|  9.60k|   z[9] = w0;
  499|  9.60k|   w0 = 0;
  500|       |
  501|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[8]);
  502|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[7]);
  503|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[6]);
  504|  9.60k|   word3_muladd(&w0, &w2, &w1, x[5], x[5]);
  505|  9.60k|   z[10] = w1;
  506|  9.60k|   w1 = 0;
  507|       |
  508|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[8]);
  509|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[7]);
  510|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[6]);
  511|  9.60k|   z[11] = w2;
  512|  9.60k|   w2 = 0;
  513|       |
  514|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[8]);
  515|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[7]);
  516|  9.60k|   word3_muladd(&w2, &w1, &w0, x[6], x[6]);
  517|  9.60k|   z[12] = w0;
  518|  9.60k|   w0 = 0;
  519|       |
  520|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[8]);
  521|  9.60k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[7]);
  522|  9.60k|   z[13] = w1;
  523|  9.60k|   w1 = 0;
  524|       |
  525|  9.60k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[8]);
  526|  9.60k|   word3_muladd(&w1, &w0, &w2, x[7], x[7]);
  527|  9.60k|   z[14] = w2;
  528|  9.60k|   w2 = 0;
  529|       |
  530|  9.60k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[8]);
  531|  9.60k|   z[15] = w0;
  532|  9.60k|   w0 = 0;
  533|       |
  534|  9.60k|   word3_muladd(&w0, &w2, &w1, x[8], x[8]);
  535|  9.60k|   z[16] = w1;
  536|  9.60k|   z[17] = w2;
  537|  9.60k|}
_ZN5Botan17bigint_comba_mul9EPmPKmS2_:
  542|  3.30k|void bigint_comba_mul9(word z[18], const word x[9], const word y[9]) {
  543|  3.30k|   word w2 = 0, w1 = 0, w0 = 0;
  544|       |
  545|  3.30k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
  546|  3.30k|   z[0] = w0;
  547|  3.30k|   w0 = 0;
  548|       |
  549|  3.30k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
  550|  3.30k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
  551|  3.30k|   z[1] = w1;
  552|  3.30k|   w1 = 0;
  553|       |
  554|  3.30k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
  555|  3.30k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
  556|  3.30k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
  557|  3.30k|   z[2] = w2;
  558|  3.30k|   w2 = 0;
  559|       |
  560|  3.30k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
  561|  3.30k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
  562|  3.30k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
  563|  3.30k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
  564|  3.30k|   z[3] = w0;
  565|  3.30k|   w0 = 0;
  566|       |
  567|  3.30k|   word3_muladd(&w0, &w2, &w1, x[0], y[4]);
  568|  3.30k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
  569|  3.30k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
  570|  3.30k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
  571|  3.30k|   word3_muladd(&w0, &w2, &w1, x[4], y[0]);
  572|  3.30k|   z[4] = w1;
  573|  3.30k|   w1 = 0;
  574|       |
  575|  3.30k|   word3_muladd(&w1, &w0, &w2, x[0], y[5]);
  576|  3.30k|   word3_muladd(&w1, &w0, &w2, x[1], y[4]);
  577|  3.30k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
  578|  3.30k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
  579|  3.30k|   word3_muladd(&w1, &w0, &w2, x[4], y[1]);
  580|  3.30k|   word3_muladd(&w1, &w0, &w2, x[5], y[0]);
  581|  3.30k|   z[5] = w2;
  582|  3.30k|   w2 = 0;
  583|       |
  584|  3.30k|   word3_muladd(&w2, &w1, &w0, x[0], y[6]);
  585|  3.30k|   word3_muladd(&w2, &w1, &w0, x[1], y[5]);
  586|  3.30k|   word3_muladd(&w2, &w1, &w0, x[2], y[4]);
  587|  3.30k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
  588|  3.30k|   word3_muladd(&w2, &w1, &w0, x[4], y[2]);
  589|  3.30k|   word3_muladd(&w2, &w1, &w0, x[5], y[1]);
  590|  3.30k|   word3_muladd(&w2, &w1, &w0, x[6], y[0]);
  591|  3.30k|   z[6] = w0;
  592|  3.30k|   w0 = 0;
  593|       |
  594|  3.30k|   word3_muladd(&w0, &w2, &w1, x[0], y[7]);
  595|  3.30k|   word3_muladd(&w0, &w2, &w1, x[1], y[6]);
  596|  3.30k|   word3_muladd(&w0, &w2, &w1, x[2], y[5]);
  597|  3.30k|   word3_muladd(&w0, &w2, &w1, x[3], y[4]);
  598|  3.30k|   word3_muladd(&w0, &w2, &w1, x[4], y[3]);
  599|  3.30k|   word3_muladd(&w0, &w2, &w1, x[5], y[2]);
  600|  3.30k|   word3_muladd(&w0, &w2, &w1, x[6], y[1]);
  601|  3.30k|   word3_muladd(&w0, &w2, &w1, x[7], y[0]);
  602|  3.30k|   z[7] = w1;
  603|  3.30k|   w1 = 0;
  604|       |
  605|  3.30k|   word3_muladd(&w1, &w0, &w2, x[0], y[8]);
  606|  3.30k|   word3_muladd(&w1, &w0, &w2, x[1], y[7]);
  607|  3.30k|   word3_muladd(&w1, &w0, &w2, x[2], y[6]);
  608|  3.30k|   word3_muladd(&w1, &w0, &w2, x[3], y[5]);
  609|  3.30k|   word3_muladd(&w1, &w0, &w2, x[4], y[4]);
  610|  3.30k|   word3_muladd(&w1, &w0, &w2, x[5], y[3]);
  611|  3.30k|   word3_muladd(&w1, &w0, &w2, x[6], y[2]);
  612|  3.30k|   word3_muladd(&w1, &w0, &w2, x[7], y[1]);
  613|  3.30k|   word3_muladd(&w1, &w0, &w2, x[8], y[0]);
  614|  3.30k|   z[8] = w2;
  615|  3.30k|   w2 = 0;
  616|       |
  617|  3.30k|   word3_muladd(&w2, &w1, &w0, x[1], y[8]);
  618|  3.30k|   word3_muladd(&w2, &w1, &w0, x[2], y[7]);
  619|  3.30k|   word3_muladd(&w2, &w1, &w0, x[3], y[6]);
  620|  3.30k|   word3_muladd(&w2, &w1, &w0, x[4], y[5]);
  621|  3.30k|   word3_muladd(&w2, &w1, &w0, x[5], y[4]);
  622|  3.30k|   word3_muladd(&w2, &w1, &w0, x[6], y[3]);
  623|  3.30k|   word3_muladd(&w2, &w1, &w0, x[7], y[2]);
  624|  3.30k|   word3_muladd(&w2, &w1, &w0, x[8], y[1]);
  625|  3.30k|   z[9] = w0;
  626|  3.30k|   w0 = 0;
  627|       |
  628|  3.30k|   word3_muladd(&w0, &w2, &w1, x[2], y[8]);
  629|  3.30k|   word3_muladd(&w0, &w2, &w1, x[3], y[7]);
  630|  3.30k|   word3_muladd(&w0, &w2, &w1, x[4], y[6]);
  631|  3.30k|   word3_muladd(&w0, &w2, &w1, x[5], y[5]);
  632|  3.30k|   word3_muladd(&w0, &w2, &w1, x[6], y[4]);
  633|  3.30k|   word3_muladd(&w0, &w2, &w1, x[7], y[3]);
  634|  3.30k|   word3_muladd(&w0, &w2, &w1, x[8], y[2]);
  635|  3.30k|   z[10] = w1;
  636|  3.30k|   w1 = 0;
  637|       |
  638|  3.30k|   word3_muladd(&w1, &w0, &w2, x[3], y[8]);
  639|  3.30k|   word3_muladd(&w1, &w0, &w2, x[4], y[7]);
  640|  3.30k|   word3_muladd(&w1, &w0, &w2, x[5], y[6]);
  641|  3.30k|   word3_muladd(&w1, &w0, &w2, x[6], y[5]);
  642|  3.30k|   word3_muladd(&w1, &w0, &w2, x[7], y[4]);
  643|  3.30k|   word3_muladd(&w1, &w0, &w2, x[8], y[3]);
  644|  3.30k|   z[11] = w2;
  645|  3.30k|   w2 = 0;
  646|       |
  647|  3.30k|   word3_muladd(&w2, &w1, &w0, x[4], y[8]);
  648|  3.30k|   word3_muladd(&w2, &w1, &w0, x[5], y[7]);
  649|  3.30k|   word3_muladd(&w2, &w1, &w0, x[6], y[6]);
  650|  3.30k|   word3_muladd(&w2, &w1, &w0, x[7], y[5]);
  651|  3.30k|   word3_muladd(&w2, &w1, &w0, x[8], y[4]);
  652|  3.30k|   z[12] = w0;
  653|  3.30k|   w0 = 0;
  654|       |
  655|  3.30k|   word3_muladd(&w0, &w2, &w1, x[5], y[8]);
  656|  3.30k|   word3_muladd(&w0, &w2, &w1, x[6], y[7]);
  657|  3.30k|   word3_muladd(&w0, &w2, &w1, x[7], y[6]);
  658|  3.30k|   word3_muladd(&w0, &w2, &w1, x[8], y[5]);
  659|  3.30k|   z[13] = w1;
  660|  3.30k|   w1 = 0;
  661|       |
  662|  3.30k|   word3_muladd(&w1, &w0, &w2, x[6], y[8]);
  663|  3.30k|   word3_muladd(&w1, &w0, &w2, x[7], y[7]);
  664|  3.30k|   word3_muladd(&w1, &w0, &w2, x[8], y[6]);
  665|  3.30k|   z[14] = w2;
  666|  3.30k|   w2 = 0;
  667|       |
  668|  3.30k|   word3_muladd(&w2, &w1, &w0, x[7], y[8]);
  669|  3.30k|   word3_muladd(&w2, &w1, &w0, x[8], y[7]);
  670|  3.30k|   z[15] = w0;
  671|  3.30k|   w0 = 0;
  672|       |
  673|  3.30k|   word3_muladd(&w0, &w2, &w1, x[8], y[8]);
  674|  3.30k|   z[16] = w1;
  675|  3.30k|   z[17] = w2;
  676|  3.30k|}
_ZN5Botan18bigint_comba_sqr16EPmPKm:
  681|  61.4k|void bigint_comba_sqr16(word z[32], const word x[16]) {
  682|  61.4k|   word w2 = 0, w1 = 0, w0 = 0;
  683|       |
  684|  61.4k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
  685|  61.4k|   z[0] = w0;
  686|  61.4k|   w0 = 0;
  687|       |
  688|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
  689|  61.4k|   z[1] = w1;
  690|  61.4k|   w1 = 0;
  691|       |
  692|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
  693|  61.4k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
  694|  61.4k|   z[2] = w2;
  695|  61.4k|   w2 = 0;
  696|       |
  697|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
  698|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
  699|  61.4k|   z[3] = w0;
  700|  61.4k|   w0 = 0;
  701|       |
  702|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[4]);
  703|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
  704|  61.4k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
  705|  61.4k|   z[4] = w1;
  706|  61.4k|   w1 = 0;
  707|       |
  708|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[5]);
  709|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[4]);
  710|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
  711|  61.4k|   z[5] = w2;
  712|  61.4k|   w2 = 0;
  713|       |
  714|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[6]);
  715|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[5]);
  716|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[4]);
  717|  61.4k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
  718|  61.4k|   z[6] = w0;
  719|  61.4k|   w0 = 0;
  720|       |
  721|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[7]);
  722|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[6]);
  723|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[5]);
  724|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[4]);
  725|  61.4k|   z[7] = w1;
  726|  61.4k|   w1 = 0;
  727|       |
  728|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[8]);
  729|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[7]);
  730|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[6]);
  731|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[5]);
  732|  61.4k|   word3_muladd(&w1, &w0, &w2, x[4], x[4]);
  733|  61.4k|   z[8] = w2;
  734|  61.4k|   w2 = 0;
  735|       |
  736|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[9]);
  737|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[8]);
  738|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[7]);
  739|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[6]);
  740|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[5]);
  741|  61.4k|   z[9] = w0;
  742|  61.4k|   w0 = 0;
  743|       |
  744|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[10]);
  745|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[9]);
  746|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[8]);
  747|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[7]);
  748|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[6]);
  749|  61.4k|   word3_muladd(&w0, &w2, &w1, x[5], x[5]);
  750|  61.4k|   z[10] = w1;
  751|  61.4k|   w1 = 0;
  752|       |
  753|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[11]);
  754|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[10]);
  755|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[9]);
  756|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[8]);
  757|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[7]);
  758|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[6]);
  759|  61.4k|   z[11] = w2;
  760|  61.4k|   w2 = 0;
  761|       |
  762|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[12]);
  763|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[11]);
  764|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[10]);
  765|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[9]);
  766|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[8]);
  767|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[7]);
  768|  61.4k|   word3_muladd(&w2, &w1, &w0, x[6], x[6]);
  769|  61.4k|   z[12] = w0;
  770|  61.4k|   w0 = 0;
  771|       |
  772|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[13]);
  773|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[12]);
  774|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[11]);
  775|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[10]);
  776|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[9]);
  777|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[8]);
  778|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[7]);
  779|  61.4k|   z[13] = w1;
  780|  61.4k|   w1 = 0;
  781|       |
  782|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[14]);
  783|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[13]);
  784|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[12]);
  785|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[11]);
  786|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[10]);
  787|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[9]);
  788|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[8]);
  789|  61.4k|   word3_muladd(&w1, &w0, &w2, x[7], x[7]);
  790|  61.4k|   z[14] = w2;
  791|  61.4k|   w2 = 0;
  792|       |
  793|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[15]);
  794|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[14]);
  795|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[13]);
  796|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[12]);
  797|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[11]);
  798|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[10]);
  799|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[9]);
  800|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[8]);
  801|  61.4k|   z[15] = w0;
  802|  61.4k|   w0 = 0;
  803|       |
  804|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[15]);
  805|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[14]);
  806|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[13]);
  807|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[12]);
  808|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[11]);
  809|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[10]);
  810|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[9]);
  811|  61.4k|   word3_muladd(&w0, &w2, &w1, x[8], x[8]);
  812|  61.4k|   z[16] = w1;
  813|  61.4k|   w1 = 0;
  814|       |
  815|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[15]);
  816|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[14]);
  817|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[13]);
  818|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[12]);
  819|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[11]);
  820|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[10]);
  821|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[9]);
  822|  61.4k|   z[17] = w2;
  823|  61.4k|   w2 = 0;
  824|       |
  825|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[15]);
  826|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[14]);
  827|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[13]);
  828|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[12]);
  829|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[11]);
  830|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[10]);
  831|  61.4k|   word3_muladd(&w2, &w1, &w0, x[9], x[9]);
  832|  61.4k|   z[18] = w0;
  833|  61.4k|   w0 = 0;
  834|       |
  835|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[15]);
  836|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[14]);
  837|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[13]);
  838|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[12]);
  839|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[11]);
  840|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[10]);
  841|  61.4k|   z[19] = w1;
  842|  61.4k|   w1 = 0;
  843|       |
  844|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[15]);
  845|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[14]);
  846|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[13]);
  847|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[12]);
  848|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[11]);
  849|  61.4k|   word3_muladd(&w1, &w0, &w2, x[10], x[10]);
  850|  61.4k|   z[20] = w2;
  851|  61.4k|   w2 = 0;
  852|       |
  853|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[15]);
  854|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[14]);
  855|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[13]);
  856|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[12]);
  857|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[11]);
  858|  61.4k|   z[21] = w0;
  859|  61.4k|   w0 = 0;
  860|       |
  861|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[15]);
  862|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[14]);
  863|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[13]);
  864|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[12]);
  865|  61.4k|   word3_muladd(&w0, &w2, &w1, x[11], x[11]);
  866|  61.4k|   z[22] = w1;
  867|  61.4k|   w1 = 0;
  868|       |
  869|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[15]);
  870|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[14]);
  871|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[10], x[13]);
  872|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[12]);
  873|  61.4k|   z[23] = w2;
  874|  61.4k|   w2 = 0;
  875|       |
  876|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[15]);
  877|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[14]);
  878|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[11], x[13]);
  879|  61.4k|   word3_muladd(&w2, &w1, &w0, x[12], x[12]);
  880|  61.4k|   z[24] = w0;
  881|  61.4k|   w0 = 0;
  882|       |
  883|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[15]);
  884|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[11], x[14]);
  885|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[12], x[13]);
  886|  61.4k|   z[25] = w1;
  887|  61.4k|   w1 = 0;
  888|       |
  889|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[15]);
  890|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[12], x[14]);
  891|  61.4k|   word3_muladd(&w1, &w0, &w2, x[13], x[13]);
  892|  61.4k|   z[26] = w2;
  893|  61.4k|   w2 = 0;
  894|       |
  895|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[12], x[15]);
  896|  61.4k|   word3_muladd_2(&w2, &w1, &w0, x[13], x[14]);
  897|  61.4k|   z[27] = w0;
  898|  61.4k|   w0 = 0;
  899|       |
  900|  61.4k|   word3_muladd_2(&w0, &w2, &w1, x[13], x[15]);
  901|  61.4k|   word3_muladd(&w0, &w2, &w1, x[14], x[14]);
  902|  61.4k|   z[28] = w1;
  903|  61.4k|   w1 = 0;
  904|       |
  905|  61.4k|   word3_muladd_2(&w1, &w0, &w2, x[14], x[15]);
  906|  61.4k|   z[29] = w2;
  907|  61.4k|   w2 = 0;
  908|       |
  909|  61.4k|   word3_muladd(&w2, &w1, &w0, x[15], x[15]);
  910|  61.4k|   z[30] = w0;
  911|  61.4k|   z[31] = w1;
  912|  61.4k|}
_ZN5Botan18bigint_comba_mul16EPmPKmS2_:
  917|  28.7k|void bigint_comba_mul16(word z[32], const word x[16], const word y[16]) {
  918|  28.7k|   word w2 = 0, w1 = 0, w0 = 0;
  919|       |
  920|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
  921|  28.7k|   z[0] = w0;
  922|  28.7k|   w0 = 0;
  923|       |
  924|  28.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
  925|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
  926|  28.7k|   z[1] = w1;
  927|  28.7k|   w1 = 0;
  928|       |
  929|  28.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
  930|  28.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
  931|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
  932|  28.7k|   z[2] = w2;
  933|  28.7k|   w2 = 0;
  934|       |
  935|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
  936|  28.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
  937|  28.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
  938|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
  939|  28.7k|   z[3] = w0;
  940|  28.7k|   w0 = 0;
  941|       |
  942|  28.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[4]);
  943|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
  944|  28.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
  945|  28.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
  946|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[0]);
  947|  28.7k|   z[4] = w1;
  948|  28.7k|   w1 = 0;
  949|       |
  950|  28.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[5]);
  951|  28.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[4]);
  952|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
  953|  28.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
  954|  28.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[1]);
  955|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[0]);
  956|  28.7k|   z[5] = w2;
  957|  28.7k|   w2 = 0;
  958|       |
  959|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[6]);
  960|  28.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[5]);
  961|  28.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[4]);
  962|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
  963|  28.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[2]);
  964|  28.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[1]);
  965|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[0]);
  966|  28.7k|   z[6] = w0;
  967|  28.7k|   w0 = 0;
  968|       |
  969|  28.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[7]);
  970|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[6]);
  971|  28.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[5]);
  972|  28.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[4]);
  973|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[3]);
  974|  28.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[2]);
  975|  28.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[1]);
  976|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[0]);
  977|  28.7k|   z[7] = w1;
  978|  28.7k|   w1 = 0;
  979|       |
  980|  28.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[8]);
  981|  28.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[7]);
  982|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[6]);
  983|  28.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[5]);
  984|  28.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[4]);
  985|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[3]);
  986|  28.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[2]);
  987|  28.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[1]);
  988|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[0]);
  989|  28.7k|   z[8] = w2;
  990|  28.7k|   w2 = 0;
  991|       |
  992|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[9]);
  993|  28.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[8]);
  994|  28.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[7]);
  995|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[6]);
  996|  28.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[5]);
  997|  28.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[4]);
  998|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[3]);
  999|  28.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[2]);
 1000|  28.7k|   word3_muladd(&w2, &w1, &w0, x[8], y[1]);
 1001|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[0]);
 1002|  28.7k|   z[9] = w0;
 1003|  28.7k|   w0 = 0;
 1004|       |
 1005|  28.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[10]);
 1006|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[9]);
 1007|  28.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[8]);
 1008|  28.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[7]);
 1009|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[6]);
 1010|  28.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[5]);
 1011|  28.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[4]);
 1012|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[3]);
 1013|  28.7k|   word3_muladd(&w0, &w2, &w1, x[8], y[2]);
 1014|  28.7k|   word3_muladd(&w0, &w2, &w1, x[9], y[1]);
 1015|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[0]);
 1016|  28.7k|   z[10] = w1;
 1017|  28.7k|   w1 = 0;
 1018|       |
 1019|  28.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[11]);
 1020|  28.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[10]);
 1021|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[9]);
 1022|  28.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[8]);
 1023|  28.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[7]);
 1024|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[6]);
 1025|  28.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[5]);
 1026|  28.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[4]);
 1027|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[3]);
 1028|  28.7k|   word3_muladd(&w1, &w0, &w2, x[9], y[2]);
 1029|  28.7k|   word3_muladd(&w1, &w0, &w2, x[10], y[1]);
 1030|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[0]);
 1031|  28.7k|   z[11] = w2;
 1032|  28.7k|   w2 = 0;
 1033|       |
 1034|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[12]);
 1035|  28.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[11]);
 1036|  28.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[10]);
 1037|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[9]);
 1038|  28.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[8]);
 1039|  28.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[7]);
 1040|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[6]);
 1041|  28.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[5]);
 1042|  28.7k|   word3_muladd(&w2, &w1, &w0, x[8], y[4]);
 1043|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[3]);
 1044|  28.7k|   word3_muladd(&w2, &w1, &w0, x[10], y[2]);
 1045|  28.7k|   word3_muladd(&w2, &w1, &w0, x[11], y[1]);
 1046|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[0]);
 1047|  28.7k|   z[12] = w0;
 1048|  28.7k|   w0 = 0;
 1049|       |
 1050|  28.7k|   word3_muladd(&w0, &w2, &w1, x[0], y[13]);
 1051|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[12]);
 1052|  28.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[11]);
 1053|  28.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[10]);
 1054|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[9]);
 1055|  28.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[8]);
 1056|  28.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[7]);
 1057|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[6]);
 1058|  28.7k|   word3_muladd(&w0, &w2, &w1, x[8], y[5]);
 1059|  28.7k|   word3_muladd(&w0, &w2, &w1, x[9], y[4]);
 1060|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[3]);
 1061|  28.7k|   word3_muladd(&w0, &w2, &w1, x[11], y[2]);
 1062|  28.7k|   word3_muladd(&w0, &w2, &w1, x[12], y[1]);
 1063|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[0]);
 1064|  28.7k|   z[13] = w1;
 1065|  28.7k|   w1 = 0;
 1066|       |
 1067|  28.7k|   word3_muladd(&w1, &w0, &w2, x[0], y[14]);
 1068|  28.7k|   word3_muladd(&w1, &w0, &w2, x[1], y[13]);
 1069|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[12]);
 1070|  28.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[11]);
 1071|  28.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[10]);
 1072|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[9]);
 1073|  28.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[8]);
 1074|  28.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[7]);
 1075|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[6]);
 1076|  28.7k|   word3_muladd(&w1, &w0, &w2, x[9], y[5]);
 1077|  28.7k|   word3_muladd(&w1, &w0, &w2, x[10], y[4]);
 1078|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[3]);
 1079|  28.7k|   word3_muladd(&w1, &w0, &w2, x[12], y[2]);
 1080|  28.7k|   word3_muladd(&w1, &w0, &w2, x[13], y[1]);
 1081|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[0]);
 1082|  28.7k|   z[14] = w2;
 1083|  28.7k|   w2 = 0;
 1084|       |
 1085|  28.7k|   word3_muladd(&w2, &w1, &w0, x[0], y[15]);
 1086|  28.7k|   word3_muladd(&w2, &w1, &w0, x[1], y[14]);
 1087|  28.7k|   word3_muladd(&w2, &w1, &w0, x[2], y[13]);
 1088|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[12]);
 1089|  28.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[11]);
 1090|  28.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[10]);
 1091|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[9]);
 1092|  28.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[8]);
 1093|  28.7k|   word3_muladd(&w2, &w1, &w0, x[8], y[7]);
 1094|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[6]);
 1095|  28.7k|   word3_muladd(&w2, &w1, &w0, x[10], y[5]);
 1096|  28.7k|   word3_muladd(&w2, &w1, &w0, x[11], y[4]);
 1097|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[3]);
 1098|  28.7k|   word3_muladd(&w2, &w1, &w0, x[13], y[2]);
 1099|  28.7k|   word3_muladd(&w2, &w1, &w0, x[14], y[1]);
 1100|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[0]);
 1101|  28.7k|   z[15] = w0;
 1102|  28.7k|   w0 = 0;
 1103|       |
 1104|  28.7k|   word3_muladd(&w0, &w2, &w1, x[1], y[15]);
 1105|  28.7k|   word3_muladd(&w0, &w2, &w1, x[2], y[14]);
 1106|  28.7k|   word3_muladd(&w0, &w2, &w1, x[3], y[13]);
 1107|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[12]);
 1108|  28.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[11]);
 1109|  28.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[10]);
 1110|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[9]);
 1111|  28.7k|   word3_muladd(&w0, &w2, &w1, x[8], y[8]);
 1112|  28.7k|   word3_muladd(&w0, &w2, &w1, x[9], y[7]);
 1113|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[6]);
 1114|  28.7k|   word3_muladd(&w0, &w2, &w1, x[11], y[5]);
 1115|  28.7k|   word3_muladd(&w0, &w2, &w1, x[12], y[4]);
 1116|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[3]);
 1117|  28.7k|   word3_muladd(&w0, &w2, &w1, x[14], y[2]);
 1118|  28.7k|   word3_muladd(&w0, &w2, &w1, x[15], y[1]);
 1119|  28.7k|   z[16] = w1;
 1120|  28.7k|   w1 = 0;
 1121|       |
 1122|  28.7k|   word3_muladd(&w1, &w0, &w2, x[2], y[15]);
 1123|  28.7k|   word3_muladd(&w1, &w0, &w2, x[3], y[14]);
 1124|  28.7k|   word3_muladd(&w1, &w0, &w2, x[4], y[13]);
 1125|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[12]);
 1126|  28.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[11]);
 1127|  28.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[10]);
 1128|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[9]);
 1129|  28.7k|   word3_muladd(&w1, &w0, &w2, x[9], y[8]);
 1130|  28.7k|   word3_muladd(&w1, &w0, &w2, x[10], y[7]);
 1131|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[6]);
 1132|  28.7k|   word3_muladd(&w1, &w0, &w2, x[12], y[5]);
 1133|  28.7k|   word3_muladd(&w1, &w0, &w2, x[13], y[4]);
 1134|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[3]);
 1135|  28.7k|   word3_muladd(&w1, &w0, &w2, x[15], y[2]);
 1136|  28.7k|   z[17] = w2;
 1137|  28.7k|   w2 = 0;
 1138|       |
 1139|  28.7k|   word3_muladd(&w2, &w1, &w0, x[3], y[15]);
 1140|  28.7k|   word3_muladd(&w2, &w1, &w0, x[4], y[14]);
 1141|  28.7k|   word3_muladd(&w2, &w1, &w0, x[5], y[13]);
 1142|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[12]);
 1143|  28.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[11]);
 1144|  28.7k|   word3_muladd(&w2, &w1, &w0, x[8], y[10]);
 1145|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[9]);
 1146|  28.7k|   word3_muladd(&w2, &w1, &w0, x[10], y[8]);
 1147|  28.7k|   word3_muladd(&w2, &w1, &w0, x[11], y[7]);
 1148|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[6]);
 1149|  28.7k|   word3_muladd(&w2, &w1, &w0, x[13], y[5]);
 1150|  28.7k|   word3_muladd(&w2, &w1, &w0, x[14], y[4]);
 1151|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[3]);
 1152|  28.7k|   z[18] = w0;
 1153|  28.7k|   w0 = 0;
 1154|       |
 1155|  28.7k|   word3_muladd(&w0, &w2, &w1, x[4], y[15]);
 1156|  28.7k|   word3_muladd(&w0, &w2, &w1, x[5], y[14]);
 1157|  28.7k|   word3_muladd(&w0, &w2, &w1, x[6], y[13]);
 1158|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[12]);
 1159|  28.7k|   word3_muladd(&w0, &w2, &w1, x[8], y[11]);
 1160|  28.7k|   word3_muladd(&w0, &w2, &w1, x[9], y[10]);
 1161|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[9]);
 1162|  28.7k|   word3_muladd(&w0, &w2, &w1, x[11], y[8]);
 1163|  28.7k|   word3_muladd(&w0, &w2, &w1, x[12], y[7]);
 1164|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[6]);
 1165|  28.7k|   word3_muladd(&w0, &w2, &w1, x[14], y[5]);
 1166|  28.7k|   word3_muladd(&w0, &w2, &w1, x[15], y[4]);
 1167|  28.7k|   z[19] = w1;
 1168|  28.7k|   w1 = 0;
 1169|       |
 1170|  28.7k|   word3_muladd(&w1, &w0, &w2, x[5], y[15]);
 1171|  28.7k|   word3_muladd(&w1, &w0, &w2, x[6], y[14]);
 1172|  28.7k|   word3_muladd(&w1, &w0, &w2, x[7], y[13]);
 1173|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[12]);
 1174|  28.7k|   word3_muladd(&w1, &w0, &w2, x[9], y[11]);
 1175|  28.7k|   word3_muladd(&w1, &w0, &w2, x[10], y[10]);
 1176|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[9]);
 1177|  28.7k|   word3_muladd(&w1, &w0, &w2, x[12], y[8]);
 1178|  28.7k|   word3_muladd(&w1, &w0, &w2, x[13], y[7]);
 1179|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[6]);
 1180|  28.7k|   word3_muladd(&w1, &w0, &w2, x[15], y[5]);
 1181|  28.7k|   z[20] = w2;
 1182|  28.7k|   w2 = 0;
 1183|       |
 1184|  28.7k|   word3_muladd(&w2, &w1, &w0, x[6], y[15]);
 1185|  28.7k|   word3_muladd(&w2, &w1, &w0, x[7], y[14]);
 1186|  28.7k|   word3_muladd(&w2, &w1, &w0, x[8], y[13]);
 1187|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[12]);
 1188|  28.7k|   word3_muladd(&w2, &w1, &w0, x[10], y[11]);
 1189|  28.7k|   word3_muladd(&w2, &w1, &w0, x[11], y[10]);
 1190|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[9]);
 1191|  28.7k|   word3_muladd(&w2, &w1, &w0, x[13], y[8]);
 1192|  28.7k|   word3_muladd(&w2, &w1, &w0, x[14], y[7]);
 1193|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[6]);
 1194|  28.7k|   z[21] = w0;
 1195|  28.7k|   w0 = 0;
 1196|       |
 1197|  28.7k|   word3_muladd(&w0, &w2, &w1, x[7], y[15]);
 1198|  28.7k|   word3_muladd(&w0, &w2, &w1, x[8], y[14]);
 1199|  28.7k|   word3_muladd(&w0, &w2, &w1, x[9], y[13]);
 1200|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[12]);
 1201|  28.7k|   word3_muladd(&w0, &w2, &w1, x[11], y[11]);
 1202|  28.7k|   word3_muladd(&w0, &w2, &w1, x[12], y[10]);
 1203|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[9]);
 1204|  28.7k|   word3_muladd(&w0, &w2, &w1, x[14], y[8]);
 1205|  28.7k|   word3_muladd(&w0, &w2, &w1, x[15], y[7]);
 1206|  28.7k|   z[22] = w1;
 1207|  28.7k|   w1 = 0;
 1208|       |
 1209|  28.7k|   word3_muladd(&w1, &w0, &w2, x[8], y[15]);
 1210|  28.7k|   word3_muladd(&w1, &w0, &w2, x[9], y[14]);
 1211|  28.7k|   word3_muladd(&w1, &w0, &w2, x[10], y[13]);
 1212|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[12]);
 1213|  28.7k|   word3_muladd(&w1, &w0, &w2, x[12], y[11]);
 1214|  28.7k|   word3_muladd(&w1, &w0, &w2, x[13], y[10]);
 1215|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[9]);
 1216|  28.7k|   word3_muladd(&w1, &w0, &w2, x[15], y[8]);
 1217|  28.7k|   z[23] = w2;
 1218|  28.7k|   w2 = 0;
 1219|       |
 1220|  28.7k|   word3_muladd(&w2, &w1, &w0, x[9], y[15]);
 1221|  28.7k|   word3_muladd(&w2, &w1, &w0, x[10], y[14]);
 1222|  28.7k|   word3_muladd(&w2, &w1, &w0, x[11], y[13]);
 1223|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[12]);
 1224|  28.7k|   word3_muladd(&w2, &w1, &w0, x[13], y[11]);
 1225|  28.7k|   word3_muladd(&w2, &w1, &w0, x[14], y[10]);
 1226|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[9]);
 1227|  28.7k|   z[24] = w0;
 1228|  28.7k|   w0 = 0;
 1229|       |
 1230|  28.7k|   word3_muladd(&w0, &w2, &w1, x[10], y[15]);
 1231|  28.7k|   word3_muladd(&w0, &w2, &w1, x[11], y[14]);
 1232|  28.7k|   word3_muladd(&w0, &w2, &w1, x[12], y[13]);
 1233|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[12]);
 1234|  28.7k|   word3_muladd(&w0, &w2, &w1, x[14], y[11]);
 1235|  28.7k|   word3_muladd(&w0, &w2, &w1, x[15], y[10]);
 1236|  28.7k|   z[25] = w1;
 1237|  28.7k|   w1 = 0;
 1238|       |
 1239|  28.7k|   word3_muladd(&w1, &w0, &w2, x[11], y[15]);
 1240|  28.7k|   word3_muladd(&w1, &w0, &w2, x[12], y[14]);
 1241|  28.7k|   word3_muladd(&w1, &w0, &w2, x[13], y[13]);
 1242|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[12]);
 1243|  28.7k|   word3_muladd(&w1, &w0, &w2, x[15], y[11]);
 1244|  28.7k|   z[26] = w2;
 1245|  28.7k|   w2 = 0;
 1246|       |
 1247|  28.7k|   word3_muladd(&w2, &w1, &w0, x[12], y[15]);
 1248|  28.7k|   word3_muladd(&w2, &w1, &w0, x[13], y[14]);
 1249|  28.7k|   word3_muladd(&w2, &w1, &w0, x[14], y[13]);
 1250|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[12]);
 1251|  28.7k|   z[27] = w0;
 1252|  28.7k|   w0 = 0;
 1253|       |
 1254|  28.7k|   word3_muladd(&w0, &w2, &w1, x[13], y[15]);
 1255|  28.7k|   word3_muladd(&w0, &w2, &w1, x[14], y[14]);
 1256|  28.7k|   word3_muladd(&w0, &w2, &w1, x[15], y[13]);
 1257|  28.7k|   z[28] = w1;
 1258|  28.7k|   w1 = 0;
 1259|       |
 1260|  28.7k|   word3_muladd(&w1, &w0, &w2, x[14], y[15]);
 1261|  28.7k|   word3_muladd(&w1, &w0, &w2, x[15], y[14]);
 1262|  28.7k|   z[29] = w2;
 1263|  28.7k|   w2 = 0;
 1264|       |
 1265|  28.7k|   word3_muladd(&w2, &w1, &w0, x[15], y[15]);
 1266|  28.7k|   z[30] = w0;
 1267|  28.7k|   z[31] = w1;
 1268|  28.7k|}
_ZN5Botan18bigint_comba_sqr24EPmPKm:
 1273|  3.85k|void bigint_comba_sqr24(word z[48], const word x[24]) {
 1274|  3.85k|   word w2 = 0, w1 = 0, w0 = 0;
 1275|       |
 1276|  3.85k|   word3_muladd(&w2, &w1, &w0, x[0], x[0]);
 1277|  3.85k|   z[0] = w0;
 1278|  3.85k|   w0 = 0;
 1279|       |
 1280|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[1]);
 1281|  3.85k|   z[1] = w1;
 1282|  3.85k|   w1 = 0;
 1283|       |
 1284|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[2]);
 1285|  3.85k|   word3_muladd(&w1, &w0, &w2, x[1], x[1]);
 1286|  3.85k|   z[2] = w2;
 1287|  3.85k|   w2 = 0;
 1288|       |
 1289|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[3]);
 1290|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[2]);
 1291|  3.85k|   z[3] = w0;
 1292|  3.85k|   w0 = 0;
 1293|       |
 1294|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[4]);
 1295|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[3]);
 1296|  3.85k|   word3_muladd(&w0, &w2, &w1, x[2], x[2]);
 1297|  3.85k|   z[4] = w1;
 1298|  3.85k|   w1 = 0;
 1299|       |
 1300|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[5]);
 1301|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[4]);
 1302|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[3]);
 1303|  3.85k|   z[5] = w2;
 1304|  3.85k|   w2 = 0;
 1305|       |
 1306|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[6]);
 1307|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[5]);
 1308|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[4]);
 1309|  3.85k|   word3_muladd(&w2, &w1, &w0, x[3], x[3]);
 1310|  3.85k|   z[6] = w0;
 1311|  3.85k|   w0 = 0;
 1312|       |
 1313|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[7]);
 1314|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[6]);
 1315|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[5]);
 1316|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[4]);
 1317|  3.85k|   z[7] = w1;
 1318|  3.85k|   w1 = 0;
 1319|       |
 1320|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[8]);
 1321|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[7]);
 1322|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[6]);
 1323|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[5]);
 1324|  3.85k|   word3_muladd(&w1, &w0, &w2, x[4], x[4]);
 1325|  3.85k|   z[8] = w2;
 1326|  3.85k|   w2 = 0;
 1327|       |
 1328|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[9]);
 1329|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[8]);
 1330|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[7]);
 1331|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[6]);
 1332|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[5]);
 1333|  3.85k|   z[9] = w0;
 1334|  3.85k|   w0 = 0;
 1335|       |
 1336|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[10]);
 1337|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[9]);
 1338|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[8]);
 1339|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[7]);
 1340|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[6]);
 1341|  3.85k|   word3_muladd(&w0, &w2, &w1, x[5], x[5]);
 1342|  3.85k|   z[10] = w1;
 1343|  3.85k|   w1 = 0;
 1344|       |
 1345|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[11]);
 1346|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[10]);
 1347|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[9]);
 1348|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[8]);
 1349|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[7]);
 1350|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[6]);
 1351|  3.85k|   z[11] = w2;
 1352|  3.85k|   w2 = 0;
 1353|       |
 1354|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[12]);
 1355|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[11]);
 1356|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[10]);
 1357|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[9]);
 1358|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[8]);
 1359|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[7]);
 1360|  3.85k|   word3_muladd(&w2, &w1, &w0, x[6], x[6]);
 1361|  3.85k|   z[12] = w0;
 1362|  3.85k|   w0 = 0;
 1363|       |
 1364|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[13]);
 1365|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[12]);
 1366|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[11]);
 1367|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[10]);
 1368|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[9]);
 1369|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[8]);
 1370|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[7]);
 1371|  3.85k|   z[13] = w1;
 1372|  3.85k|   w1 = 0;
 1373|       |
 1374|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[14]);
 1375|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[13]);
 1376|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[12]);
 1377|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[11]);
 1378|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[10]);
 1379|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[9]);
 1380|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[8]);
 1381|  3.85k|   word3_muladd(&w1, &w0, &w2, x[7], x[7]);
 1382|  3.85k|   z[14] = w2;
 1383|  3.85k|   w2 = 0;
 1384|       |
 1385|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[15]);
 1386|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[14]);
 1387|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[13]);
 1388|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[12]);
 1389|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[11]);
 1390|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[10]);
 1391|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[9]);
 1392|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[8]);
 1393|  3.85k|   z[15] = w0;
 1394|  3.85k|   w0 = 0;
 1395|       |
 1396|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[16]);
 1397|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[15]);
 1398|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[14]);
 1399|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[13]);
 1400|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[12]);
 1401|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[11]);
 1402|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[10]);
 1403|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[9]);
 1404|  3.85k|   word3_muladd(&w0, &w2, &w1, x[8], x[8]);
 1405|  3.85k|   z[16] = w1;
 1406|  3.85k|   w1 = 0;
 1407|       |
 1408|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[17]);
 1409|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[16]);
 1410|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[15]);
 1411|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[14]);
 1412|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[13]);
 1413|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[12]);
 1414|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[11]);
 1415|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[10]);
 1416|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[9]);
 1417|  3.85k|   z[17] = w2;
 1418|  3.85k|   w2 = 0;
 1419|       |
 1420|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[18]);
 1421|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[17]);
 1422|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[16]);
 1423|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[15]);
 1424|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[14]);
 1425|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[13]);
 1426|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[12]);
 1427|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[11]);
 1428|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[10]);
 1429|  3.85k|   word3_muladd(&w2, &w1, &w0, x[9], x[9]);
 1430|  3.85k|   z[18] = w0;
 1431|  3.85k|   w0 = 0;
 1432|       |
 1433|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[19]);
 1434|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[18]);
 1435|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[17]);
 1436|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[16]);
 1437|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[15]);
 1438|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[14]);
 1439|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[13]);
 1440|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[12]);
 1441|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[11]);
 1442|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[10]);
 1443|  3.85k|   z[19] = w1;
 1444|  3.85k|   w1 = 0;
 1445|       |
 1446|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[20]);
 1447|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[19]);
 1448|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[18]);
 1449|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[17]);
 1450|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[16]);
 1451|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[15]);
 1452|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[14]);
 1453|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[13]);
 1454|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[12]);
 1455|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[11]);
 1456|  3.85k|   word3_muladd(&w1, &w0, &w2, x[10], x[10]);
 1457|  3.85k|   z[20] = w2;
 1458|  3.85k|   w2 = 0;
 1459|       |
 1460|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[0], x[21]);
 1461|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[20]);
 1462|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[19]);
 1463|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[18]);
 1464|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[17]);
 1465|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[16]);
 1466|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[15]);
 1467|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[14]);
 1468|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[13]);
 1469|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[12]);
 1470|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[11]);
 1471|  3.85k|   z[21] = w0;
 1472|  3.85k|   w0 = 0;
 1473|       |
 1474|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[0], x[22]);
 1475|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[1], x[21]);
 1476|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[20]);
 1477|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[19]);
 1478|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[18]);
 1479|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[17]);
 1480|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[16]);
 1481|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[15]);
 1482|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[14]);
 1483|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[13]);
 1484|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[12]);
 1485|  3.85k|   word3_muladd(&w0, &w2, &w1, x[11], x[11]);
 1486|  3.85k|   z[22] = w1;
 1487|  3.85k|   w1 = 0;
 1488|       |
 1489|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[0], x[23]);
 1490|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[1], x[22]);
 1491|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[2], x[21]);
 1492|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[20]);
 1493|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[19]);
 1494|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[18]);
 1495|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[17]);
 1496|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[16]);
 1497|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[15]);
 1498|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[14]);
 1499|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[10], x[13]);
 1500|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[12]);
 1501|  3.85k|   z[23] = w2;
 1502|  3.85k|   w2 = 0;
 1503|       |
 1504|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[1], x[23]);
 1505|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[2], x[22]);
 1506|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[3], x[21]);
 1507|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[20]);
 1508|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[19]);
 1509|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[18]);
 1510|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[17]);
 1511|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[16]);
 1512|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[15]);
 1513|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[14]);
 1514|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[11], x[13]);
 1515|  3.85k|   word3_muladd(&w2, &w1, &w0, x[12], x[12]);
 1516|  3.85k|   z[24] = w0;
 1517|  3.85k|   w0 = 0;
 1518|       |
 1519|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[2], x[23]);
 1520|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[3], x[22]);
 1521|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[4], x[21]);
 1522|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[20]);
 1523|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[19]);
 1524|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[18]);
 1525|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[17]);
 1526|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[16]);
 1527|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[15]);
 1528|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[11], x[14]);
 1529|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[12], x[13]);
 1530|  3.85k|   z[25] = w1;
 1531|  3.85k|   w1 = 0;
 1532|       |
 1533|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[3], x[23]);
 1534|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[4], x[22]);
 1535|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[5], x[21]);
 1536|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[20]);
 1537|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[19]);
 1538|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[18]);
 1539|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[17]);
 1540|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[10], x[16]);
 1541|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[15]);
 1542|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[12], x[14]);
 1543|  3.85k|   word3_muladd(&w1, &w0, &w2, x[13], x[13]);
 1544|  3.85k|   z[26] = w2;
 1545|  3.85k|   w2 = 0;
 1546|       |
 1547|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[4], x[23]);
 1548|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[5], x[22]);
 1549|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[6], x[21]);
 1550|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[20]);
 1551|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[19]);
 1552|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[18]);
 1553|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[17]);
 1554|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[11], x[16]);
 1555|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[12], x[15]);
 1556|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[13], x[14]);
 1557|  3.85k|   z[27] = w0;
 1558|  3.85k|   w0 = 0;
 1559|       |
 1560|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[5], x[23]);
 1561|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[6], x[22]);
 1562|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[7], x[21]);
 1563|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[20]);
 1564|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[19]);
 1565|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[18]);
 1566|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[11], x[17]);
 1567|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[12], x[16]);
 1568|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[13], x[15]);
 1569|  3.85k|   word3_muladd(&w0, &w2, &w1, x[14], x[14]);
 1570|  3.85k|   z[28] = w1;
 1571|  3.85k|   w1 = 0;
 1572|       |
 1573|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[6], x[23]);
 1574|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[7], x[22]);
 1575|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[8], x[21]);
 1576|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[20]);
 1577|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[10], x[19]);
 1578|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[18]);
 1579|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[12], x[17]);
 1580|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[13], x[16]);
 1581|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[14], x[15]);
 1582|  3.85k|   z[29] = w2;
 1583|  3.85k|   w2 = 0;
 1584|       |
 1585|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[7], x[23]);
 1586|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[8], x[22]);
 1587|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[9], x[21]);
 1588|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[20]);
 1589|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[11], x[19]);
 1590|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[12], x[18]);
 1591|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[13], x[17]);
 1592|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[14], x[16]);
 1593|  3.85k|   word3_muladd(&w2, &w1, &w0, x[15], x[15]);
 1594|  3.85k|   z[30] = w0;
 1595|  3.85k|   w0 = 0;
 1596|       |
 1597|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[8], x[23]);
 1598|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[9], x[22]);
 1599|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[10], x[21]);
 1600|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[11], x[20]);
 1601|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[12], x[19]);
 1602|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[13], x[18]);
 1603|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[14], x[17]);
 1604|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[15], x[16]);
 1605|  3.85k|   z[31] = w1;
 1606|  3.85k|   w1 = 0;
 1607|       |
 1608|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[9], x[23]);
 1609|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[10], x[22]);
 1610|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[11], x[21]);
 1611|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[12], x[20]);
 1612|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[13], x[19]);
 1613|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[14], x[18]);
 1614|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[15], x[17]);
 1615|  3.85k|   word3_muladd(&w1, &w0, &w2, x[16], x[16]);
 1616|  3.85k|   z[32] = w2;
 1617|  3.85k|   w2 = 0;
 1618|       |
 1619|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[10], x[23]);
 1620|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[11], x[22]);
 1621|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[12], x[21]);
 1622|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[13], x[20]);
 1623|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[14], x[19]);
 1624|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[15], x[18]);
 1625|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[16], x[17]);
 1626|  3.85k|   z[33] = w0;
 1627|  3.85k|   w0 = 0;
 1628|       |
 1629|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[11], x[23]);
 1630|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[12], x[22]);
 1631|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[13], x[21]);
 1632|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[14], x[20]);
 1633|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[15], x[19]);
 1634|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[16], x[18]);
 1635|  3.85k|   word3_muladd(&w0, &w2, &w1, x[17], x[17]);
 1636|  3.85k|   z[34] = w1;
 1637|  3.85k|   w1 = 0;
 1638|       |
 1639|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[12], x[23]);
 1640|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[13], x[22]);
 1641|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[14], x[21]);
 1642|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[15], x[20]);
 1643|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[16], x[19]);
 1644|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[17], x[18]);
 1645|  3.85k|   z[35] = w2;
 1646|  3.85k|   w2 = 0;
 1647|       |
 1648|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[13], x[23]);
 1649|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[14], x[22]);
 1650|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[15], x[21]);
 1651|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[16], x[20]);
 1652|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[17], x[19]);
 1653|  3.85k|   word3_muladd(&w2, &w1, &w0, x[18], x[18]);
 1654|  3.85k|   z[36] = w0;
 1655|  3.85k|   w0 = 0;
 1656|       |
 1657|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[14], x[23]);
 1658|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[15], x[22]);
 1659|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[16], x[21]);
 1660|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[17], x[20]);
 1661|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[18], x[19]);
 1662|  3.85k|   z[37] = w1;
 1663|  3.85k|   w1 = 0;
 1664|       |
 1665|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[15], x[23]);
 1666|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[16], x[22]);
 1667|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[17], x[21]);
 1668|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[18], x[20]);
 1669|  3.85k|   word3_muladd(&w1, &w0, &w2, x[19], x[19]);
 1670|  3.85k|   z[38] = w2;
 1671|  3.85k|   w2 = 0;
 1672|       |
 1673|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[16], x[23]);
 1674|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[17], x[22]);
 1675|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[18], x[21]);
 1676|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[19], x[20]);
 1677|  3.85k|   z[39] = w0;
 1678|  3.85k|   w0 = 0;
 1679|       |
 1680|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[17], x[23]);
 1681|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[18], x[22]);
 1682|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[19], x[21]);
 1683|  3.85k|   word3_muladd(&w0, &w2, &w1, x[20], x[20]);
 1684|  3.85k|   z[40] = w1;
 1685|  3.85k|   w1 = 0;
 1686|       |
 1687|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[18], x[23]);
 1688|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[19], x[22]);
 1689|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[20], x[21]);
 1690|  3.85k|   z[41] = w2;
 1691|  3.85k|   w2 = 0;
 1692|       |
 1693|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[19], x[23]);
 1694|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[20], x[22]);
 1695|  3.85k|   word3_muladd(&w2, &w1, &w0, x[21], x[21]);
 1696|  3.85k|   z[42] = w0;
 1697|  3.85k|   w0 = 0;
 1698|       |
 1699|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[20], x[23]);
 1700|  3.85k|   word3_muladd_2(&w0, &w2, &w1, x[21], x[22]);
 1701|  3.85k|   z[43] = w1;
 1702|  3.85k|   w1 = 0;
 1703|       |
 1704|  3.85k|   word3_muladd_2(&w1, &w0, &w2, x[21], x[23]);
 1705|  3.85k|   word3_muladd(&w1, &w0, &w2, x[22], x[22]);
 1706|  3.85k|   z[44] = w2;
 1707|  3.85k|   w2 = 0;
 1708|       |
 1709|  3.85k|   word3_muladd_2(&w2, &w1, &w0, x[22], x[23]);
 1710|  3.85k|   z[45] = w0;
 1711|  3.85k|   w0 = 0;
 1712|       |
 1713|  3.85k|   word3_muladd(&w0, &w2, &w1, x[23], x[23]);
 1714|  3.85k|   z[46] = w1;
 1715|  3.85k|   z[47] = w2;
 1716|  3.85k|}
_ZN5Botan18bigint_comba_mul24EPmPKmS2_:
 1721|  1.35k|void bigint_comba_mul24(word z[48], const word x[24], const word y[24]) {
 1722|  1.35k|   word w2 = 0, w1 = 0, w0 = 0;
 1723|       |
 1724|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[0]);
 1725|  1.35k|   z[0] = w0;
 1726|  1.35k|   w0 = 0;
 1727|       |
 1728|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[1]);
 1729|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[0]);
 1730|  1.35k|   z[1] = w1;
 1731|  1.35k|   w1 = 0;
 1732|       |
 1733|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[2]);
 1734|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[1]);
 1735|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[0]);
 1736|  1.35k|   z[2] = w2;
 1737|  1.35k|   w2 = 0;
 1738|       |
 1739|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[3]);
 1740|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[2]);
 1741|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[1]);
 1742|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[0]);
 1743|  1.35k|   z[3] = w0;
 1744|  1.35k|   w0 = 0;
 1745|       |
 1746|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[4]);
 1747|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[3]);
 1748|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[2]);
 1749|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[1]);
 1750|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[0]);
 1751|  1.35k|   z[4] = w1;
 1752|  1.35k|   w1 = 0;
 1753|       |
 1754|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[5]);
 1755|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[4]);
 1756|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[3]);
 1757|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[2]);
 1758|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[1]);
 1759|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[0]);
 1760|  1.35k|   z[5] = w2;
 1761|  1.35k|   w2 = 0;
 1762|       |
 1763|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[6]);
 1764|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[5]);
 1765|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[4]);
 1766|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[3]);
 1767|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[2]);
 1768|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[1]);
 1769|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[0]);
 1770|  1.35k|   z[6] = w0;
 1771|  1.35k|   w0 = 0;
 1772|       |
 1773|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[7]);
 1774|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[6]);
 1775|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[5]);
 1776|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[4]);
 1777|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[3]);
 1778|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[2]);
 1779|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[1]);
 1780|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[0]);
 1781|  1.35k|   z[7] = w1;
 1782|  1.35k|   w1 = 0;
 1783|       |
 1784|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[8]);
 1785|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[7]);
 1786|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[6]);
 1787|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[5]);
 1788|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[4]);
 1789|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[3]);
 1790|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[2]);
 1791|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[1]);
 1792|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[0]);
 1793|  1.35k|   z[8] = w2;
 1794|  1.35k|   w2 = 0;
 1795|       |
 1796|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[9]);
 1797|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[8]);
 1798|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[7]);
 1799|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[6]);
 1800|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[5]);
 1801|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[4]);
 1802|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[3]);
 1803|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[2]);
 1804|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[1]);
 1805|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[0]);
 1806|  1.35k|   z[9] = w0;
 1807|  1.35k|   w0 = 0;
 1808|       |
 1809|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[10]);
 1810|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[9]);
 1811|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[8]);
 1812|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[7]);
 1813|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[6]);
 1814|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[5]);
 1815|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[4]);
 1816|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[3]);
 1817|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[2]);
 1818|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[1]);
 1819|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[0]);
 1820|  1.35k|   z[10] = w1;
 1821|  1.35k|   w1 = 0;
 1822|       |
 1823|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[11]);
 1824|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[10]);
 1825|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[9]);
 1826|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[8]);
 1827|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[7]);
 1828|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[6]);
 1829|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[5]);
 1830|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[4]);
 1831|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[3]);
 1832|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[2]);
 1833|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[1]);
 1834|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[0]);
 1835|  1.35k|   z[11] = w2;
 1836|  1.35k|   w2 = 0;
 1837|       |
 1838|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[12]);
 1839|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[11]);
 1840|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[10]);
 1841|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[9]);
 1842|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[8]);
 1843|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[7]);
 1844|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[6]);
 1845|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[5]);
 1846|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[4]);
 1847|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[3]);
 1848|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[2]);
 1849|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[1]);
 1850|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[0]);
 1851|  1.35k|   z[12] = w0;
 1852|  1.35k|   w0 = 0;
 1853|       |
 1854|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[13]);
 1855|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[12]);
 1856|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[11]);
 1857|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[10]);
 1858|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[9]);
 1859|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[8]);
 1860|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[7]);
 1861|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[6]);
 1862|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[5]);
 1863|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[4]);
 1864|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[3]);
 1865|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[2]);
 1866|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[1]);
 1867|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[0]);
 1868|  1.35k|   z[13] = w1;
 1869|  1.35k|   w1 = 0;
 1870|       |
 1871|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[14]);
 1872|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[13]);
 1873|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[12]);
 1874|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[11]);
 1875|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[10]);
 1876|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[9]);
 1877|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[8]);
 1878|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[7]);
 1879|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[6]);
 1880|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[5]);
 1881|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[4]);
 1882|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[3]);
 1883|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[2]);
 1884|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[1]);
 1885|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[0]);
 1886|  1.35k|   z[14] = w2;
 1887|  1.35k|   w2 = 0;
 1888|       |
 1889|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[15]);
 1890|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[14]);
 1891|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[13]);
 1892|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[12]);
 1893|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[11]);
 1894|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[10]);
 1895|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[9]);
 1896|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[8]);
 1897|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[7]);
 1898|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[6]);
 1899|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[5]);
 1900|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[4]);
 1901|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[3]);
 1902|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[2]);
 1903|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[1]);
 1904|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[0]);
 1905|  1.35k|   z[15] = w0;
 1906|  1.35k|   w0 = 0;
 1907|       |
 1908|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[16]);
 1909|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[15]);
 1910|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[14]);
 1911|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[13]);
 1912|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[12]);
 1913|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[11]);
 1914|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[10]);
 1915|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[9]);
 1916|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[8]);
 1917|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[7]);
 1918|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[6]);
 1919|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[5]);
 1920|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[4]);
 1921|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[3]);
 1922|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[2]);
 1923|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[1]);
 1924|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[0]);
 1925|  1.35k|   z[16] = w1;
 1926|  1.35k|   w1 = 0;
 1927|       |
 1928|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[17]);
 1929|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[16]);
 1930|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[15]);
 1931|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[14]);
 1932|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[13]);
 1933|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[12]);
 1934|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[11]);
 1935|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[10]);
 1936|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[9]);
 1937|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[8]);
 1938|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[7]);
 1939|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[6]);
 1940|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[5]);
 1941|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[4]);
 1942|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[3]);
 1943|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[2]);
 1944|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[1]);
 1945|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[0]);
 1946|  1.35k|   z[17] = w2;
 1947|  1.35k|   w2 = 0;
 1948|       |
 1949|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[18]);
 1950|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[17]);
 1951|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[16]);
 1952|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[15]);
 1953|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[14]);
 1954|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[13]);
 1955|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[12]);
 1956|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[11]);
 1957|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[10]);
 1958|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[9]);
 1959|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[8]);
 1960|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[7]);
 1961|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[6]);
 1962|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[5]);
 1963|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[4]);
 1964|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[3]);
 1965|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[2]);
 1966|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[1]);
 1967|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[0]);
 1968|  1.35k|   z[18] = w0;
 1969|  1.35k|   w0 = 0;
 1970|       |
 1971|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[19]);
 1972|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[18]);
 1973|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[17]);
 1974|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[16]);
 1975|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[15]);
 1976|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[14]);
 1977|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[13]);
 1978|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[12]);
 1979|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[11]);
 1980|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[10]);
 1981|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[9]);
 1982|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[8]);
 1983|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[7]);
 1984|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[6]);
 1985|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[5]);
 1986|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[4]);
 1987|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[3]);
 1988|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[2]);
 1989|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[1]);
 1990|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[0]);
 1991|  1.35k|   z[19] = w1;
 1992|  1.35k|   w1 = 0;
 1993|       |
 1994|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[20]);
 1995|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[19]);
 1996|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[18]);
 1997|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[17]);
 1998|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[16]);
 1999|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[15]);
 2000|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[14]);
 2001|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[13]);
 2002|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[12]);
 2003|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[11]);
 2004|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[10]);
 2005|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[9]);
 2006|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[8]);
 2007|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[7]);
 2008|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[6]);
 2009|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[5]);
 2010|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[4]);
 2011|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[3]);
 2012|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[2]);
 2013|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[1]);
 2014|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[0]);
 2015|  1.35k|   z[20] = w2;
 2016|  1.35k|   w2 = 0;
 2017|       |
 2018|  1.35k|   word3_muladd(&w2, &w1, &w0, x[0], y[21]);
 2019|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[20]);
 2020|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[19]);
 2021|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[18]);
 2022|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[17]);
 2023|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[16]);
 2024|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[15]);
 2025|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[14]);
 2026|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[13]);
 2027|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[12]);
 2028|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[11]);
 2029|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[10]);
 2030|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[9]);
 2031|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[8]);
 2032|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[7]);
 2033|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[6]);
 2034|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[5]);
 2035|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[4]);
 2036|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[3]);
 2037|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[2]);
 2038|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[1]);
 2039|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[0]);
 2040|  1.35k|   z[21] = w0;
 2041|  1.35k|   w0 = 0;
 2042|       |
 2043|  1.35k|   word3_muladd(&w0, &w2, &w1, x[0], y[22]);
 2044|  1.35k|   word3_muladd(&w0, &w2, &w1, x[1], y[21]);
 2045|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[20]);
 2046|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[19]);
 2047|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[18]);
 2048|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[17]);
 2049|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[16]);
 2050|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[15]);
 2051|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[14]);
 2052|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[13]);
 2053|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[12]);
 2054|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[11]);
 2055|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[10]);
 2056|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[9]);
 2057|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[8]);
 2058|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[7]);
 2059|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[6]);
 2060|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[5]);
 2061|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[4]);
 2062|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[3]);
 2063|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[2]);
 2064|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[1]);
 2065|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[0]);
 2066|  1.35k|   z[22] = w1;
 2067|  1.35k|   w1 = 0;
 2068|       |
 2069|  1.35k|   word3_muladd(&w1, &w0, &w2, x[0], y[23]);
 2070|  1.35k|   word3_muladd(&w1, &w0, &w2, x[1], y[22]);
 2071|  1.35k|   word3_muladd(&w1, &w0, &w2, x[2], y[21]);
 2072|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[20]);
 2073|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[19]);
 2074|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[18]);
 2075|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[17]);
 2076|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[16]);
 2077|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[15]);
 2078|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[14]);
 2079|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[13]);
 2080|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[12]);
 2081|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[11]);
 2082|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[10]);
 2083|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[9]);
 2084|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[8]);
 2085|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[7]);
 2086|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[6]);
 2087|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[5]);
 2088|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[4]);
 2089|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[3]);
 2090|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[2]);
 2091|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[1]);
 2092|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[0]);
 2093|  1.35k|   z[23] = w2;
 2094|  1.35k|   w2 = 0;
 2095|       |
 2096|  1.35k|   word3_muladd(&w2, &w1, &w0, x[1], y[23]);
 2097|  1.35k|   word3_muladd(&w2, &w1, &w0, x[2], y[22]);
 2098|  1.35k|   word3_muladd(&w2, &w1, &w0, x[3], y[21]);
 2099|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[20]);
 2100|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[19]);
 2101|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[18]);
 2102|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[17]);
 2103|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[16]);
 2104|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[15]);
 2105|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[14]);
 2106|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[13]);
 2107|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[12]);
 2108|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[11]);
 2109|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[10]);
 2110|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[9]);
 2111|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[8]);
 2112|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[7]);
 2113|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[6]);
 2114|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[5]);
 2115|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[4]);
 2116|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[3]);
 2117|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[2]);
 2118|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[1]);
 2119|  1.35k|   z[24] = w0;
 2120|  1.35k|   w0 = 0;
 2121|       |
 2122|  1.35k|   word3_muladd(&w0, &w2, &w1, x[2], y[23]);
 2123|  1.35k|   word3_muladd(&w0, &w2, &w1, x[3], y[22]);
 2124|  1.35k|   word3_muladd(&w0, &w2, &w1, x[4], y[21]);
 2125|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[20]);
 2126|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[19]);
 2127|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[18]);
 2128|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[17]);
 2129|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[16]);
 2130|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[15]);
 2131|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[14]);
 2132|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[13]);
 2133|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[12]);
 2134|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[11]);
 2135|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[10]);
 2136|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[9]);
 2137|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[8]);
 2138|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[7]);
 2139|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[6]);
 2140|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[5]);
 2141|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[4]);
 2142|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[3]);
 2143|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[2]);
 2144|  1.35k|   z[25] = w1;
 2145|  1.35k|   w1 = 0;
 2146|       |
 2147|  1.35k|   word3_muladd(&w1, &w0, &w2, x[3], y[23]);
 2148|  1.35k|   word3_muladd(&w1, &w0, &w2, x[4], y[22]);
 2149|  1.35k|   word3_muladd(&w1, &w0, &w2, x[5], y[21]);
 2150|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[20]);
 2151|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[19]);
 2152|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[18]);
 2153|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[17]);
 2154|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[16]);
 2155|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[15]);
 2156|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[14]);
 2157|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[13]);
 2158|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[12]);
 2159|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[11]);
 2160|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[10]);
 2161|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[9]);
 2162|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[8]);
 2163|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[7]);
 2164|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[6]);
 2165|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[5]);
 2166|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[4]);
 2167|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[3]);
 2168|  1.35k|   z[26] = w2;
 2169|  1.35k|   w2 = 0;
 2170|       |
 2171|  1.35k|   word3_muladd(&w2, &w1, &w0, x[4], y[23]);
 2172|  1.35k|   word3_muladd(&w2, &w1, &w0, x[5], y[22]);
 2173|  1.35k|   word3_muladd(&w2, &w1, &w0, x[6], y[21]);
 2174|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[20]);
 2175|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[19]);
 2176|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[18]);
 2177|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[17]);
 2178|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[16]);
 2179|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[15]);
 2180|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[14]);
 2181|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[13]);
 2182|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[12]);
 2183|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[11]);
 2184|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[10]);
 2185|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[9]);
 2186|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[8]);
 2187|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[7]);
 2188|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[6]);
 2189|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[5]);
 2190|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[4]);
 2191|  1.35k|   z[27] = w0;
 2192|  1.35k|   w0 = 0;
 2193|       |
 2194|  1.35k|   word3_muladd(&w0, &w2, &w1, x[5], y[23]);
 2195|  1.35k|   word3_muladd(&w0, &w2, &w1, x[6], y[22]);
 2196|  1.35k|   word3_muladd(&w0, &w2, &w1, x[7], y[21]);
 2197|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[20]);
 2198|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[19]);
 2199|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[18]);
 2200|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[17]);
 2201|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[16]);
 2202|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[15]);
 2203|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[14]);
 2204|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[13]);
 2205|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[12]);
 2206|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[11]);
 2207|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[10]);
 2208|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[9]);
 2209|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[8]);
 2210|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[7]);
 2211|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[6]);
 2212|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[5]);
 2213|  1.35k|   z[28] = w1;
 2214|  1.35k|   w1 = 0;
 2215|       |
 2216|  1.35k|   word3_muladd(&w1, &w0, &w2, x[6], y[23]);
 2217|  1.35k|   word3_muladd(&w1, &w0, &w2, x[7], y[22]);
 2218|  1.35k|   word3_muladd(&w1, &w0, &w2, x[8], y[21]);
 2219|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[20]);
 2220|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[19]);
 2221|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[18]);
 2222|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[17]);
 2223|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[16]);
 2224|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[15]);
 2225|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[14]);
 2226|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[13]);
 2227|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[12]);
 2228|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[11]);
 2229|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[10]);
 2230|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[9]);
 2231|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[8]);
 2232|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[7]);
 2233|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[6]);
 2234|  1.35k|   z[29] = w2;
 2235|  1.35k|   w2 = 0;
 2236|       |
 2237|  1.35k|   word3_muladd(&w2, &w1, &w0, x[7], y[23]);
 2238|  1.35k|   word3_muladd(&w2, &w1, &w0, x[8], y[22]);
 2239|  1.35k|   word3_muladd(&w2, &w1, &w0, x[9], y[21]);
 2240|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[20]);
 2241|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[19]);
 2242|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[18]);
 2243|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[17]);
 2244|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[16]);
 2245|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[15]);
 2246|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[14]);
 2247|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[13]);
 2248|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[12]);
 2249|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[11]);
 2250|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[10]);
 2251|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[9]);
 2252|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[8]);
 2253|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[7]);
 2254|  1.35k|   z[30] = w0;
 2255|  1.35k|   w0 = 0;
 2256|       |
 2257|  1.35k|   word3_muladd(&w0, &w2, &w1, x[8], y[23]);
 2258|  1.35k|   word3_muladd(&w0, &w2, &w1, x[9], y[22]);
 2259|  1.35k|   word3_muladd(&w0, &w2, &w1, x[10], y[21]);
 2260|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[20]);
 2261|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[19]);
 2262|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[18]);
 2263|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[17]);
 2264|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[16]);
 2265|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[15]);
 2266|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[14]);
 2267|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[13]);
 2268|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[12]);
 2269|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[11]);
 2270|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[10]);
 2271|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[9]);
 2272|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[8]);
 2273|  1.35k|   z[31] = w1;
 2274|  1.35k|   w1 = 0;
 2275|       |
 2276|  1.35k|   word3_muladd(&w1, &w0, &w2, x[9], y[23]);
 2277|  1.35k|   word3_muladd(&w1, &w0, &w2, x[10], y[22]);
 2278|  1.35k|   word3_muladd(&w1, &w0, &w2, x[11], y[21]);
 2279|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[20]);
 2280|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[19]);
 2281|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[18]);
 2282|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[17]);
 2283|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[16]);
 2284|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[15]);
 2285|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[14]);
 2286|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[13]);
 2287|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[12]);
 2288|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[11]);
 2289|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[10]);
 2290|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[9]);
 2291|  1.35k|   z[32] = w2;
 2292|  1.35k|   w2 = 0;
 2293|       |
 2294|  1.35k|   word3_muladd(&w2, &w1, &w0, x[10], y[23]);
 2295|  1.35k|   word3_muladd(&w2, &w1, &w0, x[11], y[22]);
 2296|  1.35k|   word3_muladd(&w2, &w1, &w0, x[12], y[21]);
 2297|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[20]);
 2298|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[19]);
 2299|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[18]);
 2300|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[17]);
 2301|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[16]);
 2302|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[15]);
 2303|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[14]);
 2304|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[13]);
 2305|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[12]);
 2306|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[11]);
 2307|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[10]);
 2308|  1.35k|   z[33] = w0;
 2309|  1.35k|   w0 = 0;
 2310|       |
 2311|  1.35k|   word3_muladd(&w0, &w2, &w1, x[11], y[23]);
 2312|  1.35k|   word3_muladd(&w0, &w2, &w1, x[12], y[22]);
 2313|  1.35k|   word3_muladd(&w0, &w2, &w1, x[13], y[21]);
 2314|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[20]);
 2315|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[19]);
 2316|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[18]);
 2317|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[17]);
 2318|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[16]);
 2319|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[15]);
 2320|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[14]);
 2321|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[13]);
 2322|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[12]);
 2323|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[11]);
 2324|  1.35k|   z[34] = w1;
 2325|  1.35k|   w1 = 0;
 2326|       |
 2327|  1.35k|   word3_muladd(&w1, &w0, &w2, x[12], y[23]);
 2328|  1.35k|   word3_muladd(&w1, &w0, &w2, x[13], y[22]);
 2329|  1.35k|   word3_muladd(&w1, &w0, &w2, x[14], y[21]);
 2330|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[20]);
 2331|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[19]);
 2332|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[18]);
 2333|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[17]);
 2334|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[16]);
 2335|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[15]);
 2336|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[14]);
 2337|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[13]);
 2338|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[12]);
 2339|  1.35k|   z[35] = w2;
 2340|  1.35k|   w2 = 0;
 2341|       |
 2342|  1.35k|   word3_muladd(&w2, &w1, &w0, x[13], y[23]);
 2343|  1.35k|   word3_muladd(&w2, &w1, &w0, x[14], y[22]);
 2344|  1.35k|   word3_muladd(&w2, &w1, &w0, x[15], y[21]);
 2345|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[20]);
 2346|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[19]);
 2347|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[18]);
 2348|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[17]);
 2349|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[16]);
 2350|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[15]);
 2351|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[14]);
 2352|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[13]);
 2353|  1.35k|   z[36] = w0;
 2354|  1.35k|   w0 = 0;
 2355|       |
 2356|  1.35k|   word3_muladd(&w0, &w2, &w1, x[14], y[23]);
 2357|  1.35k|   word3_muladd(&w0, &w2, &w1, x[15], y[22]);
 2358|  1.35k|   word3_muladd(&w0, &w2, &w1, x[16], y[21]);
 2359|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[20]);
 2360|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[19]);
 2361|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[18]);
 2362|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[17]);
 2363|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[16]);
 2364|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[15]);
 2365|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[14]);
 2366|  1.35k|   z[37] = w1;
 2367|  1.35k|   w1 = 0;
 2368|       |
 2369|  1.35k|   word3_muladd(&w1, &w0, &w2, x[15], y[23]);
 2370|  1.35k|   word3_muladd(&w1, &w0, &w2, x[16], y[22]);
 2371|  1.35k|   word3_muladd(&w1, &w0, &w2, x[17], y[21]);
 2372|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[20]);
 2373|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[19]);
 2374|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[18]);
 2375|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[17]);
 2376|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[16]);
 2377|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[15]);
 2378|  1.35k|   z[38] = w2;
 2379|  1.35k|   w2 = 0;
 2380|       |
 2381|  1.35k|   word3_muladd(&w2, &w1, &w0, x[16], y[23]);
 2382|  1.35k|   word3_muladd(&w2, &w1, &w0, x[17], y[22]);
 2383|  1.35k|   word3_muladd(&w2, &w1, &w0, x[18], y[21]);
 2384|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[20]);
 2385|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[19]);
 2386|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[18]);
 2387|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[17]);
 2388|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[16]);
 2389|  1.35k|   z[39] = w0;
 2390|  1.35k|   w0 = 0;
 2391|       |
 2392|  1.35k|   word3_muladd(&w0, &w2, &w1, x[17], y[23]);
 2393|  1.35k|   word3_muladd(&w0, &w2, &w1, x[18], y[22]);
 2394|  1.35k|   word3_muladd(&w0, &w2, &w1, x[19], y[21]);
 2395|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[20]);
 2396|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[19]);
 2397|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[18]);
 2398|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[17]);
 2399|  1.35k|   z[40] = w1;
 2400|  1.35k|   w1 = 0;
 2401|       |
 2402|  1.35k|   word3_muladd(&w1, &w0, &w2, x[18], y[23]);
 2403|  1.35k|   word3_muladd(&w1, &w0, &w2, x[19], y[22]);
 2404|  1.35k|   word3_muladd(&w1, &w0, &w2, x[20], y[21]);
 2405|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[20]);
 2406|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[19]);
 2407|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[18]);
 2408|  1.35k|   z[41] = w2;
 2409|  1.35k|   w2 = 0;
 2410|       |
 2411|  1.35k|   word3_muladd(&w2, &w1, &w0, x[19], y[23]);
 2412|  1.35k|   word3_muladd(&w2, &w1, &w0, x[20], y[22]);
 2413|  1.35k|   word3_muladd(&w2, &w1, &w0, x[21], y[21]);
 2414|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[20]);
 2415|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[19]);
 2416|  1.35k|   z[42] = w0;
 2417|  1.35k|   w0 = 0;
 2418|       |
 2419|  1.35k|   word3_muladd(&w0, &w2, &w1, x[20], y[23]);
 2420|  1.35k|   word3_muladd(&w0, &w2, &w1, x[21], y[22]);
 2421|  1.35k|   word3_muladd(&w0, &w2, &w1, x[22], y[21]);
 2422|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[20]);
 2423|  1.35k|   z[43] = w1;
 2424|  1.35k|   w1 = 0;
 2425|       |
 2426|  1.35k|   word3_muladd(&w1, &w0, &w2, x[21], y[23]);
 2427|  1.35k|   word3_muladd(&w1, &w0, &w2, x[22], y[22]);
 2428|  1.35k|   word3_muladd(&w1, &w0, &w2, x[23], y[21]);
 2429|  1.35k|   z[44] = w2;
 2430|  1.35k|   w2 = 0;
 2431|       |
 2432|  1.35k|   word3_muladd(&w2, &w1, &w0, x[22], y[23]);
 2433|  1.35k|   word3_muladd(&w2, &w1, &w0, x[23], y[22]);
 2434|  1.35k|   z[45] = w0;
 2435|  1.35k|   w0 = 0;
 2436|       |
 2437|  1.35k|   word3_muladd(&w0, &w2, &w1, x[23], y[23]);
 2438|  1.35k|   z[46] = w1;
 2439|  1.35k|   z[47] = w2;
 2440|  1.35k|}

_ZN5Botan12basecase_mulEPmmPKmmS2_m:
   20|  55.0k|void basecase_mul(word z[], size_t z_size, const word x[], size_t x_size, const word y[], size_t y_size) {
   21|  55.0k|   if(z_size < x_size + y_size) {
  ------------------
  |  Branch (21:7): [True: 0, False: 55.0k]
  ------------------
   22|      0|      throw Invalid_Argument("basecase_mul z_size too small");
   23|      0|   }
   24|       |
   25|  55.0k|   const size_t x_size_8 = x_size - (x_size % 8);
   26|       |
   27|  55.0k|   clear_mem(z, z_size);
   28|       |
   29|   822k|   for(size_t i = 0; i != y_size; ++i) {
  ------------------
  |  Branch (29:22): [True: 767k, False: 55.0k]
  ------------------
   30|   767k|      const word y_i = y[i];
   31|       |
   32|   767k|      word carry = 0;
   33|       |
   34|  2.30M|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (34:25): [True: 1.54M, False: 767k]
  ------------------
   35|  1.54M|         carry = word8_madd3(z + i + j, x + j, y_i, carry);
   36|  1.54M|      }
   37|       |
   38|  3.69M|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (38:32): [True: 2.92M, False: 767k]
  ------------------
   39|  2.92M|         z[i + j] = word_madd3(x[j], y_i, z[i + j], &carry);
   40|  2.92M|      }
   41|       |
   42|   767k|      z[x_size + i] = carry;
   43|   767k|   }
   44|  55.0k|}
_ZN5Botan12basecase_sqrEPmmPKmm:
   46|   127k|void basecase_sqr(word z[], size_t z_size, const word x[], size_t x_size) {
   47|   127k|   if(z_size < 2 * x_size) {
  ------------------
  |  Branch (47:7): [True: 0, False: 127k]
  ------------------
   48|      0|      throw Invalid_Argument("basecase_sqr z_size too small");
   49|      0|   }
   50|       |
   51|   127k|   const size_t x_size_8 = x_size - (x_size % 8);
   52|       |
   53|   127k|   clear_mem(z, z_size);
   54|       |
   55|  1.73M|   for(size_t i = 0; i != x_size; ++i) {
  ------------------
  |  Branch (55:22): [True: 1.60M, False: 127k]
  ------------------
   56|  1.60M|      const word x_i = x[i];
   57|       |
   58|  1.60M|      word carry = 0;
   59|       |
   60|  4.83M|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (60:25): [True: 3.22M, False: 1.60M]
  ------------------
   61|  3.22M|         carry = word8_madd3(z + i + j, x + j, x_i, carry);
   62|  3.22M|      }
   63|       |
   64|  8.47M|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (64:32): [True: 6.87M, False: 1.60M]
  ------------------
   65|  6.87M|         z[i + j] = word_madd3(x[j], x_i, z[i + j], &carry);
   66|  6.87M|      }
   67|       |
   68|  1.60M|      z[x_size + i] = carry;
   69|  1.60M|   }
   70|   127k|}
_ZN5Botan10bigint_mulEPmmPKmmmS2_mmS0_m:
  291|   126k|                size_t ws_size) {
  292|   126k|   clear_mem(z, z_size);
  293|       |
  294|   126k|   if(x_sw == 1) {
  ------------------
  |  Branch (294:7): [True: 23.0k, False: 103k]
  ------------------
  295|  23.0k|      bigint_linmul3(z, y, y_sw, x[0]);
  296|   103k|   } else if(y_sw == 1) {
  ------------------
  |  Branch (296:14): [True: 6, False: 103k]
  ------------------
  297|      6|      bigint_linmul3(z, x, x_sw, y[0]);
  298|   103k|   } else if(sized_for_comba_mul<4>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (298:14): [True: 8.96k, False: 94.3k]
  ------------------
  299|  8.96k|      bigint_comba_mul4(z, x, y);
  300|  94.3k|   } else if(sized_for_comba_mul<6>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (300:14): [True: 4.65k, False: 89.6k]
  ------------------
  301|  4.65k|      bigint_comba_mul6(z, x, y);
  302|  89.6k|   } else if(sized_for_comba_mul<8>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (302:14): [True: 10.7k, False: 78.8k]
  ------------------
  303|  10.7k|      bigint_comba_mul8(z, x, y);
  304|  78.8k|   } else if(sized_for_comba_mul<9>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (304:14): [True: 3.30k, False: 75.5k]
  ------------------
  305|  3.30k|      bigint_comba_mul9(z, x, y);
  306|  75.5k|   } else if(sized_for_comba_mul<16>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (306:14): [True: 15.6k, False: 59.9k]
  ------------------
  307|  15.6k|      bigint_comba_mul16(z, x, y);
  308|  59.9k|   } else if(sized_for_comba_mul<24>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (308:14): [True: 1.35k, False: 58.6k]
  ------------------
  309|  1.35k|      bigint_comba_mul24(z, x, y);
  310|  58.6k|   } else if(x_sw < KARATSUBA_MULTIPLY_THRESHOLD || y_sw < KARATSUBA_MULTIPLY_THRESHOLD || !workspace) {
  ------------------
  |  Branch (310:14): [True: 51.1k, False: 7.49k]
  |  Branch (310:53): [True: 19, False: 7.47k]
  |  Branch (310:92): [True: 0, False: 7.47k]
  ------------------
  311|  51.1k|      basecase_mul(z, z_size, x, x_sw, y, y_sw);
  312|  51.1k|   } else {
  313|  7.47k|      const size_t N = karatsuba_size(z_size, x_size, x_sw, y_size, y_sw);
  314|       |
  315|  7.47k|      if(N && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (315:10): [True: 4.76k, False: 2.71k]
  |  Branch (315:15): [True: 4.76k, False: 0]
  |  Branch (315:34): [True: 4.76k, False: 0]
  ------------------
  316|  4.76k|         karatsuba_mul(z, x, y, N, workspace);
  317|  4.76k|      } else {
  318|  2.71k|         basecase_mul(z, z_size, x, x_sw, y, y_sw);
  319|  2.71k|      }
  320|  7.47k|   }
  321|   126k|}
_ZN5Botan10bigint_sqrEPmmPKmmmS0_m:
  326|   331k|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) {
  327|   331k|   clear_mem(z, z_size);
  328|       |
  329|   331k|   BOTAN_ASSERT(z_size / 2 >= x_sw, "Output size is sufficient");
  ------------------
  |  |   51|   331k|   do {                                                                                 \
  |  |   52|   331k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 331k]
  |  |  ------------------
  |  |   53|   331k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|   331k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  330|       |
  331|   331k|   if(x_sw == 1) {
  ------------------
  |  Branch (331:7): [True: 71.1k, False: 260k]
  ------------------
  332|  71.1k|      bigint_linmul3(z, x, x_sw, x[0]);
  333|   260k|   } else if(sized_for_comba_sqr<4>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (333:14): [True: 23.7k, False: 236k]
  ------------------
  334|  23.7k|      bigint_comba_sqr4(z, x);
  335|   236k|   } else if(sized_for_comba_sqr<6>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (335:14): [True: 11.7k, False: 224k]
  ------------------
  336|  11.7k|      bigint_comba_sqr6(z, x);
  337|   224k|   } else if(sized_for_comba_sqr<8>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (337:14): [True: 35.3k, False: 189k]
  ------------------
  338|  35.3k|      bigint_comba_sqr8(z, x);
  339|   189k|   } else if(sized_for_comba_sqr<9>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (339:14): [True: 9.60k, False: 180k]
  ------------------
  340|  9.60k|      bigint_comba_sqr9(z, x);
  341|   180k|   } else if(sized_for_comba_sqr<16>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (341:14): [True: 42.7k, False: 137k]
  ------------------
  342|  42.7k|      bigint_comba_sqr16(z, x);
  343|   137k|   } else if(sized_for_comba_sqr<24>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (343:14): [True: 3.85k, False: 133k]
  ------------------
  344|  3.85k|      bigint_comba_sqr24(z, x);
  345|   133k|   } else if(x_size < KARATSUBA_SQUARE_THRESHOLD || !workspace) {
  ------------------
  |  Branch (345:14): [True: 60.9k, False: 72.5k]
  |  Branch (345:53): [True: 0, False: 72.5k]
  ------------------
  346|  60.9k|      basecase_sqr(z, z_size, x, x_sw);
  347|  72.5k|   } else {
  348|  72.5k|      const size_t N = karatsuba_size(z_size, x_size, x_sw);
  349|       |
  350|  72.5k|      if(N && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (350:10): [True: 41.1k, False: 31.3k]
  |  Branch (350:15): [True: 41.1k, False: 0]
  |  Branch (350:34): [True: 41.1k, False: 0]
  ------------------
  351|  41.1k|         karatsuba_sqr(z, x, N, workspace);
  352|  41.1k|      } else {
  353|  31.3k|         basecase_sqr(z, z_size, x, x_sw);
  354|  31.3k|      }
  355|  72.5k|   }
  356|   331k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmmmm:
  202|  7.47k|size_t karatsuba_size(size_t z_size, size_t x_size, size_t x_sw, size_t y_size, size_t y_sw) {
  203|  7.47k|   if(x_sw > x_size || x_sw > y_size || y_sw > x_size || y_sw > y_size) {
  ------------------
  |  Branch (203:7): [True: 0, False: 7.47k]
  |  Branch (203:24): [True: 0, False: 7.47k]
  |  Branch (203:41): [True: 50, False: 7.42k]
  |  Branch (203:58): [True: 0, False: 7.42k]
  ------------------
  204|     50|      return 0;
  205|     50|   }
  206|       |
  207|  7.42k|   if(((x_size == x_sw) && (x_size % 2)) || ((y_size == y_sw) && (y_size % 2))) {
  ------------------
  |  Branch (207:8): [True: 45, False: 7.38k]
  |  Branch (207:28): [True: 0, False: 45]
  |  Branch (207:46): [True: 114, False: 7.31k]
  |  Branch (207:66): [True: 0, False: 114]
  ------------------
  208|      0|      return 0;
  209|      0|   }
  210|       |
  211|  7.42k|   const size_t start = (x_sw > y_sw) ? x_sw : y_sw;
  ------------------
  |  Branch (211:25): [True: 47, False: 7.38k]
  ------------------
  212|  7.42k|   const size_t end = (x_size < y_size) ? x_size : y_size;
  ------------------
  |  Branch (212:23): [True: 482, False: 6.94k]
  ------------------
  213|       |
  214|  7.42k|   if(start == end) {
  ------------------
  |  Branch (214:7): [True: 159, False: 7.26k]
  ------------------
  215|    159|      if(start % 2) {
  ------------------
  |  Branch (215:10): [True: 0, False: 159]
  ------------------
  216|      0|         return 0;
  217|      0|      }
  218|    159|      return start;
  219|    159|   }
  220|       |
  221|  9.98k|   for(size_t j = start; j <= end; ++j) {
  ------------------
  |  Branch (221:26): [True: 9.98k, False: 0]
  ------------------
  222|  9.98k|      if(j % 2) {
  ------------------
  |  Branch (222:10): [True: 2.71k, False: 7.26k]
  ------------------
  223|  2.71k|         continue;
  224|  2.71k|      }
  225|       |
  226|  7.26k|      if(2 * j > z_size) {
  ------------------
  |  Branch (226:10): [True: 2.66k, False: 4.60k]
  ------------------
  227|  2.66k|         return 0;
  228|  2.66k|      }
  229|       |
  230|  4.60k|      if(x_sw <= j && j <= x_size && y_sw <= j && j <= y_size) {
  ------------------
  |  Branch (230:10): [True: 4.60k, False: 0]
  |  Branch (230:23): [True: 4.60k, False: 0]
  |  Branch (230:38): [True: 4.60k, False: 0]
  |  Branch (230:51): [True: 4.60k, False: 0]
  ------------------
  231|  4.60k|         if(j % 4 == 2 && (j + 2) <= x_size && (j + 2) <= y_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (231:13): [True: 394, False: 4.21k]
  |  Branch (231:27): [True: 394, False: 0]
  |  Branch (231:48): [True: 394, False: 0]
  |  Branch (231:69): [True: 149, False: 245]
  ------------------
  232|    149|            return j + 2;
  233|    149|         }
  234|  4.45k|         return j;
  235|  4.60k|      }
  236|  4.60k|   }
  237|       |
  238|      0|   return 0;
  239|  7.26k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_mulEPmPKmS3_mS1_:
   80|  19.0k|void karatsuba_mul(word z[], const word x[], const word y[], size_t N, word workspace[]) {
   81|  19.0k|   if(N < KARATSUBA_MULTIPLY_THRESHOLD || N % 2) {
  ------------------
  |  Branch (81:7): [True: 14.2k, False: 4.76k]
  |  Branch (81:43): [True: 0, False: 4.76k]
  ------------------
   82|  14.2k|      switch(N) {
   83|      0|         case 6:
  ------------------
  |  Branch (83:10): [True: 0, False: 14.2k]
  ------------------
   84|      0|            return bigint_comba_mul6(z, x, y);
   85|      0|         case 8:
  ------------------
  |  Branch (85:10): [True: 0, False: 14.2k]
  ------------------
   86|      0|            return bigint_comba_mul8(z, x, y);
   87|      0|         case 9:
  ------------------
  |  Branch (87:10): [True: 0, False: 14.2k]
  ------------------
   88|      0|            return bigint_comba_mul9(z, x, y);
   89|  13.1k|         case 16:
  ------------------
  |  Branch (89:10): [True: 13.1k, False: 1.18k]
  ------------------
   90|  13.1k|            return bigint_comba_mul16(z, x, y);
   91|      0|         case 24:
  ------------------
  |  Branch (91:10): [True: 0, False: 14.2k]
  ------------------
   92|      0|            return bigint_comba_mul24(z, x, y);
   93|  1.18k|         default:
  ------------------
  |  Branch (93:10): [True: 1.18k, False: 13.1k]
  ------------------
   94|  1.18k|            return basecase_mul(z, 2 * N, x, N, y, N);
   95|  14.2k|      }
   96|  14.2k|   }
   97|       |
   98|  4.76k|   const size_t N2 = N / 2;
   99|       |
  100|  4.76k|   const word* x0 = x;
  101|  4.76k|   const word* x1 = x + N2;
  102|  4.76k|   const word* y0 = y;
  103|  4.76k|   const word* y1 = y + N2;
  104|  4.76k|   word* z0 = z;
  105|  4.76k|   word* z1 = z + N;
  106|       |
  107|  4.76k|   word* ws0 = workspace;
  108|  4.76k|   word* ws1 = workspace + N;
  109|       |
  110|  4.76k|   clear_mem(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, clear_mem 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|  4.76k|   const auto cmp0 = bigint_sub_abs(z0, x0, x1, N2, workspace);
  123|  4.76k|   const auto cmp1 = bigint_sub_abs(z1, y1, y0, N2, workspace);
  124|  4.76k|   const auto neg_mask = ~(cmp0 ^ cmp1);
  125|       |
  126|  4.76k|   karatsuba_mul(ws0, z0, z1, N2, ws1);
  127|       |
  128|       |   // Compute X_lo * Y_lo
  129|  4.76k|   karatsuba_mul(z0, x0, y0, N2, ws1);
  130|       |
  131|       |   // Compute X_hi * Y_hi
  132|  4.76k|   karatsuba_mul(z1, x1, y1, N2, ws1);
  133|       |
  134|  4.76k|   const word ws_carry = bigint_add3_nc(ws1, z0, N, z1, N);
  135|  4.76k|   word z_carry = bigint_add2_nc(z + N2, N, ws1, N);
  136|       |
  137|  4.76k|   z_carry += bigint_add2_nc(z + N + N2, N2, &ws_carry, 1);
  138|  4.76k|   bigint_add2_nc(z + N + N2, N2, &z_carry, 1);
  139|       |
  140|  4.76k|   clear_mem(workspace + N, N2);
  141|       |
  142|  4.76k|   bigint_cnd_add_or_sub(neg_mask, z + N2, workspace, 2 * N - N2);
  143|  4.76k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmm:
  244|  72.5k|size_t karatsuba_size(size_t z_size, size_t x_size, size_t x_sw) {
  245|  72.5k|   if(x_sw == x_size) {
  ------------------
  |  Branch (245:7): [True: 0, False: 72.5k]
  ------------------
  246|      0|      if(x_sw % 2) {
  ------------------
  |  Branch (246:10): [True: 0, False: 0]
  ------------------
  247|      0|         return 0;
  248|      0|      }
  249|      0|      return x_sw;
  250|      0|   }
  251|       |
  252|   103k|   for(size_t j = x_sw; j <= x_size; ++j) {
  ------------------
  |  Branch (252:25): [True: 103k, False: 0]
  ------------------
  253|   103k|      if(j % 2) {
  ------------------
  |  Branch (253:10): [True: 31.3k, False: 72.5k]
  ------------------
  254|  31.3k|         continue;
  255|  31.3k|      }
  256|       |
  257|  72.5k|      if(2 * j > z_size) {
  ------------------
  |  Branch (257:10): [True: 31.3k, False: 41.1k]
  ------------------
  258|  31.3k|         return 0;
  259|  31.3k|      }
  260|       |
  261|  41.1k|      if(j % 4 == 2 && (j + 2) <= x_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (261:10): [True: 10.6k, False: 30.4k]
  |  Branch (261:24): [True: 10.6k, False: 0]
  |  Branch (261:45): [True: 0, False: 10.6k]
  ------------------
  262|      0|         return j + 2;
  263|      0|      }
  264|  41.1k|      return j;
  265|  41.1k|   }
  266|       |
  267|      0|   return 0;
  268|  72.5k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_sqrEPmPKmmS1_:
  148|  59.8k|void karatsuba_sqr(word z[], const word x[], size_t N, word workspace[]) {
  149|  59.8k|   if(N < KARATSUBA_SQUARE_THRESHOLD || N % 2) {
  ------------------
  |  Branch (149:7): [True: 53.5k, False: 6.23k]
  |  Branch (149:41): [True: 0, False: 6.23k]
  ------------------
  150|  53.5k|      switch(N) {
  151|      0|         case 6:
  ------------------
  |  Branch (151:10): [True: 0, False: 53.5k]
  ------------------
  152|      0|            return bigint_comba_sqr6(z, x);
  153|      0|         case 8:
  ------------------
  |  Branch (153:10): [True: 0, False: 53.5k]
  ------------------
  154|      0|            return bigint_comba_sqr8(z, x);
  155|      0|         case 9:
  ------------------
  |  Branch (155:10): [True: 0, False: 53.5k]
  ------------------
  156|      0|            return bigint_comba_sqr9(z, x);
  157|  18.7k|         case 16:
  ------------------
  |  Branch (157:10): [True: 18.7k, False: 34.8k]
  ------------------
  158|  18.7k|            return bigint_comba_sqr16(z, x);
  159|      0|         case 24:
  ------------------
  |  Branch (159:10): [True: 0, False: 53.5k]
  ------------------
  160|      0|            return bigint_comba_sqr24(z, x);
  161|  34.8k|         default:
  ------------------
  |  Branch (161:10): [True: 34.8k, False: 18.7k]
  ------------------
  162|  34.8k|            return basecase_sqr(z, 2 * N, x, N);
  163|  53.5k|      }
  164|  53.5k|   }
  165|       |
  166|  6.23k|   const size_t N2 = N / 2;
  167|       |
  168|  6.23k|   const word* x0 = x;
  169|  6.23k|   const word* x1 = x + N2;
  170|  6.23k|   word* z0 = z;
  171|  6.23k|   word* z1 = z + N;
  172|       |
  173|  6.23k|   word* ws0 = workspace;
  174|  6.23k|   word* ws1 = workspace + N;
  175|       |
  176|  6.23k|   clear_mem(workspace, 2 * N);
  177|       |
  178|       |   // See comment in karatsuba_mul
  179|  6.23k|   bigint_sub_abs(z0, x0, x1, N2, workspace);
  180|  6.23k|   karatsuba_sqr(ws0, z0, N2, ws1);
  181|       |
  182|  6.23k|   karatsuba_sqr(z0, x0, N2, ws1);
  183|  6.23k|   karatsuba_sqr(z1, x1, N2, ws1);
  184|       |
  185|  6.23k|   const word ws_carry = bigint_add3_nc(ws1, z0, N, z1, N);
  186|  6.23k|   word z_carry = bigint_add2_nc(z + N2, N, ws1, N);
  187|       |
  188|  6.23k|   z_carry += bigint_add2_nc(z + N + N2, N2, &ws_carry, 1);
  189|  6.23k|   bigint_add2_nc(z + N + N2, N2, &z_carry, 1);
  190|       |
  191|       |   /*
  192|       |   * This is only actually required if cmp (result of bigint_sub_abs) is != 0,
  193|       |   * however if cmp==0 then ws0[0:N] == 0 and avoiding the jump hides a
  194|       |   * timing channel.
  195|       |   */
  196|  6.23k|   bigint_sub2(z + N2, 2 * N - N2, ws0, N);
  197|  6.23k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm4EEEbmmmmm:
  271|   103k|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) {
  272|   103k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 22.0k, False: 81.2k]
  |  Branch (272:26): [True: 21.8k, False: 139]
  |  Branch (272:42): [True: 20.2k, False: 1.63k]
  |  Branch (272:56): [True: 20.2k, False: 0]
  |  Branch (272:72): [True: 8.96k, False: 11.2k]
  ------------------
  273|   103k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm6EEEbmmmmm:
  271|  94.3k|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) {
  272|  94.3k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 28.1k, False: 66.1k]
  |  Branch (272:26): [True: 28.0k, False: 167]
  |  Branch (272:42): [True: 26.6k, False: 1.39k]
  |  Branch (272:56): [True: 26.6k, False: 0]
  |  Branch (272:72): [True: 4.65k, False: 21.9k]
  ------------------
  273|  94.3k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm8EEEbmmmmm:
  271|  89.6k|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) {
  272|  89.6k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 37.5k, False: 52.1k]
  |  Branch (272:26): [True: 37.3k, False: 223]
  |  Branch (272:42): [True: 35.1k, False: 2.16k]
  |  Branch (272:56): [True: 35.1k, False: 0]
  |  Branch (272:72): [True: 10.7k, False: 24.3k]
  ------------------
  273|  89.6k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm9EEEbmmmmm:
  271|  78.8k|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) {
  272|  78.8k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 30.1k, False: 48.7k]
  |  Branch (272:26): [True: 20.9k, False: 9.19k]
  |  Branch (272:42): [True: 19.5k, False: 1.36k]
  |  Branch (272:56): [True: 19.2k, False: 331]
  |  Branch (272:72): [True: 3.30k, False: 15.9k]
  ------------------
  273|  78.8k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm16EEEbmmmmm:
  271|  75.5k|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) {
  272|  75.5k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 54.4k, False: 21.1k]
  |  Branch (272:26): [True: 45.0k, False: 9.42k]
  |  Branch (272:42): [True: 43.4k, False: 1.64k]
  |  Branch (272:56): [True: 43.2k, False: 138]
  |  Branch (272:72): [True: 15.6k, False: 27.6k]
  ------------------
  273|  75.5k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm24EEEbmmmmm:
  271|  59.9k|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) {
  272|  59.9k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 42.5k, False: 17.3k]
  |  Branch (272:26): [True: 19.5k, False: 23.0k]
  |  Branch (272:42): [True: 17.9k, False: 1.61k]
  |  Branch (272:56): [True: 17.6k, False: 313]
  |  Branch (272:72): [True: 1.35k, False: 16.3k]
  ------------------
  273|  59.9k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm4EEEbmmm:
  276|   260k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   260k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 52.8k, False: 207k]
  |  Branch (277:26): [True: 52.8k, False: 0]
  |  Branch (277:42): [True: 23.7k, False: 29.0k]
  ------------------
  278|   260k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm6EEEbmmm:
  276|   236k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   236k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 64.4k, False: 172k]
  |  Branch (277:26): [True: 64.4k, False: 0]
  |  Branch (277:42): [True: 11.7k, False: 52.6k]
  ------------------
  278|   236k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm8EEEbmmm:
  276|   224k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   224k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 95.0k, False: 129k]
  |  Branch (277:26): [True: 95.0k, False: 0]
  |  Branch (277:42): [True: 35.3k, False: 59.7k]
  ------------------
  278|   224k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm9EEEbmmm:
  276|   189k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   189k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 69.3k, False: 120k]
  |  Branch (277:26): [True: 48.7k, False: 20.6k]
  |  Branch (277:42): [True: 9.60k, False: 39.1k]
  ------------------
  278|   189k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm16EEEbmmm:
  276|   180k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   180k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 134k, False: 45.7k]
  |  Branch (277:26): [True: 113k, False: 20.6k]
  |  Branch (277:42): [True: 42.7k, False: 70.9k]
  ------------------
  278|   180k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm24EEEbmmm:
  276|   137k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   137k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 103k, False: 34.1k]
  |  Branch (277:26): [True: 50.5k, False: 52.6k]
  |  Branch (277:42): [True: 3.85k, False: 46.6k]
  ------------------
  278|   137k|}

_ZN5Botan25bigint_monty_redc_genericEPmmPKmmmS0_:
   31|   282k|void bigint_monty_redc_generic(word z[], size_t z_size, const word p[], size_t p_size, word p_dash, word ws[]) {
   32|   282k|   BOTAN_ARG_CHECK(z_size >= 2 * p_size && p_size > 0, "Invalid sizes for bigint_monty_redc_generic");
  ------------------
  |  |   30|   282k|   do {                                                          \
  |  |   31|   565k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 282k, False: 0]
  |  |  |  Branch (31:12): [True: 282k, False: 0]
  |  |  ------------------
  |  |   32|   282k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|   282k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   33|       |
   34|   282k|   word w2 = 0, w1 = 0, w0 = 0;
   35|       |
   36|   282k|   w0 = z[0];
   37|       |
   38|   282k|   ws[0] = w0 * p_dash;
   39|       |
   40|   282k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
   41|       |
   42|   282k|   w0 = w1;
   43|   282k|   w1 = w2;
   44|   282k|   w2 = 0;
   45|       |
   46|  2.43M|   for(size_t i = 1; i != p_size; ++i) {
  ------------------
  |  Branch (46:22): [True: 2.15M, False: 282k]
  ------------------
   47|  24.3M|      for(size_t j = 0; j < i; ++j) {
  ------------------
  |  Branch (47:25): [True: 22.1M, False: 2.15M]
  ------------------
   48|  22.1M|         word3_muladd(&w2, &w1, &w0, ws[j], p[i - j]);
   49|  22.1M|      }
   50|       |
   51|  2.15M|      word3_add(&w2, &w1, &w0, z[i]);
   52|       |
   53|  2.15M|      ws[i] = w0 * p_dash;
   54|       |
   55|  2.15M|      word3_muladd(&w2, &w1, &w0, ws[i], p[0]);
   56|       |
   57|  2.15M|      w0 = w1;
   58|  2.15M|      w1 = w2;
   59|  2.15M|      w2 = 0;
   60|  2.15M|   }
   61|       |
   62|  2.43M|   for(size_t i = 0; i != p_size - 1; ++i) {
  ------------------
  |  Branch (62:22): [True: 2.15M, False: 282k]
  ------------------
   63|  24.3M|      for(size_t j = i + 1; j != p_size; ++j) {
  ------------------
  |  Branch (63:29): [True: 22.1M, False: 2.15M]
  ------------------
   64|  22.1M|         word3_muladd(&w2, &w1, &w0, ws[j], p[p_size + i - j]);
   65|  22.1M|      }
   66|       |
   67|  2.15M|      word3_add(&w2, &w1, &w0, z[p_size + i]);
   68|       |
   69|  2.15M|      ws[i] = w0;
   70|       |
   71|  2.15M|      w0 = w1;
   72|  2.15M|      w1 = w2;
   73|  2.15M|      w2 = 0;
   74|  2.15M|   }
   75|       |
   76|   282k|   word3_add(&w2, &w1, &w0, z[2 * p_size - 1]);
   77|       |
   78|   282k|   ws[p_size - 1] = w0;
   79|   282k|   ws[p_size] = w1;
   80|       |
   81|       |   /*
   82|       |   * The result might need to be reduced mod p. To avoid a timing
   83|       |   * channel, always perform the subtraction. If in the compution
   84|       |   * of x - p a borrow is required then x was already < p.
   85|       |   *
   86|       |   * x starts at ws[0] and is p_size+1 bytes long.
   87|       |   * x - p starts at z[0] and is also p_size+1 bytes log
   88|       |   *
   89|       |   * If borrow was set then x was already < p and the subtraction
   90|       |   * was not needed. In that case overwrite z[0:p_size] with the
   91|       |   * original x in ws[0:p_size].
   92|       |   *
   93|       |   * We only copy out p_size in the final step because we know
   94|       |   * the Montgomery result is < P
   95|       |   */
   96|       |
   97|   282k|   word borrow = bigint_sub3(z, ws, p_size + 1, p, p_size);
   98|       |
   99|   282k|   BOTAN_DEBUG_ASSERT(borrow == 0 || borrow == 1);
  ------------------
  |  |   99|   282k|      do {                          \
  |  |  100|   282k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  100|       |
  101|   282k|   CT::conditional_assign_mem(borrow, z, ws, p_size);
  102|   282k|   clear_mem(z + p_size, z_size - p_size);
  103|   282k|}

_ZN5Botan19bigint_monty_redc_4EPmPKmmS0_:
   14|  32.4k|void bigint_monty_redc_4(word z[8], const word p[4], word p_dash, word ws[]) {
   15|  32.4k|   word w2 = 0, w1 = 0, w0 = 0;
   16|  32.4k|   w0 = z[0];
   17|  32.4k|   ws[0] = w0 * p_dash;
   18|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
   19|  32.4k|   w0 = w1;
   20|  32.4k|   w1 = w2;
   21|  32.4k|   w2 = 0;
   22|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
   23|  32.4k|   word3_add(&w2, &w1, &w0, z[1]);
   24|  32.4k|   ws[1] = w0 * p_dash;
   25|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
   26|  32.4k|   w0 = w1;
   27|  32.4k|   w1 = w2;
   28|  32.4k|   w2 = 0;
   29|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
   30|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
   31|  32.4k|   word3_add(&w2, &w1, &w0, z[2]);
   32|  32.4k|   ws[2] = w0 * p_dash;
   33|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
   34|  32.4k|   w0 = w1;
   35|  32.4k|   w1 = w2;
   36|  32.4k|   w2 = 0;
   37|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
   38|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
   39|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
   40|  32.4k|   word3_add(&w2, &w1, &w0, z[3]);
   41|  32.4k|   ws[3] = w0 * p_dash;
   42|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
   43|  32.4k|   w0 = w1;
   44|  32.4k|   w1 = w2;
   45|  32.4k|   w2 = 0;
   46|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
   47|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
   48|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
   49|  32.4k|   word3_add(&w2, &w1, &w0, z[4]);
   50|  32.4k|   ws[0] = w0;
   51|  32.4k|   w0 = w1;
   52|  32.4k|   w1 = w2;
   53|  32.4k|   w2 = 0;
   54|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
   55|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
   56|  32.4k|   word3_add(&w2, &w1, &w0, z[5]);
   57|  32.4k|   ws[1] = w0;
   58|  32.4k|   w0 = w1;
   59|  32.4k|   w1 = w2;
   60|  32.4k|   w2 = 0;
   61|  32.4k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
   62|  32.4k|   word3_add(&w2, &w1, &w0, z[6]);
   63|  32.4k|   ws[2] = w0;
   64|  32.4k|   w0 = w1;
   65|  32.4k|   w1 = w2;
   66|  32.4k|   w2 = 0;
   67|  32.4k|   word3_add(&w2, &w1, &w0, z[7]);
   68|  32.4k|   ws[3] = w0;
   69|  32.4k|   ws[4] = w1;
   70|  32.4k|   word borrow = bigint_sub3(z, ws, 4 + 1, p, 4);
   71|  32.4k|   CT::conditional_assign_mem(borrow, z, ws, 4);
   72|  32.4k|   clear_mem(z + 4, 4);
   73|  32.4k|}
_ZN5Botan19bigint_monty_redc_6EPmPKmmS0_:
   75|  16.0k|void bigint_monty_redc_6(word z[12], const word p[6], word p_dash, word ws[]) {
   76|  16.0k|   word w2 = 0, w1 = 0, w0 = 0;
   77|  16.0k|   w0 = z[0];
   78|  16.0k|   ws[0] = w0 * p_dash;
   79|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
   80|  16.0k|   w0 = w1;
   81|  16.0k|   w1 = w2;
   82|  16.0k|   w2 = 0;
   83|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
   84|  16.0k|   word3_add(&w2, &w1, &w0, z[1]);
   85|  16.0k|   ws[1] = w0 * p_dash;
   86|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
   87|  16.0k|   w0 = w1;
   88|  16.0k|   w1 = w2;
   89|  16.0k|   w2 = 0;
   90|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
   91|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
   92|  16.0k|   word3_add(&w2, &w1, &w0, z[2]);
   93|  16.0k|   ws[2] = w0 * p_dash;
   94|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
   95|  16.0k|   w0 = w1;
   96|  16.0k|   w1 = w2;
   97|  16.0k|   w2 = 0;
   98|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
   99|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
  100|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
  101|  16.0k|   word3_add(&w2, &w1, &w0, z[3]);
  102|  16.0k|   ws[3] = w0 * p_dash;
  103|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
  104|  16.0k|   w0 = w1;
  105|  16.0k|   w1 = w2;
  106|  16.0k|   w2 = 0;
  107|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[4]);
  108|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
  109|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
  110|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
  111|  16.0k|   word3_add(&w2, &w1, &w0, z[4]);
  112|  16.0k|   ws[4] = w0 * p_dash;
  113|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[0]);
  114|  16.0k|   w0 = w1;
  115|  16.0k|   w1 = w2;
  116|  16.0k|   w2 = 0;
  117|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[0], p[5]);
  118|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[4]);
  119|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
  120|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
  121|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[1]);
  122|  16.0k|   word3_add(&w2, &w1, &w0, z[5]);
  123|  16.0k|   ws[5] = w0 * p_dash;
  124|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[0]);
  125|  16.0k|   w0 = w1;
  126|  16.0k|   w1 = w2;
  127|  16.0k|   w2 = 0;
  128|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[1], p[5]);
  129|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[4]);
  130|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
  131|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[2]);
  132|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[1]);
  133|  16.0k|   word3_add(&w2, &w1, &w0, z[6]);
  134|  16.0k|   ws[0] = w0;
  135|  16.0k|   w0 = w1;
  136|  16.0k|   w1 = w2;
  137|  16.0k|   w2 = 0;
  138|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[2], p[5]);
  139|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[4]);
  140|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[3]);
  141|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[2]);
  142|  16.0k|   word3_add(&w2, &w1, &w0, z[7]);
  143|  16.0k|   ws[1] = w0;
  144|  16.0k|   w0 = w1;
  145|  16.0k|   w1 = w2;
  146|  16.0k|   w2 = 0;
  147|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[3], p[5]);
  148|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[4]);
  149|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[3]);
  150|  16.0k|   word3_add(&w2, &w1, &w0, z[8]);
  151|  16.0k|   ws[2] = w0;
  152|  16.0k|   w0 = w1;
  153|  16.0k|   w1 = w2;
  154|  16.0k|   w2 = 0;
  155|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[4], p[5]);
  156|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[4]);
  157|  16.0k|   word3_add(&w2, &w1, &w0, z[9]);
  158|  16.0k|   ws[3] = w0;
  159|  16.0k|   w0 = w1;
  160|  16.0k|   w1 = w2;
  161|  16.0k|   w2 = 0;
  162|  16.0k|   word3_muladd(&w2, &w1, &w0, ws[5], p[5]);
  163|  16.0k|   word3_add(&w2, &w1, &w0, z[10]);
  164|  16.0k|   ws[4] = w0;
  165|  16.0k|   w0 = w1;
  166|  16.0k|   w1 = w2;
  167|  16.0k|   w2 = 0;
  168|  16.0k|   word3_add(&w2, &w1, &w0, z[11]);
  169|  16.0k|   ws[5] = w0;
  170|  16.0k|   ws[6] = w1;
  171|  16.0k|   word borrow = bigint_sub3(z, ws, 6 + 1, p, 6);
  172|  16.0k|   CT::conditional_assign_mem(borrow, z, ws, 6);
  173|  16.0k|   clear_mem(z + 6, 6);
  174|  16.0k|}
_ZN5Botan19bigint_monty_redc_8EPmPKmmS0_:
  176|  45.8k|void bigint_monty_redc_8(word z[16], const word p[8], word p_dash, word ws[]) {
  177|  45.8k|   word w2 = 0, w1 = 0, w0 = 0;
  178|  45.8k|   w0 = z[0];
  179|  45.8k|   ws[0] = w0 * p_dash;
  180|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
  181|  45.8k|   w0 = w1;
  182|  45.8k|   w1 = w2;
  183|  45.8k|   w2 = 0;
  184|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
  185|  45.8k|   word3_add(&w2, &w1, &w0, z[1]);
  186|  45.8k|   ws[1] = w0 * p_dash;
  187|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
  188|  45.8k|   w0 = w1;
  189|  45.8k|   w1 = w2;
  190|  45.8k|   w2 = 0;
  191|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
  192|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
  193|  45.8k|   word3_add(&w2, &w1, &w0, z[2]);
  194|  45.8k|   ws[2] = w0 * p_dash;
  195|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
  196|  45.8k|   w0 = w1;
  197|  45.8k|   w1 = w2;
  198|  45.8k|   w2 = 0;
  199|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
  200|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
  201|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
  202|  45.8k|   word3_add(&w2, &w1, &w0, z[3]);
  203|  45.8k|   ws[3] = w0 * p_dash;
  204|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
  205|  45.8k|   w0 = w1;
  206|  45.8k|   w1 = w2;
  207|  45.8k|   w2 = 0;
  208|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[4]);
  209|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
  210|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
  211|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
  212|  45.8k|   word3_add(&w2, &w1, &w0, z[4]);
  213|  45.8k|   ws[4] = w0 * p_dash;
  214|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[0]);
  215|  45.8k|   w0 = w1;
  216|  45.8k|   w1 = w2;
  217|  45.8k|   w2 = 0;
  218|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[5]);
  219|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[4]);
  220|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
  221|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
  222|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[1]);
  223|  45.8k|   word3_add(&w2, &w1, &w0, z[5]);
  224|  45.8k|   ws[5] = w0 * p_dash;
  225|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[0]);
  226|  45.8k|   w0 = w1;
  227|  45.8k|   w1 = w2;
  228|  45.8k|   w2 = 0;
  229|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[6]);
  230|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[5]);
  231|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[4]);
  232|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
  233|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[2]);
  234|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[1]);
  235|  45.8k|   word3_add(&w2, &w1, &w0, z[6]);
  236|  45.8k|   ws[6] = w0 * p_dash;
  237|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[0]);
  238|  45.8k|   w0 = w1;
  239|  45.8k|   w1 = w2;
  240|  45.8k|   w2 = 0;
  241|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[0], p[7]);
  242|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[6]);
  243|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[5]);
  244|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[4]);
  245|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[3]);
  246|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[2]);
  247|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[1]);
  248|  45.8k|   word3_add(&w2, &w1, &w0, z[7]);
  249|  45.8k|   ws[7] = w0 * p_dash;
  250|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[0]);
  251|  45.8k|   w0 = w1;
  252|  45.8k|   w1 = w2;
  253|  45.8k|   w2 = 0;
  254|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[1], p[7]);
  255|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[6]);
  256|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[5]);
  257|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[4]);
  258|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[3]);
  259|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[2]);
  260|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[1]);
  261|  45.8k|   word3_add(&w2, &w1, &w0, z[8]);
  262|  45.8k|   ws[0] = w0;
  263|  45.8k|   w0 = w1;
  264|  45.8k|   w1 = w2;
  265|  45.8k|   w2 = 0;
  266|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[2], p[7]);
  267|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[6]);
  268|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[5]);
  269|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[4]);
  270|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[3]);
  271|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[2]);
  272|  45.8k|   word3_add(&w2, &w1, &w0, z[9]);
  273|  45.8k|   ws[1] = w0;
  274|  45.8k|   w0 = w1;
  275|  45.8k|   w1 = w2;
  276|  45.8k|   w2 = 0;
  277|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[3], p[7]);
  278|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[6]);
  279|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[5]);
  280|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[4]);
  281|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[3]);
  282|  45.8k|   word3_add(&w2, &w1, &w0, z[10]);
  283|  45.8k|   ws[2] = w0;
  284|  45.8k|   w0 = w1;
  285|  45.8k|   w1 = w2;
  286|  45.8k|   w2 = 0;
  287|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[4], p[7]);
  288|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[6]);
  289|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[5]);
  290|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[4]);
  291|  45.8k|   word3_add(&w2, &w1, &w0, z[11]);
  292|  45.8k|   ws[3] = w0;
  293|  45.8k|   w0 = w1;
  294|  45.8k|   w1 = w2;
  295|  45.8k|   w2 = 0;
  296|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[5], p[7]);
  297|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[6]);
  298|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[5]);
  299|  45.8k|   word3_add(&w2, &w1, &w0, z[12]);
  300|  45.8k|   ws[4] = w0;
  301|  45.8k|   w0 = w1;
  302|  45.8k|   w1 = w2;
  303|  45.8k|   w2 = 0;
  304|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[6], p[7]);
  305|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[6]);
  306|  45.8k|   word3_add(&w2, &w1, &w0, z[13]);
  307|  45.8k|   ws[5] = w0;
  308|  45.8k|   w0 = w1;
  309|  45.8k|   w1 = w2;
  310|  45.8k|   w2 = 0;
  311|  45.8k|   word3_muladd(&w2, &w1, &w0, ws[7], p[7]);
  312|  45.8k|   word3_add(&w2, &w1, &w0, z[14]);
  313|  45.8k|   ws[6] = w0;
  314|  45.8k|   w0 = w1;
  315|  45.8k|   w1 = w2;
  316|  45.8k|   w2 = 0;
  317|  45.8k|   word3_add(&w2, &w1, &w0, z[15]);
  318|  45.8k|   ws[7] = w0;
  319|  45.8k|   ws[8] = w1;
  320|  45.8k|   word borrow = bigint_sub3(z, ws, 8 + 1, p, 8);
  321|  45.8k|   CT::conditional_assign_mem(borrow, z, ws, 8);
  322|  45.8k|   clear_mem(z + 8, 8);
  323|  45.8k|}
_ZN5Botan20bigint_monty_redc_16EPmPKmmS0_:
  325|  58.1k|void bigint_monty_redc_16(word z[32], const word p[16], word p_dash, word ws[]) {
  326|  58.1k|   word w2 = 0, w1 = 0, w0 = 0;
  327|  58.1k|   w0 = z[0];
  328|  58.1k|   ws[0] = w0 * p_dash;
  329|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
  330|  58.1k|   w0 = w1;
  331|  58.1k|   w1 = w2;
  332|  58.1k|   w2 = 0;
  333|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
  334|  58.1k|   word3_add(&w2, &w1, &w0, z[1]);
  335|  58.1k|   ws[1] = w0 * p_dash;
  336|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
  337|  58.1k|   w0 = w1;
  338|  58.1k|   w1 = w2;
  339|  58.1k|   w2 = 0;
  340|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
  341|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
  342|  58.1k|   word3_add(&w2, &w1, &w0, z[2]);
  343|  58.1k|   ws[2] = w0 * p_dash;
  344|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
  345|  58.1k|   w0 = w1;
  346|  58.1k|   w1 = w2;
  347|  58.1k|   w2 = 0;
  348|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
  349|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
  350|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
  351|  58.1k|   word3_add(&w2, &w1, &w0, z[3]);
  352|  58.1k|   ws[3] = w0 * p_dash;
  353|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
  354|  58.1k|   w0 = w1;
  355|  58.1k|   w1 = w2;
  356|  58.1k|   w2 = 0;
  357|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[4]);
  358|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
  359|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
  360|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
  361|  58.1k|   word3_add(&w2, &w1, &w0, z[4]);
  362|  58.1k|   ws[4] = w0 * p_dash;
  363|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[0]);
  364|  58.1k|   w0 = w1;
  365|  58.1k|   w1 = w2;
  366|  58.1k|   w2 = 0;
  367|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[5]);
  368|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[4]);
  369|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
  370|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
  371|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[1]);
  372|  58.1k|   word3_add(&w2, &w1, &w0, z[5]);
  373|  58.1k|   ws[5] = w0 * p_dash;
  374|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[0]);
  375|  58.1k|   w0 = w1;
  376|  58.1k|   w1 = w2;
  377|  58.1k|   w2 = 0;
  378|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[6]);
  379|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[5]);
  380|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[4]);
  381|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
  382|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[2]);
  383|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[1]);
  384|  58.1k|   word3_add(&w2, &w1, &w0, z[6]);
  385|  58.1k|   ws[6] = w0 * p_dash;
  386|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[0]);
  387|  58.1k|   w0 = w1;
  388|  58.1k|   w1 = w2;
  389|  58.1k|   w2 = 0;
  390|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[7]);
  391|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[6]);
  392|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[5]);
  393|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[4]);
  394|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[3]);
  395|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[2]);
  396|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[1]);
  397|  58.1k|   word3_add(&w2, &w1, &w0, z[7]);
  398|  58.1k|   ws[7] = w0 * p_dash;
  399|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[0]);
  400|  58.1k|   w0 = w1;
  401|  58.1k|   w1 = w2;
  402|  58.1k|   w2 = 0;
  403|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[8]);
  404|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[7]);
  405|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[6]);
  406|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[5]);
  407|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[4]);
  408|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[3]);
  409|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[2]);
  410|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[1]);
  411|  58.1k|   word3_add(&w2, &w1, &w0, z[8]);
  412|  58.1k|   ws[8] = w0 * p_dash;
  413|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[0]);
  414|  58.1k|   w0 = w1;
  415|  58.1k|   w1 = w2;
  416|  58.1k|   w2 = 0;
  417|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[9]);
  418|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[8]);
  419|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[7]);
  420|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[6]);
  421|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[5]);
  422|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[4]);
  423|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[3]);
  424|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[2]);
  425|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[1]);
  426|  58.1k|   word3_add(&w2, &w1, &w0, z[9]);
  427|  58.1k|   ws[9] = w0 * p_dash;
  428|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[0]);
  429|  58.1k|   w0 = w1;
  430|  58.1k|   w1 = w2;
  431|  58.1k|   w2 = 0;
  432|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[10]);
  433|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[9]);
  434|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[8]);
  435|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[7]);
  436|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[6]);
  437|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[5]);
  438|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[4]);
  439|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[3]);
  440|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[2]);
  441|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[1]);
  442|  58.1k|   word3_add(&w2, &w1, &w0, z[10]);
  443|  58.1k|   ws[10] = w0 * p_dash;
  444|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[0]);
  445|  58.1k|   w0 = w1;
  446|  58.1k|   w1 = w2;
  447|  58.1k|   w2 = 0;
  448|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[11]);
  449|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[10]);
  450|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[9]);
  451|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[8]);
  452|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[7]);
  453|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[6]);
  454|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[5]);
  455|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[4]);
  456|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[3]);
  457|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[2]);
  458|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[1]);
  459|  58.1k|   word3_add(&w2, &w1, &w0, z[11]);
  460|  58.1k|   ws[11] = w0 * p_dash;
  461|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[0]);
  462|  58.1k|   w0 = w1;
  463|  58.1k|   w1 = w2;
  464|  58.1k|   w2 = 0;
  465|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[12]);
  466|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[11]);
  467|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[10]);
  468|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[9]);
  469|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[8]);
  470|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[7]);
  471|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[6]);
  472|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[5]);
  473|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[4]);
  474|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[3]);
  475|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[2]);
  476|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[1]);
  477|  58.1k|   word3_add(&w2, &w1, &w0, z[12]);
  478|  58.1k|   ws[12] = w0 * p_dash;
  479|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[0]);
  480|  58.1k|   w0 = w1;
  481|  58.1k|   w1 = w2;
  482|  58.1k|   w2 = 0;
  483|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[13]);
  484|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[12]);
  485|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[11]);
  486|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[10]);
  487|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[9]);
  488|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[8]);
  489|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[7]);
  490|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[6]);
  491|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[5]);
  492|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[4]);
  493|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[3]);
  494|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[2]);
  495|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[1]);
  496|  58.1k|   word3_add(&w2, &w1, &w0, z[13]);
  497|  58.1k|   ws[13] = w0 * p_dash;
  498|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[0]);
  499|  58.1k|   w0 = w1;
  500|  58.1k|   w1 = w2;
  501|  58.1k|   w2 = 0;
  502|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[14]);
  503|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[13]);
  504|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[12]);
  505|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[11]);
  506|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[10]);
  507|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[9]);
  508|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[8]);
  509|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[7]);
  510|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[6]);
  511|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[5]);
  512|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[4]);
  513|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[3]);
  514|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[2]);
  515|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[1]);
  516|  58.1k|   word3_add(&w2, &w1, &w0, z[14]);
  517|  58.1k|   ws[14] = w0 * p_dash;
  518|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[0]);
  519|  58.1k|   w0 = w1;
  520|  58.1k|   w1 = w2;
  521|  58.1k|   w2 = 0;
  522|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[15]);
  523|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[14]);
  524|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[13]);
  525|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[12]);
  526|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[11]);
  527|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[10]);
  528|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[9]);
  529|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[8]);
  530|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[7]);
  531|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[6]);
  532|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[5]);
  533|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[4]);
  534|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[3]);
  535|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[2]);
  536|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[1]);
  537|  58.1k|   word3_add(&w2, &w1, &w0, z[15]);
  538|  58.1k|   ws[15] = w0 * p_dash;
  539|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[0]);
  540|  58.1k|   w0 = w1;
  541|  58.1k|   w1 = w2;
  542|  58.1k|   w2 = 0;
  543|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[15]);
  544|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[14]);
  545|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[13]);
  546|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[12]);
  547|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[11]);
  548|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[10]);
  549|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[9]);
  550|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[8]);
  551|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[7]);
  552|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[6]);
  553|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[5]);
  554|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[4]);
  555|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[3]);
  556|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[2]);
  557|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[1]);
  558|  58.1k|   word3_add(&w2, &w1, &w0, z[16]);
  559|  58.1k|   ws[0] = w0;
  560|  58.1k|   w0 = w1;
  561|  58.1k|   w1 = w2;
  562|  58.1k|   w2 = 0;
  563|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[15]);
  564|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[14]);
  565|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[13]);
  566|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[12]);
  567|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[11]);
  568|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[10]);
  569|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[9]);
  570|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[8]);
  571|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[7]);
  572|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[6]);
  573|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[5]);
  574|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[4]);
  575|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[3]);
  576|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[2]);
  577|  58.1k|   word3_add(&w2, &w1, &w0, z[17]);
  578|  58.1k|   ws[1] = w0;
  579|  58.1k|   w0 = w1;
  580|  58.1k|   w1 = w2;
  581|  58.1k|   w2 = 0;
  582|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[15]);
  583|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[14]);
  584|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[13]);
  585|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[12]);
  586|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[11]);
  587|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[10]);
  588|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[9]);
  589|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[8]);
  590|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[7]);
  591|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[6]);
  592|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[5]);
  593|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[4]);
  594|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[3]);
  595|  58.1k|   word3_add(&w2, &w1, &w0, z[18]);
  596|  58.1k|   ws[2] = w0;
  597|  58.1k|   w0 = w1;
  598|  58.1k|   w1 = w2;
  599|  58.1k|   w2 = 0;
  600|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[15]);
  601|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[14]);
  602|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[13]);
  603|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[12]);
  604|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[11]);
  605|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[10]);
  606|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[9]);
  607|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[8]);
  608|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[7]);
  609|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[6]);
  610|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[5]);
  611|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[4]);
  612|  58.1k|   word3_add(&w2, &w1, &w0, z[19]);
  613|  58.1k|   ws[3] = w0;
  614|  58.1k|   w0 = w1;
  615|  58.1k|   w1 = w2;
  616|  58.1k|   w2 = 0;
  617|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[15]);
  618|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[14]);
  619|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[13]);
  620|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[12]);
  621|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[11]);
  622|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[10]);
  623|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[9]);
  624|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[8]);
  625|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[7]);
  626|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[6]);
  627|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[5]);
  628|  58.1k|   word3_add(&w2, &w1, &w0, z[20]);
  629|  58.1k|   ws[4] = w0;
  630|  58.1k|   w0 = w1;
  631|  58.1k|   w1 = w2;
  632|  58.1k|   w2 = 0;
  633|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[15]);
  634|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[14]);
  635|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[13]);
  636|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[12]);
  637|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[11]);
  638|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[10]);
  639|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[9]);
  640|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[8]);
  641|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[7]);
  642|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[6]);
  643|  58.1k|   word3_add(&w2, &w1, &w0, z[21]);
  644|  58.1k|   ws[5] = w0;
  645|  58.1k|   w0 = w1;
  646|  58.1k|   w1 = w2;
  647|  58.1k|   w2 = 0;
  648|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[15]);
  649|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[14]);
  650|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[13]);
  651|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[12]);
  652|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[11]);
  653|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[10]);
  654|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[9]);
  655|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[8]);
  656|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[7]);
  657|  58.1k|   word3_add(&w2, &w1, &w0, z[22]);
  658|  58.1k|   ws[6] = w0;
  659|  58.1k|   w0 = w1;
  660|  58.1k|   w1 = w2;
  661|  58.1k|   w2 = 0;
  662|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[15]);
  663|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[14]);
  664|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[13]);
  665|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[12]);
  666|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[11]);
  667|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[10]);
  668|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[9]);
  669|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[8]);
  670|  58.1k|   word3_add(&w2, &w1, &w0, z[23]);
  671|  58.1k|   ws[7] = w0;
  672|  58.1k|   w0 = w1;
  673|  58.1k|   w1 = w2;
  674|  58.1k|   w2 = 0;
  675|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[15]);
  676|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[14]);
  677|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[13]);
  678|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[12]);
  679|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[11]);
  680|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[10]);
  681|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[9]);
  682|  58.1k|   word3_add(&w2, &w1, &w0, z[24]);
  683|  58.1k|   ws[8] = w0;
  684|  58.1k|   w0 = w1;
  685|  58.1k|   w1 = w2;
  686|  58.1k|   w2 = 0;
  687|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[15]);
  688|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[14]);
  689|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[13]);
  690|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[12]);
  691|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[11]);
  692|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[10]);
  693|  58.1k|   word3_add(&w2, &w1, &w0, z[25]);
  694|  58.1k|   ws[9] = w0;
  695|  58.1k|   w0 = w1;
  696|  58.1k|   w1 = w2;
  697|  58.1k|   w2 = 0;
  698|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[15]);
  699|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[14]);
  700|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[13]);
  701|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[12]);
  702|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[11]);
  703|  58.1k|   word3_add(&w2, &w1, &w0, z[26]);
  704|  58.1k|   ws[10] = w0;
  705|  58.1k|   w0 = w1;
  706|  58.1k|   w1 = w2;
  707|  58.1k|   w2 = 0;
  708|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[15]);
  709|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[14]);
  710|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[13]);
  711|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[12]);
  712|  58.1k|   word3_add(&w2, &w1, &w0, z[27]);
  713|  58.1k|   ws[11] = w0;
  714|  58.1k|   w0 = w1;
  715|  58.1k|   w1 = w2;
  716|  58.1k|   w2 = 0;
  717|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[15]);
  718|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[14]);
  719|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[13]);
  720|  58.1k|   word3_add(&w2, &w1, &w0, z[28]);
  721|  58.1k|   ws[12] = w0;
  722|  58.1k|   w0 = w1;
  723|  58.1k|   w1 = w2;
  724|  58.1k|   w2 = 0;
  725|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[15]);
  726|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[14]);
  727|  58.1k|   word3_add(&w2, &w1, &w0, z[29]);
  728|  58.1k|   ws[13] = w0;
  729|  58.1k|   w0 = w1;
  730|  58.1k|   w1 = w2;
  731|  58.1k|   w2 = 0;
  732|  58.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[15]);
  733|  58.1k|   word3_add(&w2, &w1, &w0, z[30]);
  734|  58.1k|   ws[14] = w0;
  735|  58.1k|   w0 = w1;
  736|  58.1k|   w1 = w2;
  737|  58.1k|   w2 = 0;
  738|  58.1k|   word3_add(&w2, &w1, &w0, z[31]);
  739|  58.1k|   ws[15] = w0;
  740|  58.1k|   ws[16] = w1;
  741|  58.1k|   word borrow = bigint_sub3(z, ws, 16 + 1, p, 16);
  742|  58.1k|   CT::conditional_assign_mem(borrow, z, ws, 16);
  743|  58.1k|   clear_mem(z + 16, 16);
  744|  58.1k|}
_ZN5Botan20bigint_monty_redc_24EPmPKmmS0_:
  746|  5.01k|void bigint_monty_redc_24(word z[48], const word p[24], word p_dash, word ws[]) {
  747|  5.01k|   word w2 = 0, w1 = 0, w0 = 0;
  748|  5.01k|   w0 = z[0];
  749|  5.01k|   ws[0] = w0 * p_dash;
  750|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
  751|  5.01k|   w0 = w1;
  752|  5.01k|   w1 = w2;
  753|  5.01k|   w2 = 0;
  754|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
  755|  5.01k|   word3_add(&w2, &w1, &w0, z[1]);
  756|  5.01k|   ws[1] = w0 * p_dash;
  757|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
  758|  5.01k|   w0 = w1;
  759|  5.01k|   w1 = w2;
  760|  5.01k|   w2 = 0;
  761|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
  762|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
  763|  5.01k|   word3_add(&w2, &w1, &w0, z[2]);
  764|  5.01k|   ws[2] = w0 * p_dash;
  765|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
  766|  5.01k|   w0 = w1;
  767|  5.01k|   w1 = w2;
  768|  5.01k|   w2 = 0;
  769|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
  770|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
  771|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
  772|  5.01k|   word3_add(&w2, &w1, &w0, z[3]);
  773|  5.01k|   ws[3] = w0 * p_dash;
  774|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
  775|  5.01k|   w0 = w1;
  776|  5.01k|   w1 = w2;
  777|  5.01k|   w2 = 0;
  778|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[4]);
  779|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
  780|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
  781|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
  782|  5.01k|   word3_add(&w2, &w1, &w0, z[4]);
  783|  5.01k|   ws[4] = w0 * p_dash;
  784|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[0]);
  785|  5.01k|   w0 = w1;
  786|  5.01k|   w1 = w2;
  787|  5.01k|   w2 = 0;
  788|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[5]);
  789|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[4]);
  790|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
  791|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
  792|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[1]);
  793|  5.01k|   word3_add(&w2, &w1, &w0, z[5]);
  794|  5.01k|   ws[5] = w0 * p_dash;
  795|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[0]);
  796|  5.01k|   w0 = w1;
  797|  5.01k|   w1 = w2;
  798|  5.01k|   w2 = 0;
  799|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[6]);
  800|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[5]);
  801|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[4]);
  802|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
  803|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[2]);
  804|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[1]);
  805|  5.01k|   word3_add(&w2, &w1, &w0, z[6]);
  806|  5.01k|   ws[6] = w0 * p_dash;
  807|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[0]);
  808|  5.01k|   w0 = w1;
  809|  5.01k|   w1 = w2;
  810|  5.01k|   w2 = 0;
  811|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[7]);
  812|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[6]);
  813|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[5]);
  814|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[4]);
  815|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[3]);
  816|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[2]);
  817|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[1]);
  818|  5.01k|   word3_add(&w2, &w1, &w0, z[7]);
  819|  5.01k|   ws[7] = w0 * p_dash;
  820|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[0]);
  821|  5.01k|   w0 = w1;
  822|  5.01k|   w1 = w2;
  823|  5.01k|   w2 = 0;
  824|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[8]);
  825|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[7]);
  826|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[6]);
  827|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[5]);
  828|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[4]);
  829|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[3]);
  830|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[2]);
  831|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[1]);
  832|  5.01k|   word3_add(&w2, &w1, &w0, z[8]);
  833|  5.01k|   ws[8] = w0 * p_dash;
  834|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[0]);
  835|  5.01k|   w0 = w1;
  836|  5.01k|   w1 = w2;
  837|  5.01k|   w2 = 0;
  838|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[9]);
  839|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[8]);
  840|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[7]);
  841|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[6]);
  842|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[5]);
  843|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[4]);
  844|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[3]);
  845|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[2]);
  846|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[1]);
  847|  5.01k|   word3_add(&w2, &w1, &w0, z[9]);
  848|  5.01k|   ws[9] = w0 * p_dash;
  849|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[0]);
  850|  5.01k|   w0 = w1;
  851|  5.01k|   w1 = w2;
  852|  5.01k|   w2 = 0;
  853|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[10]);
  854|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[9]);
  855|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[8]);
  856|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[7]);
  857|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[6]);
  858|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[5]);
  859|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[4]);
  860|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[3]);
  861|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[2]);
  862|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[1]);
  863|  5.01k|   word3_add(&w2, &w1, &w0, z[10]);
  864|  5.01k|   ws[10] = w0 * p_dash;
  865|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[0]);
  866|  5.01k|   w0 = w1;
  867|  5.01k|   w1 = w2;
  868|  5.01k|   w2 = 0;
  869|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[11]);
  870|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[10]);
  871|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[9]);
  872|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[8]);
  873|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[7]);
  874|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[6]);
  875|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[5]);
  876|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[4]);
  877|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[3]);
  878|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[2]);
  879|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[1]);
  880|  5.01k|   word3_add(&w2, &w1, &w0, z[11]);
  881|  5.01k|   ws[11] = w0 * p_dash;
  882|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[0]);
  883|  5.01k|   w0 = w1;
  884|  5.01k|   w1 = w2;
  885|  5.01k|   w2 = 0;
  886|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[12]);
  887|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[11]);
  888|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[10]);
  889|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[9]);
  890|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[8]);
  891|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[7]);
  892|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[6]);
  893|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[5]);
  894|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[4]);
  895|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[3]);
  896|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[2]);
  897|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[1]);
  898|  5.01k|   word3_add(&w2, &w1, &w0, z[12]);
  899|  5.01k|   ws[12] = w0 * p_dash;
  900|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[0]);
  901|  5.01k|   w0 = w1;
  902|  5.01k|   w1 = w2;
  903|  5.01k|   w2 = 0;
  904|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[13]);
  905|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[12]);
  906|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[11]);
  907|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[10]);
  908|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[9]);
  909|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[8]);
  910|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[7]);
  911|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[6]);
  912|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[5]);
  913|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[4]);
  914|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[3]);
  915|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[2]);
  916|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[1]);
  917|  5.01k|   word3_add(&w2, &w1, &w0, z[13]);
  918|  5.01k|   ws[13] = w0 * p_dash;
  919|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[0]);
  920|  5.01k|   w0 = w1;
  921|  5.01k|   w1 = w2;
  922|  5.01k|   w2 = 0;
  923|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[14]);
  924|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[13]);
  925|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[12]);
  926|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[11]);
  927|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[10]);
  928|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[9]);
  929|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[8]);
  930|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[7]);
  931|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[6]);
  932|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[5]);
  933|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[4]);
  934|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[3]);
  935|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[2]);
  936|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[1]);
  937|  5.01k|   word3_add(&w2, &w1, &w0, z[14]);
  938|  5.01k|   ws[14] = w0 * p_dash;
  939|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[0]);
  940|  5.01k|   w0 = w1;
  941|  5.01k|   w1 = w2;
  942|  5.01k|   w2 = 0;
  943|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[15]);
  944|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[14]);
  945|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[13]);
  946|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[12]);
  947|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[11]);
  948|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[10]);
  949|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[9]);
  950|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[8]);
  951|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[7]);
  952|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[6]);
  953|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[5]);
  954|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[4]);
  955|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[3]);
  956|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[2]);
  957|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[1]);
  958|  5.01k|   word3_add(&w2, &w1, &w0, z[15]);
  959|  5.01k|   ws[15] = w0 * p_dash;
  960|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[0]);
  961|  5.01k|   w0 = w1;
  962|  5.01k|   w1 = w2;
  963|  5.01k|   w2 = 0;
  964|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[16]);
  965|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[15]);
  966|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[14]);
  967|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[13]);
  968|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[12]);
  969|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[11]);
  970|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[10]);
  971|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[9]);
  972|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[8]);
  973|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[7]);
  974|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[6]);
  975|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[5]);
  976|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[4]);
  977|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[3]);
  978|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[2]);
  979|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[1]);
  980|  5.01k|   word3_add(&w2, &w1, &w0, z[16]);
  981|  5.01k|   ws[16] = w0 * p_dash;
  982|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[0]);
  983|  5.01k|   w0 = w1;
  984|  5.01k|   w1 = w2;
  985|  5.01k|   w2 = 0;
  986|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[17]);
  987|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[16]);
  988|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[15]);
  989|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[14]);
  990|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[13]);
  991|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[12]);
  992|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[11]);
  993|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[10]);
  994|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[9]);
  995|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[8]);
  996|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[7]);
  997|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[6]);
  998|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[5]);
  999|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[4]);
 1000|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[3]);
 1001|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[2]);
 1002|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[1]);
 1003|  5.01k|   word3_add(&w2, &w1, &w0, z[17]);
 1004|  5.01k|   ws[17] = w0 * p_dash;
 1005|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[0]);
 1006|  5.01k|   w0 = w1;
 1007|  5.01k|   w1 = w2;
 1008|  5.01k|   w2 = 0;
 1009|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[18]);
 1010|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[17]);
 1011|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[16]);
 1012|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[15]);
 1013|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[14]);
 1014|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[13]);
 1015|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[12]);
 1016|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[11]);
 1017|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[10]);
 1018|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[9]);
 1019|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[8]);
 1020|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[7]);
 1021|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[6]);
 1022|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[5]);
 1023|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[4]);
 1024|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[3]);
 1025|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[2]);
 1026|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[1]);
 1027|  5.01k|   word3_add(&w2, &w1, &w0, z[18]);
 1028|  5.01k|   ws[18] = w0 * p_dash;
 1029|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[0]);
 1030|  5.01k|   w0 = w1;
 1031|  5.01k|   w1 = w2;
 1032|  5.01k|   w2 = 0;
 1033|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[19]);
 1034|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[18]);
 1035|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[17]);
 1036|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[16]);
 1037|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[15]);
 1038|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[14]);
 1039|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[13]);
 1040|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[12]);
 1041|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[11]);
 1042|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[10]);
 1043|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[9]);
 1044|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[8]);
 1045|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[7]);
 1046|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[6]);
 1047|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[5]);
 1048|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[4]);
 1049|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[3]);
 1050|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[2]);
 1051|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[1]);
 1052|  5.01k|   word3_add(&w2, &w1, &w0, z[19]);
 1053|  5.01k|   ws[19] = w0 * p_dash;
 1054|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[0]);
 1055|  5.01k|   w0 = w1;
 1056|  5.01k|   w1 = w2;
 1057|  5.01k|   w2 = 0;
 1058|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[20]);
 1059|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[19]);
 1060|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[18]);
 1061|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[17]);
 1062|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[16]);
 1063|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[15]);
 1064|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[14]);
 1065|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[13]);
 1066|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[12]);
 1067|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[11]);
 1068|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[10]);
 1069|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[9]);
 1070|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[8]);
 1071|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[7]);
 1072|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[6]);
 1073|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[5]);
 1074|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[4]);
 1075|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[3]);
 1076|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[2]);
 1077|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[1]);
 1078|  5.01k|   word3_add(&w2, &w1, &w0, z[20]);
 1079|  5.01k|   ws[20] = w0 * p_dash;
 1080|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[0]);
 1081|  5.01k|   w0 = w1;
 1082|  5.01k|   w1 = w2;
 1083|  5.01k|   w2 = 0;
 1084|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[21]);
 1085|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[20]);
 1086|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[19]);
 1087|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[18]);
 1088|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[17]);
 1089|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[16]);
 1090|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[15]);
 1091|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[14]);
 1092|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[13]);
 1093|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[12]);
 1094|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[11]);
 1095|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[10]);
 1096|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[9]);
 1097|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[8]);
 1098|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[7]);
 1099|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[6]);
 1100|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[5]);
 1101|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[4]);
 1102|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[3]);
 1103|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[2]);
 1104|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[1]);
 1105|  5.01k|   word3_add(&w2, &w1, &w0, z[21]);
 1106|  5.01k|   ws[21] = w0 * p_dash;
 1107|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[0]);
 1108|  5.01k|   w0 = w1;
 1109|  5.01k|   w1 = w2;
 1110|  5.01k|   w2 = 0;
 1111|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[22]);
 1112|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[21]);
 1113|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[20]);
 1114|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[19]);
 1115|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[18]);
 1116|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[17]);
 1117|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[16]);
 1118|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[15]);
 1119|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[14]);
 1120|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[13]);
 1121|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[12]);
 1122|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[11]);
 1123|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[10]);
 1124|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[9]);
 1125|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[8]);
 1126|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[7]);
 1127|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[6]);
 1128|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[5]);
 1129|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[4]);
 1130|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[3]);
 1131|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[2]);
 1132|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[1]);
 1133|  5.01k|   word3_add(&w2, &w1, &w0, z[22]);
 1134|  5.01k|   ws[22] = w0 * p_dash;
 1135|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[0]);
 1136|  5.01k|   w0 = w1;
 1137|  5.01k|   w1 = w2;
 1138|  5.01k|   w2 = 0;
 1139|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[0], p[23]);
 1140|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[22]);
 1141|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[21]);
 1142|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[20]);
 1143|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[19]);
 1144|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[18]);
 1145|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[17]);
 1146|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[16]);
 1147|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[15]);
 1148|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[14]);
 1149|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[13]);
 1150|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[12]);
 1151|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[11]);
 1152|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[10]);
 1153|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[9]);
 1154|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[8]);
 1155|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[7]);
 1156|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[6]);
 1157|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[5]);
 1158|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[4]);
 1159|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[3]);
 1160|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[2]);
 1161|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[1]);
 1162|  5.01k|   word3_add(&w2, &w1, &w0, z[23]);
 1163|  5.01k|   ws[23] = w0 * p_dash;
 1164|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[0]);
 1165|  5.01k|   w0 = w1;
 1166|  5.01k|   w1 = w2;
 1167|  5.01k|   w2 = 0;
 1168|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[1], p[23]);
 1169|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[22]);
 1170|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[21]);
 1171|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[20]);
 1172|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[19]);
 1173|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[18]);
 1174|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[17]);
 1175|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[16]);
 1176|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[15]);
 1177|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[14]);
 1178|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[13]);
 1179|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[12]);
 1180|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[11]);
 1181|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[10]);
 1182|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[9]);
 1183|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[8]);
 1184|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[7]);
 1185|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[6]);
 1186|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[5]);
 1187|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[4]);
 1188|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[3]);
 1189|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[2]);
 1190|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[1]);
 1191|  5.01k|   word3_add(&w2, &w1, &w0, z[24]);
 1192|  5.01k|   ws[0] = w0;
 1193|  5.01k|   w0 = w1;
 1194|  5.01k|   w1 = w2;
 1195|  5.01k|   w2 = 0;
 1196|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[2], p[23]);
 1197|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[22]);
 1198|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[21]);
 1199|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[20]);
 1200|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[19]);
 1201|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[18]);
 1202|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[17]);
 1203|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[16]);
 1204|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[15]);
 1205|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[14]);
 1206|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[13]);
 1207|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[12]);
 1208|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[11]);
 1209|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[10]);
 1210|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[9]);
 1211|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[8]);
 1212|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[7]);
 1213|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[6]);
 1214|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[5]);
 1215|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[4]);
 1216|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[3]);
 1217|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[2]);
 1218|  5.01k|   word3_add(&w2, &w1, &w0, z[25]);
 1219|  5.01k|   ws[1] = w0;
 1220|  5.01k|   w0 = w1;
 1221|  5.01k|   w1 = w2;
 1222|  5.01k|   w2 = 0;
 1223|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[3], p[23]);
 1224|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[22]);
 1225|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[21]);
 1226|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[20]);
 1227|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[19]);
 1228|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[18]);
 1229|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[17]);
 1230|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[16]);
 1231|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[15]);
 1232|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[14]);
 1233|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[13]);
 1234|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[12]);
 1235|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[11]);
 1236|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[10]);
 1237|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[9]);
 1238|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[8]);
 1239|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[7]);
 1240|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[6]);
 1241|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[5]);
 1242|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[4]);
 1243|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[3]);
 1244|  5.01k|   word3_add(&w2, &w1, &w0, z[26]);
 1245|  5.01k|   ws[2] = w0;
 1246|  5.01k|   w0 = w1;
 1247|  5.01k|   w1 = w2;
 1248|  5.01k|   w2 = 0;
 1249|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[4], p[23]);
 1250|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[22]);
 1251|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[21]);
 1252|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[20]);
 1253|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[19]);
 1254|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[18]);
 1255|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[17]);
 1256|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[16]);
 1257|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[15]);
 1258|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[14]);
 1259|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[13]);
 1260|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[12]);
 1261|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[11]);
 1262|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[10]);
 1263|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[9]);
 1264|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[8]);
 1265|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[7]);
 1266|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[6]);
 1267|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[5]);
 1268|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[4]);
 1269|  5.01k|   word3_add(&w2, &w1, &w0, z[27]);
 1270|  5.01k|   ws[3] = w0;
 1271|  5.01k|   w0 = w1;
 1272|  5.01k|   w1 = w2;
 1273|  5.01k|   w2 = 0;
 1274|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[5], p[23]);
 1275|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[22]);
 1276|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[21]);
 1277|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[20]);
 1278|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[19]);
 1279|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[18]);
 1280|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[17]);
 1281|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[16]);
 1282|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[15]);
 1283|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[14]);
 1284|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[13]);
 1285|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[12]);
 1286|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[11]);
 1287|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[10]);
 1288|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[9]);
 1289|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[8]);
 1290|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[7]);
 1291|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[6]);
 1292|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[5]);
 1293|  5.01k|   word3_add(&w2, &w1, &w0, z[28]);
 1294|  5.01k|   ws[4] = w0;
 1295|  5.01k|   w0 = w1;
 1296|  5.01k|   w1 = w2;
 1297|  5.01k|   w2 = 0;
 1298|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[6], p[23]);
 1299|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[22]);
 1300|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[21]);
 1301|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[20]);
 1302|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[19]);
 1303|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[18]);
 1304|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[17]);
 1305|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[16]);
 1306|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[15]);
 1307|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[14]);
 1308|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[13]);
 1309|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[12]);
 1310|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[11]);
 1311|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[10]);
 1312|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[9]);
 1313|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[8]);
 1314|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[7]);
 1315|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[6]);
 1316|  5.01k|   word3_add(&w2, &w1, &w0, z[29]);
 1317|  5.01k|   ws[5] = w0;
 1318|  5.01k|   w0 = w1;
 1319|  5.01k|   w1 = w2;
 1320|  5.01k|   w2 = 0;
 1321|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[7], p[23]);
 1322|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[22]);
 1323|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[21]);
 1324|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[20]);
 1325|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[19]);
 1326|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[18]);
 1327|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[17]);
 1328|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[16]);
 1329|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[15]);
 1330|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[14]);
 1331|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[13]);
 1332|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[12]);
 1333|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[11]);
 1334|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[10]);
 1335|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[9]);
 1336|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[8]);
 1337|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[7]);
 1338|  5.01k|   word3_add(&w2, &w1, &w0, z[30]);
 1339|  5.01k|   ws[6] = w0;
 1340|  5.01k|   w0 = w1;
 1341|  5.01k|   w1 = w2;
 1342|  5.01k|   w2 = 0;
 1343|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[8], p[23]);
 1344|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[22]);
 1345|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[21]);
 1346|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[20]);
 1347|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[19]);
 1348|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[18]);
 1349|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[17]);
 1350|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[16]);
 1351|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[15]);
 1352|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[14]);
 1353|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[13]);
 1354|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[12]);
 1355|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[11]);
 1356|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[10]);
 1357|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[9]);
 1358|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[8]);
 1359|  5.01k|   word3_add(&w2, &w1, &w0, z[31]);
 1360|  5.01k|   ws[7] = w0;
 1361|  5.01k|   w0 = w1;
 1362|  5.01k|   w1 = w2;
 1363|  5.01k|   w2 = 0;
 1364|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[9], p[23]);
 1365|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[22]);
 1366|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[21]);
 1367|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[20]);
 1368|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[19]);
 1369|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[18]);
 1370|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[17]);
 1371|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[16]);
 1372|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[15]);
 1373|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[14]);
 1374|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[13]);
 1375|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[12]);
 1376|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[11]);
 1377|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[10]);
 1378|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[9]);
 1379|  5.01k|   word3_add(&w2, &w1, &w0, z[32]);
 1380|  5.01k|   ws[8] = w0;
 1381|  5.01k|   w0 = w1;
 1382|  5.01k|   w1 = w2;
 1383|  5.01k|   w2 = 0;
 1384|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[10], p[23]);
 1385|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[22]);
 1386|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[21]);
 1387|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[20]);
 1388|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[19]);
 1389|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[18]);
 1390|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[17]);
 1391|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[16]);
 1392|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[15]);
 1393|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[14]);
 1394|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[13]);
 1395|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[12]);
 1396|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[11]);
 1397|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[10]);
 1398|  5.01k|   word3_add(&w2, &w1, &w0, z[33]);
 1399|  5.01k|   ws[9] = w0;
 1400|  5.01k|   w0 = w1;
 1401|  5.01k|   w1 = w2;
 1402|  5.01k|   w2 = 0;
 1403|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[11], p[23]);
 1404|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[22]);
 1405|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[21]);
 1406|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[20]);
 1407|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[19]);
 1408|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[18]);
 1409|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[17]);
 1410|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[16]);
 1411|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[15]);
 1412|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[14]);
 1413|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[13]);
 1414|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[12]);
 1415|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[11]);
 1416|  5.01k|   word3_add(&w2, &w1, &w0, z[34]);
 1417|  5.01k|   ws[10] = w0;
 1418|  5.01k|   w0 = w1;
 1419|  5.01k|   w1 = w2;
 1420|  5.01k|   w2 = 0;
 1421|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[12], p[23]);
 1422|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[22]);
 1423|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[21]);
 1424|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[20]);
 1425|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[19]);
 1426|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[18]);
 1427|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[17]);
 1428|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[16]);
 1429|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[15]);
 1430|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[14]);
 1431|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[13]);
 1432|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[12]);
 1433|  5.01k|   word3_add(&w2, &w1, &w0, z[35]);
 1434|  5.01k|   ws[11] = w0;
 1435|  5.01k|   w0 = w1;
 1436|  5.01k|   w1 = w2;
 1437|  5.01k|   w2 = 0;
 1438|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[13], p[23]);
 1439|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[22]);
 1440|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[21]);
 1441|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[20]);
 1442|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[19]);
 1443|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[18]);
 1444|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[17]);
 1445|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[16]);
 1446|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[15]);
 1447|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[14]);
 1448|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[13]);
 1449|  5.01k|   word3_add(&w2, &w1, &w0, z[36]);
 1450|  5.01k|   ws[12] = w0;
 1451|  5.01k|   w0 = w1;
 1452|  5.01k|   w1 = w2;
 1453|  5.01k|   w2 = 0;
 1454|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[14], p[23]);
 1455|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[22]);
 1456|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[21]);
 1457|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[20]);
 1458|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[19]);
 1459|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[18]);
 1460|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[17]);
 1461|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[16]);
 1462|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[15]);
 1463|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[14]);
 1464|  5.01k|   word3_add(&w2, &w1, &w0, z[37]);
 1465|  5.01k|   ws[13] = w0;
 1466|  5.01k|   w0 = w1;
 1467|  5.01k|   w1 = w2;
 1468|  5.01k|   w2 = 0;
 1469|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[15], p[23]);
 1470|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[22]);
 1471|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[21]);
 1472|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[20]);
 1473|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[19]);
 1474|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[18]);
 1475|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[17]);
 1476|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[16]);
 1477|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[15]);
 1478|  5.01k|   word3_add(&w2, &w1, &w0, z[38]);
 1479|  5.01k|   ws[14] = w0;
 1480|  5.01k|   w0 = w1;
 1481|  5.01k|   w1 = w2;
 1482|  5.01k|   w2 = 0;
 1483|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[16], p[23]);
 1484|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[22]);
 1485|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[21]);
 1486|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[20]);
 1487|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[19]);
 1488|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[18]);
 1489|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[17]);
 1490|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[16]);
 1491|  5.01k|   word3_add(&w2, &w1, &w0, z[39]);
 1492|  5.01k|   ws[15] = w0;
 1493|  5.01k|   w0 = w1;
 1494|  5.01k|   w1 = w2;
 1495|  5.01k|   w2 = 0;
 1496|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[17], p[23]);
 1497|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[22]);
 1498|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[21]);
 1499|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[20]);
 1500|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[19]);
 1501|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[18]);
 1502|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[17]);
 1503|  5.01k|   word3_add(&w2, &w1, &w0, z[40]);
 1504|  5.01k|   ws[16] = w0;
 1505|  5.01k|   w0 = w1;
 1506|  5.01k|   w1 = w2;
 1507|  5.01k|   w2 = 0;
 1508|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[18], p[23]);
 1509|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[22]);
 1510|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[21]);
 1511|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[20]);
 1512|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[19]);
 1513|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[18]);
 1514|  5.01k|   word3_add(&w2, &w1, &w0, z[41]);
 1515|  5.01k|   ws[17] = w0;
 1516|  5.01k|   w0 = w1;
 1517|  5.01k|   w1 = w2;
 1518|  5.01k|   w2 = 0;
 1519|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[19], p[23]);
 1520|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[22]);
 1521|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[21]);
 1522|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[20]);
 1523|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[19]);
 1524|  5.01k|   word3_add(&w2, &w1, &w0, z[42]);
 1525|  5.01k|   ws[18] = w0;
 1526|  5.01k|   w0 = w1;
 1527|  5.01k|   w1 = w2;
 1528|  5.01k|   w2 = 0;
 1529|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[20], p[23]);
 1530|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[22]);
 1531|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[21]);
 1532|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[20]);
 1533|  5.01k|   word3_add(&w2, &w1, &w0, z[43]);
 1534|  5.01k|   ws[19] = w0;
 1535|  5.01k|   w0 = w1;
 1536|  5.01k|   w1 = w2;
 1537|  5.01k|   w2 = 0;
 1538|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[21], p[23]);
 1539|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[22]);
 1540|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[21]);
 1541|  5.01k|   word3_add(&w2, &w1, &w0, z[44]);
 1542|  5.01k|   ws[20] = w0;
 1543|  5.01k|   w0 = w1;
 1544|  5.01k|   w1 = w2;
 1545|  5.01k|   w2 = 0;
 1546|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[22], p[23]);
 1547|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[22]);
 1548|  5.01k|   word3_add(&w2, &w1, &w0, z[45]);
 1549|  5.01k|   ws[21] = w0;
 1550|  5.01k|   w0 = w1;
 1551|  5.01k|   w1 = w2;
 1552|  5.01k|   w2 = 0;
 1553|  5.01k|   word3_muladd(&w2, &w1, &w0, ws[23], p[23]);
 1554|  5.01k|   word3_add(&w2, &w1, &w0, z[46]);
 1555|  5.01k|   ws[22] = w0;
 1556|  5.01k|   w0 = w1;
 1557|  5.01k|   w1 = w2;
 1558|  5.01k|   w2 = 0;
 1559|  5.01k|   word3_add(&w2, &w1, &w0, z[47]);
 1560|  5.01k|   ws[23] = w0;
 1561|  5.01k|   ws[24] = w1;
 1562|  5.01k|   word borrow = bigint_sub3(z, ws, 24 + 1, p, 24);
 1563|  5.01k|   CT::conditional_assign_mem(borrow, z, ws, 24);
 1564|  5.01k|   clear_mem(z + 24, 24);
 1565|  5.01k|}
_ZN5Botan20bigint_monty_redc_32EPmPKmmS0_:
 1567|  10.1k|void bigint_monty_redc_32(word z[64], const word p[32], word p_dash, word ws[]) {
 1568|  10.1k|   word w2 = 0, w1 = 0, w0 = 0;
 1569|  10.1k|   w0 = z[0];
 1570|  10.1k|   ws[0] = w0 * p_dash;
 1571|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
 1572|  10.1k|   w0 = w1;
 1573|  10.1k|   w1 = w2;
 1574|  10.1k|   w2 = 0;
 1575|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[1]);
 1576|  10.1k|   word3_add(&w2, &w1, &w0, z[1]);
 1577|  10.1k|   ws[1] = w0 * p_dash;
 1578|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[0]);
 1579|  10.1k|   w0 = w1;
 1580|  10.1k|   w1 = w2;
 1581|  10.1k|   w2 = 0;
 1582|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[2]);
 1583|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[1]);
 1584|  10.1k|   word3_add(&w2, &w1, &w0, z[2]);
 1585|  10.1k|   ws[2] = w0 * p_dash;
 1586|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[0]);
 1587|  10.1k|   w0 = w1;
 1588|  10.1k|   w1 = w2;
 1589|  10.1k|   w2 = 0;
 1590|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[3]);
 1591|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[2]);
 1592|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[1]);
 1593|  10.1k|   word3_add(&w2, &w1, &w0, z[3]);
 1594|  10.1k|   ws[3] = w0 * p_dash;
 1595|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[0]);
 1596|  10.1k|   w0 = w1;
 1597|  10.1k|   w1 = w2;
 1598|  10.1k|   w2 = 0;
 1599|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[4]);
 1600|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[3]);
 1601|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[2]);
 1602|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[1]);
 1603|  10.1k|   word3_add(&w2, &w1, &w0, z[4]);
 1604|  10.1k|   ws[4] = w0 * p_dash;
 1605|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[0]);
 1606|  10.1k|   w0 = w1;
 1607|  10.1k|   w1 = w2;
 1608|  10.1k|   w2 = 0;
 1609|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[5]);
 1610|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[4]);
 1611|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[3]);
 1612|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[2]);
 1613|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[1]);
 1614|  10.1k|   word3_add(&w2, &w1, &w0, z[5]);
 1615|  10.1k|   ws[5] = w0 * p_dash;
 1616|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[0]);
 1617|  10.1k|   w0 = w1;
 1618|  10.1k|   w1 = w2;
 1619|  10.1k|   w2 = 0;
 1620|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[6]);
 1621|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[5]);
 1622|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[4]);
 1623|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[3]);
 1624|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[2]);
 1625|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[1]);
 1626|  10.1k|   word3_add(&w2, &w1, &w0, z[6]);
 1627|  10.1k|   ws[6] = w0 * p_dash;
 1628|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[0]);
 1629|  10.1k|   w0 = w1;
 1630|  10.1k|   w1 = w2;
 1631|  10.1k|   w2 = 0;
 1632|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[7]);
 1633|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[6]);
 1634|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[5]);
 1635|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[4]);
 1636|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[3]);
 1637|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[2]);
 1638|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[1]);
 1639|  10.1k|   word3_add(&w2, &w1, &w0, z[7]);
 1640|  10.1k|   ws[7] = w0 * p_dash;
 1641|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[0]);
 1642|  10.1k|   w0 = w1;
 1643|  10.1k|   w1 = w2;
 1644|  10.1k|   w2 = 0;
 1645|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[8]);
 1646|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[7]);
 1647|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[6]);
 1648|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[5]);
 1649|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[4]);
 1650|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[3]);
 1651|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[2]);
 1652|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[1]);
 1653|  10.1k|   word3_add(&w2, &w1, &w0, z[8]);
 1654|  10.1k|   ws[8] = w0 * p_dash;
 1655|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[0]);
 1656|  10.1k|   w0 = w1;
 1657|  10.1k|   w1 = w2;
 1658|  10.1k|   w2 = 0;
 1659|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[9]);
 1660|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[8]);
 1661|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[7]);
 1662|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[6]);
 1663|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[5]);
 1664|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[4]);
 1665|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[3]);
 1666|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[2]);
 1667|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[1]);
 1668|  10.1k|   word3_add(&w2, &w1, &w0, z[9]);
 1669|  10.1k|   ws[9] = w0 * p_dash;
 1670|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[0]);
 1671|  10.1k|   w0 = w1;
 1672|  10.1k|   w1 = w2;
 1673|  10.1k|   w2 = 0;
 1674|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[10]);
 1675|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[9]);
 1676|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[8]);
 1677|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[7]);
 1678|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[6]);
 1679|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[5]);
 1680|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[4]);
 1681|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[3]);
 1682|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[2]);
 1683|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[1]);
 1684|  10.1k|   word3_add(&w2, &w1, &w0, z[10]);
 1685|  10.1k|   ws[10] = w0 * p_dash;
 1686|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[0]);
 1687|  10.1k|   w0 = w1;
 1688|  10.1k|   w1 = w2;
 1689|  10.1k|   w2 = 0;
 1690|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[11]);
 1691|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[10]);
 1692|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[9]);
 1693|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[8]);
 1694|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[7]);
 1695|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[6]);
 1696|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[5]);
 1697|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[4]);
 1698|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[3]);
 1699|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[2]);
 1700|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[1]);
 1701|  10.1k|   word3_add(&w2, &w1, &w0, z[11]);
 1702|  10.1k|   ws[11] = w0 * p_dash;
 1703|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[0]);
 1704|  10.1k|   w0 = w1;
 1705|  10.1k|   w1 = w2;
 1706|  10.1k|   w2 = 0;
 1707|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[12]);
 1708|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[11]);
 1709|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[10]);
 1710|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[9]);
 1711|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[8]);
 1712|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[7]);
 1713|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[6]);
 1714|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[5]);
 1715|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[4]);
 1716|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[3]);
 1717|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[2]);
 1718|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[1]);
 1719|  10.1k|   word3_add(&w2, &w1, &w0, z[12]);
 1720|  10.1k|   ws[12] = w0 * p_dash;
 1721|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[0]);
 1722|  10.1k|   w0 = w1;
 1723|  10.1k|   w1 = w2;
 1724|  10.1k|   w2 = 0;
 1725|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[13]);
 1726|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[12]);
 1727|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[11]);
 1728|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[10]);
 1729|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[9]);
 1730|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[8]);
 1731|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[7]);
 1732|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[6]);
 1733|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[5]);
 1734|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[4]);
 1735|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[3]);
 1736|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[2]);
 1737|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[1]);
 1738|  10.1k|   word3_add(&w2, &w1, &w0, z[13]);
 1739|  10.1k|   ws[13] = w0 * p_dash;
 1740|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[0]);
 1741|  10.1k|   w0 = w1;
 1742|  10.1k|   w1 = w2;
 1743|  10.1k|   w2 = 0;
 1744|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[14]);
 1745|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[13]);
 1746|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[12]);
 1747|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[11]);
 1748|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[10]);
 1749|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[9]);
 1750|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[8]);
 1751|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[7]);
 1752|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[6]);
 1753|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[5]);
 1754|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[4]);
 1755|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[3]);
 1756|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[2]);
 1757|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[1]);
 1758|  10.1k|   word3_add(&w2, &w1, &w0, z[14]);
 1759|  10.1k|   ws[14] = w0 * p_dash;
 1760|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[0]);
 1761|  10.1k|   w0 = w1;
 1762|  10.1k|   w1 = w2;
 1763|  10.1k|   w2 = 0;
 1764|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[15]);
 1765|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[14]);
 1766|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[13]);
 1767|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[12]);
 1768|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[11]);
 1769|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[10]);
 1770|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[9]);
 1771|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[8]);
 1772|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[7]);
 1773|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[6]);
 1774|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[5]);
 1775|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[4]);
 1776|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[3]);
 1777|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[2]);
 1778|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[1]);
 1779|  10.1k|   word3_add(&w2, &w1, &w0, z[15]);
 1780|  10.1k|   ws[15] = w0 * p_dash;
 1781|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[0]);
 1782|  10.1k|   w0 = w1;
 1783|  10.1k|   w1 = w2;
 1784|  10.1k|   w2 = 0;
 1785|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[16]);
 1786|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[15]);
 1787|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[14]);
 1788|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[13]);
 1789|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[12]);
 1790|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[11]);
 1791|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[10]);
 1792|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[9]);
 1793|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[8]);
 1794|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[7]);
 1795|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[6]);
 1796|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[5]);
 1797|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[4]);
 1798|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[3]);
 1799|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[2]);
 1800|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[1]);
 1801|  10.1k|   word3_add(&w2, &w1, &w0, z[16]);
 1802|  10.1k|   ws[16] = w0 * p_dash;
 1803|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[0]);
 1804|  10.1k|   w0 = w1;
 1805|  10.1k|   w1 = w2;
 1806|  10.1k|   w2 = 0;
 1807|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[17]);
 1808|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[16]);
 1809|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[15]);
 1810|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[14]);
 1811|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[13]);
 1812|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[12]);
 1813|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[11]);
 1814|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[10]);
 1815|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[9]);
 1816|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[8]);
 1817|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[7]);
 1818|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[6]);
 1819|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[5]);
 1820|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[4]);
 1821|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[3]);
 1822|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[2]);
 1823|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[1]);
 1824|  10.1k|   word3_add(&w2, &w1, &w0, z[17]);
 1825|  10.1k|   ws[17] = w0 * p_dash;
 1826|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[0]);
 1827|  10.1k|   w0 = w1;
 1828|  10.1k|   w1 = w2;
 1829|  10.1k|   w2 = 0;
 1830|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[18]);
 1831|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[17]);
 1832|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[16]);
 1833|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[15]);
 1834|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[14]);
 1835|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[13]);
 1836|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[12]);
 1837|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[11]);
 1838|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[10]);
 1839|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[9]);
 1840|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[8]);
 1841|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[7]);
 1842|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[6]);
 1843|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[5]);
 1844|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[4]);
 1845|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[3]);
 1846|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[2]);
 1847|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[1]);
 1848|  10.1k|   word3_add(&w2, &w1, &w0, z[18]);
 1849|  10.1k|   ws[18] = w0 * p_dash;
 1850|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[0]);
 1851|  10.1k|   w0 = w1;
 1852|  10.1k|   w1 = w2;
 1853|  10.1k|   w2 = 0;
 1854|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[19]);
 1855|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[18]);
 1856|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[17]);
 1857|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[16]);
 1858|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[15]);
 1859|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[14]);
 1860|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[13]);
 1861|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[12]);
 1862|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[11]);
 1863|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[10]);
 1864|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[9]);
 1865|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[8]);
 1866|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[7]);
 1867|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[6]);
 1868|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[5]);
 1869|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[4]);
 1870|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[3]);
 1871|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[2]);
 1872|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[1]);
 1873|  10.1k|   word3_add(&w2, &w1, &w0, z[19]);
 1874|  10.1k|   ws[19] = w0 * p_dash;
 1875|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[0]);
 1876|  10.1k|   w0 = w1;
 1877|  10.1k|   w1 = w2;
 1878|  10.1k|   w2 = 0;
 1879|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[20]);
 1880|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[19]);
 1881|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[18]);
 1882|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[17]);
 1883|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[16]);
 1884|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[15]);
 1885|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[14]);
 1886|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[13]);
 1887|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[12]);
 1888|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[11]);
 1889|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[10]);
 1890|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[9]);
 1891|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[8]);
 1892|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[7]);
 1893|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[6]);
 1894|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[5]);
 1895|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[4]);
 1896|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[3]);
 1897|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[2]);
 1898|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[1]);
 1899|  10.1k|   word3_add(&w2, &w1, &w0, z[20]);
 1900|  10.1k|   ws[20] = w0 * p_dash;
 1901|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[0]);
 1902|  10.1k|   w0 = w1;
 1903|  10.1k|   w1 = w2;
 1904|  10.1k|   w2 = 0;
 1905|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[21]);
 1906|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[20]);
 1907|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[19]);
 1908|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[18]);
 1909|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[17]);
 1910|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[16]);
 1911|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[15]);
 1912|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[14]);
 1913|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[13]);
 1914|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[12]);
 1915|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[11]);
 1916|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[10]);
 1917|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[9]);
 1918|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[8]);
 1919|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[7]);
 1920|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[6]);
 1921|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[5]);
 1922|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[4]);
 1923|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[3]);
 1924|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[2]);
 1925|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[1]);
 1926|  10.1k|   word3_add(&w2, &w1, &w0, z[21]);
 1927|  10.1k|   ws[21] = w0 * p_dash;
 1928|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[0]);
 1929|  10.1k|   w0 = w1;
 1930|  10.1k|   w1 = w2;
 1931|  10.1k|   w2 = 0;
 1932|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[22]);
 1933|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[21]);
 1934|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[20]);
 1935|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[19]);
 1936|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[18]);
 1937|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[17]);
 1938|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[16]);
 1939|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[15]);
 1940|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[14]);
 1941|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[13]);
 1942|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[12]);
 1943|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[11]);
 1944|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[10]);
 1945|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[9]);
 1946|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[8]);
 1947|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[7]);
 1948|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[6]);
 1949|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[5]);
 1950|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[4]);
 1951|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[3]);
 1952|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[2]);
 1953|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[1]);
 1954|  10.1k|   word3_add(&w2, &w1, &w0, z[22]);
 1955|  10.1k|   ws[22] = w0 * p_dash;
 1956|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[0]);
 1957|  10.1k|   w0 = w1;
 1958|  10.1k|   w1 = w2;
 1959|  10.1k|   w2 = 0;
 1960|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[23]);
 1961|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[22]);
 1962|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[21]);
 1963|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[20]);
 1964|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[19]);
 1965|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[18]);
 1966|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[17]);
 1967|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[16]);
 1968|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[15]);
 1969|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[14]);
 1970|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[13]);
 1971|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[12]);
 1972|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[11]);
 1973|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[10]);
 1974|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[9]);
 1975|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[8]);
 1976|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[7]);
 1977|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[6]);
 1978|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[5]);
 1979|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[4]);
 1980|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[3]);
 1981|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[2]);
 1982|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[1]);
 1983|  10.1k|   word3_add(&w2, &w1, &w0, z[23]);
 1984|  10.1k|   ws[23] = w0 * p_dash;
 1985|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[0]);
 1986|  10.1k|   w0 = w1;
 1987|  10.1k|   w1 = w2;
 1988|  10.1k|   w2 = 0;
 1989|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[24]);
 1990|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[23]);
 1991|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[22]);
 1992|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[21]);
 1993|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[20]);
 1994|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[19]);
 1995|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[18]);
 1996|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[17]);
 1997|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[16]);
 1998|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[15]);
 1999|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[14]);
 2000|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[13]);
 2001|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[12]);
 2002|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[11]);
 2003|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[10]);
 2004|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[9]);
 2005|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[8]);
 2006|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[7]);
 2007|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[6]);
 2008|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[5]);
 2009|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[4]);
 2010|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[3]);
 2011|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[2]);
 2012|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[1]);
 2013|  10.1k|   word3_add(&w2, &w1, &w0, z[24]);
 2014|  10.1k|   ws[24] = w0 * p_dash;
 2015|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[0]);
 2016|  10.1k|   w0 = w1;
 2017|  10.1k|   w1 = w2;
 2018|  10.1k|   w2 = 0;
 2019|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[25]);
 2020|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[24]);
 2021|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[23]);
 2022|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[22]);
 2023|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[21]);
 2024|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[20]);
 2025|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[19]);
 2026|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[18]);
 2027|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[17]);
 2028|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[16]);
 2029|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[15]);
 2030|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[14]);
 2031|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[13]);
 2032|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[12]);
 2033|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[11]);
 2034|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[10]);
 2035|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[9]);
 2036|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[8]);
 2037|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[7]);
 2038|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[6]);
 2039|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[5]);
 2040|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[4]);
 2041|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[3]);
 2042|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[2]);
 2043|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[1]);
 2044|  10.1k|   word3_add(&w2, &w1, &w0, z[25]);
 2045|  10.1k|   ws[25] = w0 * p_dash;
 2046|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[0]);
 2047|  10.1k|   w0 = w1;
 2048|  10.1k|   w1 = w2;
 2049|  10.1k|   w2 = 0;
 2050|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[26]);
 2051|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[25]);
 2052|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[24]);
 2053|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[23]);
 2054|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[22]);
 2055|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[21]);
 2056|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[20]);
 2057|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[19]);
 2058|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[18]);
 2059|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[17]);
 2060|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[16]);
 2061|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[15]);
 2062|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[14]);
 2063|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[13]);
 2064|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[12]);
 2065|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[11]);
 2066|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[10]);
 2067|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[9]);
 2068|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[8]);
 2069|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[7]);
 2070|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[6]);
 2071|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[5]);
 2072|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[4]);
 2073|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[3]);
 2074|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[2]);
 2075|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[1]);
 2076|  10.1k|   word3_add(&w2, &w1, &w0, z[26]);
 2077|  10.1k|   ws[26] = w0 * p_dash;
 2078|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[0]);
 2079|  10.1k|   w0 = w1;
 2080|  10.1k|   w1 = w2;
 2081|  10.1k|   w2 = 0;
 2082|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[27]);
 2083|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[26]);
 2084|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[25]);
 2085|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[24]);
 2086|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[23]);
 2087|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[22]);
 2088|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[21]);
 2089|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[20]);
 2090|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[19]);
 2091|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[18]);
 2092|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[17]);
 2093|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[16]);
 2094|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[15]);
 2095|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[14]);
 2096|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[13]);
 2097|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[12]);
 2098|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[11]);
 2099|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[10]);
 2100|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[9]);
 2101|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[8]);
 2102|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[7]);
 2103|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[6]);
 2104|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[5]);
 2105|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[4]);
 2106|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[3]);
 2107|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[2]);
 2108|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[1]);
 2109|  10.1k|   word3_add(&w2, &w1, &w0, z[27]);
 2110|  10.1k|   ws[27] = w0 * p_dash;
 2111|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[0]);
 2112|  10.1k|   w0 = w1;
 2113|  10.1k|   w1 = w2;
 2114|  10.1k|   w2 = 0;
 2115|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[28]);
 2116|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[27]);
 2117|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[26]);
 2118|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[25]);
 2119|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[24]);
 2120|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[23]);
 2121|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[22]);
 2122|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[21]);
 2123|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[20]);
 2124|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[19]);
 2125|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[18]);
 2126|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[17]);
 2127|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[16]);
 2128|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[15]);
 2129|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[14]);
 2130|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[13]);
 2131|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[12]);
 2132|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[11]);
 2133|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[10]);
 2134|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[9]);
 2135|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[8]);
 2136|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[7]);
 2137|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[6]);
 2138|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[5]);
 2139|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[4]);
 2140|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[3]);
 2141|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[2]);
 2142|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[1]);
 2143|  10.1k|   word3_add(&w2, &w1, &w0, z[28]);
 2144|  10.1k|   ws[28] = w0 * p_dash;
 2145|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[0]);
 2146|  10.1k|   w0 = w1;
 2147|  10.1k|   w1 = w2;
 2148|  10.1k|   w2 = 0;
 2149|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[29]);
 2150|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[28]);
 2151|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[27]);
 2152|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[26]);
 2153|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[25]);
 2154|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[24]);
 2155|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[23]);
 2156|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[22]);
 2157|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[21]);
 2158|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[20]);
 2159|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[19]);
 2160|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[18]);
 2161|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[17]);
 2162|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[16]);
 2163|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[15]);
 2164|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[14]);
 2165|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[13]);
 2166|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[12]);
 2167|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[11]);
 2168|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[10]);
 2169|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[9]);
 2170|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[8]);
 2171|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[7]);
 2172|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[6]);
 2173|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[5]);
 2174|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[4]);
 2175|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[3]);
 2176|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[2]);
 2177|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[1]);
 2178|  10.1k|   word3_add(&w2, &w1, &w0, z[29]);
 2179|  10.1k|   ws[29] = w0 * p_dash;
 2180|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[0]);
 2181|  10.1k|   w0 = w1;
 2182|  10.1k|   w1 = w2;
 2183|  10.1k|   w2 = 0;
 2184|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[30]);
 2185|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[29]);
 2186|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[28]);
 2187|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[27]);
 2188|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[26]);
 2189|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[25]);
 2190|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[24]);
 2191|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[23]);
 2192|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[22]);
 2193|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[21]);
 2194|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[20]);
 2195|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[19]);
 2196|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[18]);
 2197|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[17]);
 2198|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[16]);
 2199|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[15]);
 2200|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[14]);
 2201|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[13]);
 2202|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[12]);
 2203|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[11]);
 2204|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[10]);
 2205|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[9]);
 2206|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[8]);
 2207|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[7]);
 2208|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[6]);
 2209|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[5]);
 2210|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[4]);
 2211|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[3]);
 2212|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[2]);
 2213|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[1]);
 2214|  10.1k|   word3_add(&w2, &w1, &w0, z[30]);
 2215|  10.1k|   ws[30] = w0 * p_dash;
 2216|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[0]);
 2217|  10.1k|   w0 = w1;
 2218|  10.1k|   w1 = w2;
 2219|  10.1k|   w2 = 0;
 2220|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[0], p[31]);
 2221|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[30]);
 2222|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[29]);
 2223|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[28]);
 2224|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[27]);
 2225|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[26]);
 2226|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[25]);
 2227|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[24]);
 2228|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[23]);
 2229|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[22]);
 2230|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[21]);
 2231|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[20]);
 2232|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[19]);
 2233|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[18]);
 2234|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[17]);
 2235|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[16]);
 2236|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[15]);
 2237|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[14]);
 2238|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[13]);
 2239|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[12]);
 2240|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[11]);
 2241|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[10]);
 2242|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[9]);
 2243|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[8]);
 2244|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[7]);
 2245|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[6]);
 2246|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[5]);
 2247|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[4]);
 2248|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[3]);
 2249|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[2]);
 2250|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[1]);
 2251|  10.1k|   word3_add(&w2, &w1, &w0, z[31]);
 2252|  10.1k|   ws[31] = w0 * p_dash;
 2253|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[0]);
 2254|  10.1k|   w0 = w1;
 2255|  10.1k|   w1 = w2;
 2256|  10.1k|   w2 = 0;
 2257|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[1], p[31]);
 2258|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[30]);
 2259|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[29]);
 2260|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[28]);
 2261|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[27]);
 2262|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[26]);
 2263|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[25]);
 2264|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[24]);
 2265|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[23]);
 2266|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[22]);
 2267|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[21]);
 2268|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[20]);
 2269|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[19]);
 2270|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[18]);
 2271|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[17]);
 2272|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[16]);
 2273|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[15]);
 2274|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[14]);
 2275|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[13]);
 2276|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[12]);
 2277|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[11]);
 2278|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[10]);
 2279|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[9]);
 2280|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[8]);
 2281|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[7]);
 2282|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[6]);
 2283|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[5]);
 2284|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[4]);
 2285|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[3]);
 2286|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[2]);
 2287|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[1]);
 2288|  10.1k|   word3_add(&w2, &w1, &w0, z[32]);
 2289|  10.1k|   ws[0] = w0;
 2290|  10.1k|   w0 = w1;
 2291|  10.1k|   w1 = w2;
 2292|  10.1k|   w2 = 0;
 2293|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[2], p[31]);
 2294|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[30]);
 2295|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[29]);
 2296|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[28]);
 2297|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[27]);
 2298|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[26]);
 2299|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[25]);
 2300|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[24]);
 2301|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[23]);
 2302|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[22]);
 2303|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[21]);
 2304|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[20]);
 2305|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[19]);
 2306|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[18]);
 2307|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[17]);
 2308|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[16]);
 2309|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[15]);
 2310|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[14]);
 2311|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[13]);
 2312|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[12]);
 2313|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[11]);
 2314|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[10]);
 2315|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[9]);
 2316|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[8]);
 2317|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[7]);
 2318|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[6]);
 2319|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[5]);
 2320|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[4]);
 2321|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[3]);
 2322|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[2]);
 2323|  10.1k|   word3_add(&w2, &w1, &w0, z[33]);
 2324|  10.1k|   ws[1] = w0;
 2325|  10.1k|   w0 = w1;
 2326|  10.1k|   w1 = w2;
 2327|  10.1k|   w2 = 0;
 2328|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[3], p[31]);
 2329|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[30]);
 2330|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[29]);
 2331|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[28]);
 2332|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[27]);
 2333|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[26]);
 2334|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[25]);
 2335|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[24]);
 2336|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[23]);
 2337|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[22]);
 2338|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[21]);
 2339|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[20]);
 2340|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[19]);
 2341|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[18]);
 2342|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[17]);
 2343|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[16]);
 2344|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[15]);
 2345|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[14]);
 2346|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[13]);
 2347|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[12]);
 2348|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[11]);
 2349|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[10]);
 2350|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[9]);
 2351|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[8]);
 2352|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[7]);
 2353|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[6]);
 2354|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[5]);
 2355|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[4]);
 2356|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[3]);
 2357|  10.1k|   word3_add(&w2, &w1, &w0, z[34]);
 2358|  10.1k|   ws[2] = w0;
 2359|  10.1k|   w0 = w1;
 2360|  10.1k|   w1 = w2;
 2361|  10.1k|   w2 = 0;
 2362|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[4], p[31]);
 2363|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[30]);
 2364|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[29]);
 2365|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[28]);
 2366|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[27]);
 2367|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[26]);
 2368|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[25]);
 2369|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[24]);
 2370|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[23]);
 2371|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[22]);
 2372|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[21]);
 2373|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[20]);
 2374|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[19]);
 2375|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[18]);
 2376|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[17]);
 2377|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[16]);
 2378|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[15]);
 2379|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[14]);
 2380|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[13]);
 2381|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[12]);
 2382|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[11]);
 2383|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[10]);
 2384|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[9]);
 2385|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[8]);
 2386|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[7]);
 2387|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[6]);
 2388|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[5]);
 2389|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[4]);
 2390|  10.1k|   word3_add(&w2, &w1, &w0, z[35]);
 2391|  10.1k|   ws[3] = w0;
 2392|  10.1k|   w0 = w1;
 2393|  10.1k|   w1 = w2;
 2394|  10.1k|   w2 = 0;
 2395|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[5], p[31]);
 2396|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[30]);
 2397|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[29]);
 2398|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[28]);
 2399|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[27]);
 2400|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[26]);
 2401|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[25]);
 2402|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[24]);
 2403|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[23]);
 2404|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[22]);
 2405|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[21]);
 2406|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[20]);
 2407|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[19]);
 2408|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[18]);
 2409|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[17]);
 2410|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[16]);
 2411|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[15]);
 2412|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[14]);
 2413|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[13]);
 2414|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[12]);
 2415|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[11]);
 2416|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[10]);
 2417|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[9]);
 2418|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[8]);
 2419|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[7]);
 2420|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[6]);
 2421|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[5]);
 2422|  10.1k|   word3_add(&w2, &w1, &w0, z[36]);
 2423|  10.1k|   ws[4] = w0;
 2424|  10.1k|   w0 = w1;
 2425|  10.1k|   w1 = w2;
 2426|  10.1k|   w2 = 0;
 2427|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[6], p[31]);
 2428|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[30]);
 2429|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[29]);
 2430|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[28]);
 2431|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[27]);
 2432|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[26]);
 2433|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[25]);
 2434|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[24]);
 2435|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[23]);
 2436|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[22]);
 2437|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[21]);
 2438|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[20]);
 2439|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[19]);
 2440|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[18]);
 2441|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[17]);
 2442|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[16]);
 2443|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[15]);
 2444|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[14]);
 2445|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[13]);
 2446|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[12]);
 2447|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[11]);
 2448|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[10]);
 2449|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[9]);
 2450|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[8]);
 2451|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[7]);
 2452|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[6]);
 2453|  10.1k|   word3_add(&w2, &w1, &w0, z[37]);
 2454|  10.1k|   ws[5] = w0;
 2455|  10.1k|   w0 = w1;
 2456|  10.1k|   w1 = w2;
 2457|  10.1k|   w2 = 0;
 2458|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[7], p[31]);
 2459|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[30]);
 2460|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[29]);
 2461|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[28]);
 2462|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[27]);
 2463|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[26]);
 2464|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[25]);
 2465|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[24]);
 2466|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[23]);
 2467|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[22]);
 2468|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[21]);
 2469|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[20]);
 2470|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[19]);
 2471|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[18]);
 2472|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[17]);
 2473|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[16]);
 2474|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[15]);
 2475|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[14]);
 2476|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[13]);
 2477|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[12]);
 2478|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[11]);
 2479|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[10]);
 2480|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[9]);
 2481|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[8]);
 2482|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[7]);
 2483|  10.1k|   word3_add(&w2, &w1, &w0, z[38]);
 2484|  10.1k|   ws[6] = w0;
 2485|  10.1k|   w0 = w1;
 2486|  10.1k|   w1 = w2;
 2487|  10.1k|   w2 = 0;
 2488|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[8], p[31]);
 2489|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[30]);
 2490|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[29]);
 2491|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[28]);
 2492|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[27]);
 2493|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[26]);
 2494|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[25]);
 2495|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[24]);
 2496|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[23]);
 2497|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[22]);
 2498|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[21]);
 2499|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[20]);
 2500|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[19]);
 2501|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[18]);
 2502|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[17]);
 2503|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[16]);
 2504|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[15]);
 2505|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[14]);
 2506|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[13]);
 2507|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[12]);
 2508|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[11]);
 2509|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[10]);
 2510|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[9]);
 2511|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[8]);
 2512|  10.1k|   word3_add(&w2, &w1, &w0, z[39]);
 2513|  10.1k|   ws[7] = w0;
 2514|  10.1k|   w0 = w1;
 2515|  10.1k|   w1 = w2;
 2516|  10.1k|   w2 = 0;
 2517|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[9], p[31]);
 2518|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[30]);
 2519|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[29]);
 2520|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[28]);
 2521|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[27]);
 2522|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[26]);
 2523|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[25]);
 2524|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[24]);
 2525|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[23]);
 2526|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[22]);
 2527|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[21]);
 2528|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[20]);
 2529|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[19]);
 2530|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[18]);
 2531|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[17]);
 2532|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[16]);
 2533|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[15]);
 2534|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[14]);
 2535|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[13]);
 2536|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[12]);
 2537|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[11]);
 2538|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[10]);
 2539|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[9]);
 2540|  10.1k|   word3_add(&w2, &w1, &w0, z[40]);
 2541|  10.1k|   ws[8] = w0;
 2542|  10.1k|   w0 = w1;
 2543|  10.1k|   w1 = w2;
 2544|  10.1k|   w2 = 0;
 2545|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[10], p[31]);
 2546|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[30]);
 2547|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[29]);
 2548|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[28]);
 2549|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[27]);
 2550|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[26]);
 2551|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[25]);
 2552|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[24]);
 2553|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[23]);
 2554|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[22]);
 2555|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[21]);
 2556|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[20]);
 2557|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[19]);
 2558|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[18]);
 2559|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[17]);
 2560|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[16]);
 2561|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[15]);
 2562|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[14]);
 2563|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[13]);
 2564|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[12]);
 2565|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[11]);
 2566|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[10]);
 2567|  10.1k|   word3_add(&w2, &w1, &w0, z[41]);
 2568|  10.1k|   ws[9] = w0;
 2569|  10.1k|   w0 = w1;
 2570|  10.1k|   w1 = w2;
 2571|  10.1k|   w2 = 0;
 2572|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[11], p[31]);
 2573|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[30]);
 2574|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[29]);
 2575|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[28]);
 2576|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[27]);
 2577|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[26]);
 2578|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[25]);
 2579|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[24]);
 2580|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[23]);
 2581|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[22]);
 2582|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[21]);
 2583|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[20]);
 2584|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[19]);
 2585|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[18]);
 2586|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[17]);
 2587|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[16]);
 2588|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[15]);
 2589|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[14]);
 2590|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[13]);
 2591|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[12]);
 2592|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[11]);
 2593|  10.1k|   word3_add(&w2, &w1, &w0, z[42]);
 2594|  10.1k|   ws[10] = w0;
 2595|  10.1k|   w0 = w1;
 2596|  10.1k|   w1 = w2;
 2597|  10.1k|   w2 = 0;
 2598|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[12], p[31]);
 2599|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[30]);
 2600|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[29]);
 2601|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[28]);
 2602|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[27]);
 2603|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[26]);
 2604|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[25]);
 2605|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[24]);
 2606|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[23]);
 2607|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[22]);
 2608|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[21]);
 2609|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[20]);
 2610|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[19]);
 2611|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[18]);
 2612|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[17]);
 2613|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[16]);
 2614|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[15]);
 2615|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[14]);
 2616|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[13]);
 2617|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[12]);
 2618|  10.1k|   word3_add(&w2, &w1, &w0, z[43]);
 2619|  10.1k|   ws[11] = w0;
 2620|  10.1k|   w0 = w1;
 2621|  10.1k|   w1 = w2;
 2622|  10.1k|   w2 = 0;
 2623|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[13], p[31]);
 2624|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[30]);
 2625|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[29]);
 2626|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[28]);
 2627|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[27]);
 2628|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[26]);
 2629|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[25]);
 2630|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[24]);
 2631|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[23]);
 2632|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[22]);
 2633|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[21]);
 2634|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[20]);
 2635|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[19]);
 2636|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[18]);
 2637|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[17]);
 2638|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[16]);
 2639|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[15]);
 2640|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[14]);
 2641|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[13]);
 2642|  10.1k|   word3_add(&w2, &w1, &w0, z[44]);
 2643|  10.1k|   ws[12] = w0;
 2644|  10.1k|   w0 = w1;
 2645|  10.1k|   w1 = w2;
 2646|  10.1k|   w2 = 0;
 2647|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[14], p[31]);
 2648|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[30]);
 2649|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[29]);
 2650|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[28]);
 2651|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[27]);
 2652|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[26]);
 2653|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[25]);
 2654|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[24]);
 2655|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[23]);
 2656|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[22]);
 2657|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[21]);
 2658|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[20]);
 2659|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[19]);
 2660|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[18]);
 2661|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[17]);
 2662|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[16]);
 2663|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[15]);
 2664|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[14]);
 2665|  10.1k|   word3_add(&w2, &w1, &w0, z[45]);
 2666|  10.1k|   ws[13] = w0;
 2667|  10.1k|   w0 = w1;
 2668|  10.1k|   w1 = w2;
 2669|  10.1k|   w2 = 0;
 2670|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[15], p[31]);
 2671|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[30]);
 2672|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[29]);
 2673|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[28]);
 2674|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[27]);
 2675|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[26]);
 2676|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[25]);
 2677|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[24]);
 2678|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[23]);
 2679|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[22]);
 2680|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[21]);
 2681|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[20]);
 2682|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[19]);
 2683|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[18]);
 2684|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[17]);
 2685|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[16]);
 2686|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[15]);
 2687|  10.1k|   word3_add(&w2, &w1, &w0, z[46]);
 2688|  10.1k|   ws[14] = w0;
 2689|  10.1k|   w0 = w1;
 2690|  10.1k|   w1 = w2;
 2691|  10.1k|   w2 = 0;
 2692|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[16], p[31]);
 2693|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[30]);
 2694|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[29]);
 2695|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[28]);
 2696|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[27]);
 2697|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[26]);
 2698|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[25]);
 2699|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[24]);
 2700|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[23]);
 2701|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[22]);
 2702|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[21]);
 2703|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[20]);
 2704|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[19]);
 2705|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[18]);
 2706|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[17]);
 2707|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[16]);
 2708|  10.1k|   word3_add(&w2, &w1, &w0, z[47]);
 2709|  10.1k|   ws[15] = w0;
 2710|  10.1k|   w0 = w1;
 2711|  10.1k|   w1 = w2;
 2712|  10.1k|   w2 = 0;
 2713|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[17], p[31]);
 2714|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[30]);
 2715|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[29]);
 2716|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[28]);
 2717|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[27]);
 2718|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[26]);
 2719|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[25]);
 2720|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[24]);
 2721|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[23]);
 2722|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[22]);
 2723|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[21]);
 2724|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[20]);
 2725|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[19]);
 2726|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[18]);
 2727|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[17]);
 2728|  10.1k|   word3_add(&w2, &w1, &w0, z[48]);
 2729|  10.1k|   ws[16] = w0;
 2730|  10.1k|   w0 = w1;
 2731|  10.1k|   w1 = w2;
 2732|  10.1k|   w2 = 0;
 2733|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[18], p[31]);
 2734|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[30]);
 2735|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[29]);
 2736|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[28]);
 2737|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[27]);
 2738|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[26]);
 2739|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[25]);
 2740|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[24]);
 2741|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[23]);
 2742|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[22]);
 2743|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[21]);
 2744|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[20]);
 2745|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[19]);
 2746|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[18]);
 2747|  10.1k|   word3_add(&w2, &w1, &w0, z[49]);
 2748|  10.1k|   ws[17] = w0;
 2749|  10.1k|   w0 = w1;
 2750|  10.1k|   w1 = w2;
 2751|  10.1k|   w2 = 0;
 2752|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[19], p[31]);
 2753|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[30]);
 2754|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[29]);
 2755|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[28]);
 2756|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[27]);
 2757|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[26]);
 2758|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[25]);
 2759|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[24]);
 2760|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[23]);
 2761|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[22]);
 2762|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[21]);
 2763|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[20]);
 2764|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[19]);
 2765|  10.1k|   word3_add(&w2, &w1, &w0, z[50]);
 2766|  10.1k|   ws[18] = w0;
 2767|  10.1k|   w0 = w1;
 2768|  10.1k|   w1 = w2;
 2769|  10.1k|   w2 = 0;
 2770|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[20], p[31]);
 2771|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[30]);
 2772|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[29]);
 2773|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[28]);
 2774|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[27]);
 2775|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[26]);
 2776|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[25]);
 2777|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[24]);
 2778|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[23]);
 2779|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[22]);
 2780|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[21]);
 2781|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[20]);
 2782|  10.1k|   word3_add(&w2, &w1, &w0, z[51]);
 2783|  10.1k|   ws[19] = w0;
 2784|  10.1k|   w0 = w1;
 2785|  10.1k|   w1 = w2;
 2786|  10.1k|   w2 = 0;
 2787|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[21], p[31]);
 2788|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[30]);
 2789|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[29]);
 2790|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[28]);
 2791|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[27]);
 2792|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[26]);
 2793|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[25]);
 2794|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[24]);
 2795|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[23]);
 2796|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[22]);
 2797|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[21]);
 2798|  10.1k|   word3_add(&w2, &w1, &w0, z[52]);
 2799|  10.1k|   ws[20] = w0;
 2800|  10.1k|   w0 = w1;
 2801|  10.1k|   w1 = w2;
 2802|  10.1k|   w2 = 0;
 2803|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[22], p[31]);
 2804|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[30]);
 2805|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[29]);
 2806|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[28]);
 2807|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[27]);
 2808|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[26]);
 2809|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[25]);
 2810|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[24]);
 2811|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[23]);
 2812|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[22]);
 2813|  10.1k|   word3_add(&w2, &w1, &w0, z[53]);
 2814|  10.1k|   ws[21] = w0;
 2815|  10.1k|   w0 = w1;
 2816|  10.1k|   w1 = w2;
 2817|  10.1k|   w2 = 0;
 2818|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[23], p[31]);
 2819|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[30]);
 2820|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[29]);
 2821|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[28]);
 2822|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[27]);
 2823|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[26]);
 2824|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[25]);
 2825|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[24]);
 2826|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[23]);
 2827|  10.1k|   word3_add(&w2, &w1, &w0, z[54]);
 2828|  10.1k|   ws[22] = w0;
 2829|  10.1k|   w0 = w1;
 2830|  10.1k|   w1 = w2;
 2831|  10.1k|   w2 = 0;
 2832|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[24], p[31]);
 2833|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[30]);
 2834|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[29]);
 2835|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[28]);
 2836|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[27]);
 2837|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[26]);
 2838|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[25]);
 2839|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[24]);
 2840|  10.1k|   word3_add(&w2, &w1, &w0, z[55]);
 2841|  10.1k|   ws[23] = w0;
 2842|  10.1k|   w0 = w1;
 2843|  10.1k|   w1 = w2;
 2844|  10.1k|   w2 = 0;
 2845|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[25], p[31]);
 2846|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[30]);
 2847|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[29]);
 2848|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[28]);
 2849|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[27]);
 2850|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[26]);
 2851|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[25]);
 2852|  10.1k|   word3_add(&w2, &w1, &w0, z[56]);
 2853|  10.1k|   ws[24] = w0;
 2854|  10.1k|   w0 = w1;
 2855|  10.1k|   w1 = w2;
 2856|  10.1k|   w2 = 0;
 2857|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[26], p[31]);
 2858|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[30]);
 2859|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[29]);
 2860|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[28]);
 2861|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[27]);
 2862|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[26]);
 2863|  10.1k|   word3_add(&w2, &w1, &w0, z[57]);
 2864|  10.1k|   ws[25] = w0;
 2865|  10.1k|   w0 = w1;
 2866|  10.1k|   w1 = w2;
 2867|  10.1k|   w2 = 0;
 2868|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[27], p[31]);
 2869|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[30]);
 2870|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[29]);
 2871|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[28]);
 2872|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[27]);
 2873|  10.1k|   word3_add(&w2, &w1, &w0, z[58]);
 2874|  10.1k|   ws[26] = w0;
 2875|  10.1k|   w0 = w1;
 2876|  10.1k|   w1 = w2;
 2877|  10.1k|   w2 = 0;
 2878|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[28], p[31]);
 2879|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[30]);
 2880|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[29]);
 2881|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[28]);
 2882|  10.1k|   word3_add(&w2, &w1, &w0, z[59]);
 2883|  10.1k|   ws[27] = w0;
 2884|  10.1k|   w0 = w1;
 2885|  10.1k|   w1 = w2;
 2886|  10.1k|   w2 = 0;
 2887|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[29], p[31]);
 2888|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[30]);
 2889|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[29]);
 2890|  10.1k|   word3_add(&w2, &w1, &w0, z[60]);
 2891|  10.1k|   ws[28] = w0;
 2892|  10.1k|   w0 = w1;
 2893|  10.1k|   w1 = w2;
 2894|  10.1k|   w2 = 0;
 2895|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[30], p[31]);
 2896|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[30]);
 2897|  10.1k|   word3_add(&w2, &w1, &w0, z[61]);
 2898|  10.1k|   ws[29] = w0;
 2899|  10.1k|   w0 = w1;
 2900|  10.1k|   w1 = w2;
 2901|  10.1k|   w2 = 0;
 2902|  10.1k|   word3_muladd(&w2, &w1, &w0, ws[31], p[31]);
 2903|  10.1k|   word3_add(&w2, &w1, &w0, z[62]);
 2904|  10.1k|   ws[30] = w0;
 2905|  10.1k|   w0 = w1;
 2906|  10.1k|   w1 = w2;
 2907|  10.1k|   w2 = 0;
 2908|  10.1k|   word3_add(&w2, &w1, &w0, z[63]);
 2909|  10.1k|   ws[31] = w0;
 2910|  10.1k|   ws[32] = w1;
 2911|  10.1k|   word borrow = bigint_sub3(z, ws, 32 + 1, p, 32);
 2912|  10.1k|   CT::conditional_assign_mem(borrow, z, ws, 32);
 2913|  10.1k|   clear_mem(z + 32, 32);
 2914|  10.1k|}

_ZN5Botan13monty_inverseEm:
   16|  1.45k|word monty_inverse(word a) {
   17|  1.45k|   if(a % 2 == 0) {
  ------------------
  |  Branch (17:7): [True: 0, False: 1.45k]
  ------------------
   18|      0|      throw Invalid_Argument("monty_inverse only valid for odd integers");
   19|      0|   }
   20|       |
   21|       |   /*
   22|       |   * From "A New Algorithm for Inversion mod p^k" by Çetin Kaya Koç
   23|       |   * https://eprint.iacr.org/2017/411.pdf sections 5 and 7.
   24|       |   */
   25|       |
   26|  1.45k|   word b = 1;
   27|  1.45k|   word r = 0;
   28|       |
   29|  94.7k|   for(size_t i = 0; i != BOTAN_MP_WORD_BITS; ++i) {
  ------------------
  |  |   50|  94.7k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  |  Branch (29:22): [True: 93.3k, False: 1.45k]
  ------------------
   30|  93.3k|      const word bi = b % 2;
   31|  93.3k|      r >>= 1;
   32|  93.3k|      r += bi << (BOTAN_MP_WORD_BITS - 1);
  ------------------
  |  |   50|  93.3k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   33|       |
   34|  93.3k|      b -= a * bi;
   35|  93.3k|      b >>= 1;
   36|  93.3k|   }
   37|       |
   38|       |   // Now invert in addition space
   39|  1.45k|   r = (MP_WORD_MAX - r) + 1;
   40|       |
   41|  1.45k|   return r;
   42|  1.45k|}
_ZN5Botan17Montgomery_ParamsC2ERKNS_6BigIntE:
   60|  1.45k|Montgomery_Params::Montgomery_Params(const BigInt& p) {
   61|  1.45k|   if(p.is_even() || p < 3) {
  ------------------
  |  Branch (61:7): [True: 0, False: 1.45k]
  |  Branch (61:22): [True: 0, False: 1.45k]
  ------------------
   62|      0|      throw Invalid_Argument("Montgomery_Params invalid modulus");
   63|      0|   }
   64|       |
   65|  1.45k|   m_p = p;
   66|  1.45k|   m_p_words = m_p.sig_words();
   67|  1.45k|   m_p_dash = monty_inverse(m_p.word_at(0));
   68|       |
   69|  1.45k|   const BigInt r = BigInt::power_of_2(m_p_words * BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|  1.45k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   70|       |
   71|       |   // It might be faster to use ct_modulo here vs setting up Barrett reduction?
   72|  1.45k|   Modular_Reducer mod_p(p);
   73|       |
   74|  1.45k|   m_r1 = mod_p.reduce(r);
   75|  1.45k|   m_r2 = mod_p.square(m_r1);
   76|  1.45k|   m_r3 = mod_p.multiply(m_r1, m_r2);
   77|  1.45k|}
_ZNK5Botan17Montgomery_Params4redcERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
   84|  1.36k|BigInt Montgomery_Params::redc(const BigInt& x, secure_vector<word>& ws) const {
   85|  1.36k|   const size_t output_size = m_p_words + 1;
   86|       |
   87|  1.36k|   if(ws.size() < output_size) {
  ------------------
  |  Branch (87:7): [True: 1.36k, False: 0]
  ------------------
   88|  1.36k|      ws.resize(output_size);
   89|  1.36k|   }
   90|       |
   91|  1.36k|   BigInt z = x;
   92|  1.36k|   z.grow_to(2 * m_p_words);
   93|       |
   94|  1.36k|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
   95|       |
   96|  1.36k|   return z;
   97|  1.36k|}
_ZNK5Botan17Montgomery_Params3mulERKNS_6BigIntES3_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   99|  1.36k|BigInt Montgomery_Params::mul(const BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  100|  1.36k|   const size_t output_size = 2 * m_p_words + 2;
  101|       |
  102|  1.36k|   if(ws.size() < output_size) {
  ------------------
  |  Branch (102:7): [True: 1.36k, False: 0]
  ------------------
  103|  1.36k|      ws.resize(output_size);
  104|  1.36k|   }
  105|       |
  106|  1.36k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|  1.36k|      do {                          \
  |  |  100|  1.36k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|  1.36k|   BOTAN_DEBUG_ASSERT(y.sig_words() <= m_p_words);
  ------------------
  |  |   99|  1.36k|      do {                          \
  |  |  100|  1.36k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  108|       |
  109|  1.36k|   BigInt z = BigInt::with_capacity(output_size);
  110|  1.36k|   bigint_mul(z.mutable_data(),
  111|  1.36k|              z.size(),
  112|  1.36k|              x.data(),
  113|  1.36k|              x.size(),
  114|  1.36k|              std::min(m_p_words, x.size()),
  115|  1.36k|              y.data(),
  116|  1.36k|              y.size(),
  117|  1.36k|              std::min(m_p_words, y.size()),
  118|  1.36k|              ws.data(),
  119|  1.36k|              ws.size());
  120|       |
  121|  1.36k|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
  122|       |
  123|  1.36k|   return z;
  124|  1.36k|}
_ZNK5Botan17Montgomery_Params6mul_byERNS_6BigIntERKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  182|   117k|void Montgomery_Params::mul_by(BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  183|   117k|   const size_t output_size = 2 * m_p_words;
  184|       |
  185|   117k|   if(ws.size() < 2 * output_size) {
  ------------------
  |  Branch (185:7): [True: 0, False: 117k]
  ------------------
  186|      0|      ws.resize(2 * output_size);
  187|      0|   }
  188|       |
  189|   117k|   word* z_data = &ws[0];
  190|   117k|   word* ws_data = &ws[output_size];
  191|       |
  192|   117k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|   117k|      do {                          \
  |  |  100|   117k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  193|       |
  194|   117k|   bigint_mul(z_data,
  195|   117k|              output_size,
  196|   117k|              x.data(),
  197|   117k|              x.size(),
  198|   117k|              std::min(m_p_words, x.size()),
  199|   117k|              y.data(),
  200|   117k|              y.size(),
  201|   117k|              std::min(m_p_words, y.size()),
  202|   117k|              ws_data,
  203|   117k|              output_size);
  204|       |
  205|   117k|   bigint_monty_redc(z_data, m_p.data(), m_p_words, m_p_dash, ws_data, output_size);
  206|       |
  207|   117k|   if(x.size() < output_size) {
  ------------------
  |  Branch (207:7): [True: 0, False: 117k]
  ------------------
  208|      0|      x.grow_to(output_size);
  209|      0|   }
  210|   117k|   copy_mem(x.mutable_data(), z_data, output_size);
  211|   117k|}
_ZNK5Botan17Montgomery_Params11square_thisERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  231|   330k|void Montgomery_Params::square_this(BigInt& x, secure_vector<word>& ws) const {
  232|   330k|   const size_t output_size = 2 * m_p_words;
  233|       |
  234|   330k|   if(ws.size() < 2 * output_size) {
  ------------------
  |  Branch (234:7): [True: 1.35k, False: 328k]
  ------------------
  235|  1.35k|      ws.resize(2 * output_size);
  236|  1.35k|   }
  237|       |
  238|   330k|   word* z_data = &ws[0];
  239|   330k|   word* ws_data = &ws[output_size];
  240|       |
  241|   330k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|   330k|      do {                          \
  |  |  100|   330k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  242|       |
  243|   330k|   bigint_sqr(z_data, output_size, x.data(), x.size(), std::min(m_p_words, x.size()), ws_data, output_size);
  244|       |
  245|   330k|   bigint_monty_redc(z_data, m_p.data(), m_p_words, m_p_dash, ws_data, output_size);
  246|       |
  247|   330k|   if(x.size() < output_size) {
  ------------------
  |  Branch (247:7): [True: 0, False: 330k]
  ------------------
  248|      0|      x.grow_to(output_size);
  249|      0|   }
  250|   330k|   copy_mem(x.mutable_data(), z_data, output_size);
  251|   330k|}
_ZN5Botan14Montgomery_IntC2ERKNSt3__110shared_ptrIKNS_17Montgomery_ParamsEEERKNS_6BigIntEb:
  256|  2.73k|      m_params(params) {
  257|  2.73k|   if(redc_needed == false) {
  ------------------
  |  Branch (257:7): [True: 1.36k, False: 1.36k]
  ------------------
  258|  1.36k|      m_v = v;
  259|  1.36k|   } else {
  260|  1.36k|      BOTAN_ASSERT_NOMSG(m_v < m_params->p());
  ------------------
  |  |   60|  1.36k|   do {                                                                     \
  |  |   61|  1.36k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.36k]
  |  |  ------------------
  |  |   62|  1.36k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.36k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  261|  1.36k|      secure_vector<word> ws;
  262|  1.36k|      m_v = m_params->mul(v, m_params->R2(), ws);
  263|  1.36k|   }
  264|  2.73k|}
_ZN5Botan14Montgomery_Int8fix_sizeEv:
  292|  2.73k|void Montgomery_Int::fix_size() {
  293|  2.73k|   const size_t p_words = m_params->p_words();
  294|       |
  295|  2.73k|   if(m_v.sig_words() > p_words) {
  ------------------
  |  Branch (295:7): [True: 0, False: 2.73k]
  ------------------
  296|      0|      throw Internal_Error("Montgomery_Int::fix_size v too large");
  297|      0|   }
  298|       |
  299|  2.73k|   m_v.grow_to(p_words);
  300|  2.73k|}
_ZNK5Botan14Montgomery_Int5valueEv:
  324|  1.36k|BigInt Montgomery_Int::value() const {
  325|  1.36k|   secure_vector<word> ws;
  326|  1.36k|   return m_params->redc(m_v, ws);
  327|  1.36k|}
_ZN5Botan14Montgomery_Int6mul_byERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  372|   117k|Montgomery_Int& Montgomery_Int::mul_by(const Montgomery_Int& other, secure_vector<word>& ws) {
  373|   117k|   m_params->mul_by(m_v, other.m_v, ws);
  374|   117k|   return (*this);
  375|   117k|}
_ZN5Botan14Montgomery_Int19square_this_n_timesERNSt3__16vectorImNS_16secure_allocatorImEEEEm:
  392|   330k|Montgomery_Int& Montgomery_Int::square_this_n_times(secure_vector<word>& ws, size_t n) {
  393|   660k|   for(size_t i = 0; i != n; ++i) {
  ------------------
  |  Branch (393:22): [True: 330k, False: 330k]
  ------------------
  394|   330k|      m_params->square_this(m_v, ws);
  395|   330k|   }
  396|   330k|   return (*this);
  397|   330k|}

_ZN5Botan30Montgomery_Exponentation_StateC2ERKNSt3__110shared_ptrIKNS_17Montgomery_ParamsEEERKNS_6BigIntEmb:
   40|  1.36k|      m_params(params), m_window_bits(window_bits == 0 ? 4 : window_bits) {
   41|  1.36k|   BOTAN_ARG_CHECK(g < m_params->p(), "Montgomery base too big");
  ------------------
  |  |   30|  1.36k|   do {                                                          \
  |  |   31|  1.36k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 1.36k]
  |  |  ------------------
  |  |   32|  1.36k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.36k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   42|       |
   43|  1.36k|   if(m_window_bits < 1 || m_window_bits > 12) {  // really even 8 is too large ...
  ------------------
  |  Branch (43:7): [True: 0, False: 1.36k]
  |  Branch (43:28): [True: 0, False: 1.36k]
  ------------------
   44|      0|      throw Invalid_Argument("Invalid window bits for Montgomery exponentiation");
   45|      0|   }
   46|       |
   47|  1.36k|   const size_t window_size = (static_cast<size_t>(1) << m_window_bits);
   48|       |
   49|  1.36k|   m_g.reserve(window_size);
   50|       |
   51|  1.36k|   m_g.push_back(Montgomery_Int(m_params, m_params->R1(), false));
   52|       |
   53|  1.36k|   m_g.push_back(Montgomery_Int(m_params, g));
   54|       |
   55|  1.36k|   for(size_t i = 2; i != window_size; ++i) {
  ------------------
  |  Branch (55:22): [True: 0, False: 1.36k]
  ------------------
   56|      0|      m_g.push_back(m_g[1] * m_g[i - 1]);
   57|      0|   }
   58|       |
   59|       |   // Resize each element to exactly p words
   60|  4.09k|   for(size_t i = 0; i != window_size; ++i) {
  ------------------
  |  Branch (60:22): [True: 2.73k, False: 1.36k]
  ------------------
   61|  2.73k|      m_g[i].fix_size();
   62|  2.73k|      if(const_time) {
  ------------------
  |  Branch (62:10): [True: 0, False: 2.73k]
  ------------------
   63|      0|         m_g[i].const_time_poison();
   64|      0|      }
   65|  2.73k|   }
   66|  1.36k|}
_ZNK5Botan30Montgomery_Exponentation_State22exponentiation_vartimeERKNS_6BigIntE:
  121|  1.36k|BigInt Montgomery_Exponentation_State::exponentiation_vartime(const BigInt& scalar) const {
  122|  1.36k|   const size_t exp_nibbles = (scalar.bits() + m_window_bits - 1) / m_window_bits;
  123|       |
  124|  1.36k|   secure_vector<word> ws;
  125|       |
  126|  1.36k|   if(exp_nibbles == 0) {
  ------------------
  |  Branch (126:7): [True: 0, False: 1.36k]
  ------------------
  127|      0|      return BigInt::one();
  128|      0|   }
  129|       |
  130|  1.36k|   Montgomery_Int x = m_g[scalar.get_substring(m_window_bits * (exp_nibbles - 1), m_window_bits)];
  131|       |
  132|   331k|   for(size_t i = exp_nibbles - 1; i > 0; --i) {
  ------------------
  |  Branch (132:36): [True: 330k, False: 1.36k]
  ------------------
  133|   330k|      x.square_this_n_times(ws, m_window_bits);
  134|       |
  135|   330k|      const uint32_t nibble = scalar.get_substring(m_window_bits * (i - 1), m_window_bits);
  136|   330k|      if(nibble > 0) {
  ------------------
  |  Branch (136:10): [True: 117k, False: 212k]
  ------------------
  137|   117k|         x.mul_by(m_g[nibble], ws);
  138|   117k|      }
  139|   330k|   }
  140|       |
  141|  1.36k|   x.const_time_unpoison();
  142|  1.36k|   return x.value();
  143|  1.36k|}
_ZN5Botan16monty_precomputeERKNSt3__110shared_ptrIKNS_17Montgomery_ParamsEEERKNS_6BigIntEmb:
  146|  1.36k|   const std::shared_ptr<const Montgomery_Params>& params, const BigInt& g, size_t window_bits, bool const_time) {
  147|  1.36k|   return std::make_shared<const Montgomery_Exponentation_State>(params, g, window_bits, const_time);
  148|  1.36k|}
_ZN5Botan21monty_execute_vartimeERKNS_30Montgomery_Exponentation_StateERKNS_6BigIntE:
  154|  1.36k|BigInt monty_execute_vartime(const Montgomery_Exponentation_State& precomputed_state, const BigInt& k) {
  155|  1.36k|   return precomputed_state.exponentiation_vartime(k);
  156|  1.36k|}

_ZN5Botan6squareERKNS_6BigIntE:
  157|  1.45k|BigInt square(const BigInt& x) {
  158|  1.45k|   BigInt z = x;
  159|  1.45k|   secure_vector<word> ws;
  160|  1.45k|   z.square(ws);
  161|  1.45k|   return z;
  162|  1.45k|}

_ZN5Botan15Modular_ReducerC2ERKNS_6BigIntE:
   19|  1.45k|Modular_Reducer::Modular_Reducer(const BigInt& mod) {
   20|  1.45k|   if(mod < 0) {
  ------------------
  |  Branch (20:7): [True: 0, False: 1.45k]
  ------------------
   21|      0|      throw Invalid_Argument("Modular_Reducer: modulus must be positive");
   22|      0|   }
   23|       |
   24|       |   // Left uninitialized if mod == 0
   25|  1.45k|   m_mod_words = 0;
   26|       |
   27|  1.45k|   if(mod > 0) {
  ------------------
  |  Branch (27:7): [True: 1.45k, False: 0]
  ------------------
   28|  1.45k|      m_modulus = mod;
   29|  1.45k|      m_mod_words = m_modulus.sig_words();
   30|       |
   31|       |      // Compute mu = floor(2^{2k} / m)
   32|  1.45k|      m_mu.set_bit(2 * BOTAN_MP_WORD_BITS * m_mod_words);
  ------------------
  |  |   50|  1.45k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   33|  1.45k|      m_mu = ct_divide(m_mu, m_modulus);
   34|  1.45k|   }
   35|  1.45k|}
_ZNK5Botan15Modular_Reducer6reduceERKNS_6BigIntE:
   37|  4.37k|BigInt Modular_Reducer::reduce(const BigInt& x) const {
   38|  4.37k|   BigInt r;
   39|  4.37k|   secure_vector<word> ws;
   40|  4.37k|   reduce(r, x, ws);
   41|  4.37k|   return r;
   42|  4.37k|}
_ZNK5Botan15Modular_Reducer6reduceERNS_6BigIntERKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   69|  4.37k|void Modular_Reducer::reduce(BigInt& t1, const BigInt& x, secure_vector<word>& ws) const {
   70|  4.37k|   if(&t1 == &x) {
  ------------------
  |  Branch (70:7): [True: 0, False: 4.37k]
  ------------------
   71|      0|      throw Invalid_State("Modular_Reducer arguments cannot alias");
   72|      0|   }
   73|  4.37k|   if(m_mod_words == 0) {
  ------------------
  |  Branch (73:7): [True: 0, False: 4.37k]
  ------------------
   74|      0|      throw Invalid_State("Modular_Reducer: Never initalized");
   75|      0|   }
   76|       |
   77|  4.37k|   const size_t x_sw = x.sig_words();
   78|       |
   79|  4.37k|   if(x_sw > 2 * m_mod_words) {
  ------------------
  |  Branch (79:7): [True: 0, False: 4.37k]
  ------------------
   80|       |      // too big, fall back to slow boat division
   81|      0|      t1 = ct_modulo(x, m_modulus);
   82|      0|      return;
   83|      0|   }
   84|       |
   85|  4.37k|   t1 = x;
   86|  4.37k|   t1.set_sign(BigInt::Positive);
   87|  4.37k|   t1 >>= (BOTAN_MP_WORD_BITS * (m_mod_words - 1));
  ------------------
  |  |   50|  4.37k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   88|       |
   89|  4.37k|   t1.mul(m_mu, ws);
   90|  4.37k|   t1 >>= (BOTAN_MP_WORD_BITS * (m_mod_words + 1));
  ------------------
  |  |   50|  4.37k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   91|       |
   92|       |   // TODO add masked mul to avoid computing high bits
   93|  4.37k|   t1.mul(m_modulus, ws);
   94|  4.37k|   t1.mask_bits(BOTAN_MP_WORD_BITS * (m_mod_words + 1));
  ------------------
  |  |   50|  4.37k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   95|       |
   96|  4.37k|   t1.rev_sub(x.data(), std::min(x_sw, m_mod_words + 1), ws);
   97|       |
   98|       |   /*
   99|       |   * If t1 < 0 then we must add b^(k+1) where b = 2^w. To avoid a
  100|       |   * side channel perform the addition unconditionally, with ws set
  101|       |   * to either b^(k+1) or else 0.
  102|       |   */
  103|  4.37k|   const word t1_neg = t1.is_negative();
  104|       |
  105|  4.37k|   if(ws.size() < m_mod_words + 2) {
  ------------------
  |  Branch (105:7): [True: 110, False: 4.26k]
  ------------------
  106|    110|      ws.resize(m_mod_words + 2);
  107|    110|   }
  108|  4.37k|   clear_mem(ws.data(), ws.size());
  109|  4.37k|   ws[m_mod_words + 1] = t1_neg;
  110|       |
  111|  4.37k|   t1.add(ws.data(), m_mod_words + 2, BigInt::Positive);
  112|       |
  113|       |   // Per HAC this step requires at most 2 subtractions
  114|  4.37k|   t1.ct_reduce_below(m_modulus, ws, 2);
  115|       |
  116|  4.37k|   cnd_rev_sub(t1.is_nonzero() && x.is_negative(), t1, m_modulus.data(), m_modulus.size(), ws);
  ------------------
  |  Branch (116:16): [True: 4.37k, False: 0]
  |  Branch (116:35): [True: 0, False: 4.37k]
  ------------------
  117|  4.37k|}
reducer.cpp:_ZN5Botan12_GLOBAL__N_111cnd_rev_subEbRNS_6BigIntEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
   49|  4.37k|void cnd_rev_sub(bool cnd, BigInt& x, const word y[], size_t y_sw, secure_vector<word>& ws) {
   50|  4.37k|   if(x.sign() != BigInt::Positive) {
  ------------------
  |  Branch (50:7): [True: 0, False: 4.37k]
  ------------------
   51|      0|      throw Invalid_State("BigInt::sub_rev requires this is positive");
   52|      0|   }
   53|       |
   54|  4.37k|   const size_t x_sw = x.sig_words();
   55|       |
   56|  4.37k|   const size_t max_words = std::max(x_sw, y_sw);
   57|  4.37k|   ws.resize(std::max(x_sw, y_sw));
   58|  4.37k|   clear_mem(ws.data(), ws.size());
   59|  4.37k|   x.grow_to(max_words);
   60|       |
   61|  4.37k|   const int32_t relative_size = bigint_sub_abs(ws.data(), x.data(), x_sw, y, y_sw);
   62|       |
   63|  4.37k|   x.cond_flip_sign((relative_size > 0) && cnd);
  ------------------
  |  Branch (63:21): [True: 0, False: 4.37k]
  |  Branch (63:44): [True: 0, False: 0]
  ------------------
   64|  4.37k|   bigint_cnd_swap(cnd, x.mutable_data(), ws.data(), max_words);
   65|  4.37k|}

_ZN5Botan4EMSA6createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   35|  1.44k|std::unique_ptr<EMSA> EMSA::create(std::string_view algo_spec) {
   36|  1.44k|   SCAN_Name req(algo_spec);
   37|       |
   38|  1.44k|#if defined(BOTAN_HAS_EMSA_PKCS1)
   39|  1.44k|   if(req.algo_name() == "EMSA_PKCS1" || req.algo_name() == "PKCS1v15" || req.algo_name() == "EMSA-PKCS1-v1_5" ||
  ------------------
  |  Branch (39:7): [True: 0, False: 1.44k]
  |  Branch (39:42): [True: 0, False: 1.44k]
  |  Branch (39:75): [True: 0, False: 1.44k]
  ------------------
   40|  1.44k|      req.algo_name() == "EMSA3") {
  ------------------
  |  Branch (40:7): [True: 1.44k, False: 1]
  ------------------
   41|  1.44k|      if(req.arg_count() == 2 && req.arg(0) == "Raw") {
  ------------------
  |  Branch (41:10): [True: 0, False: 1.44k]
  |  Branch (41:10): [True: 0, False: 1.44k]
  |  Branch (41:34): [True: 0, False: 0]
  ------------------
   42|      0|         return std::make_unique<EMSA_PKCS1v15_Raw>(req.arg(1));
   43|  1.44k|      } else if(req.arg_count() == 1) {
  ------------------
  |  Branch (43:17): [True: 1.44k, False: 0]
  ------------------
   44|  1.44k|         if(req.arg(0) == "Raw") {
  ------------------
  |  Branch (44:13): [True: 0, False: 1.44k]
  ------------------
   45|      0|            return std::make_unique<EMSA_PKCS1v15_Raw>();
   46|  1.44k|         } else {
   47|  1.44k|            if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (47:21): [True: 1.44k, False: 0]
  ------------------
   48|  1.44k|               return std::make_unique<EMSA_PKCS1v15>(std::move(hash));
   49|  1.44k|            }
   50|  1.44k|         }
   51|  1.44k|      }
   52|  1.44k|   }
   53|      1|#endif
   54|       |
   55|      1|#if defined(BOTAN_HAS_EMSA_PSSR)
   56|      1|   if(req.algo_name() == "PSS_Raw" || req.algo_name() == "PSSR_Raw") {
  ------------------
  |  Branch (56:7): [True: 0, False: 1]
  |  Branch (56:39): [True: 0, False: 1]
  ------------------
   57|      0|      if(req.arg_count_between(1, 3) && req.arg(1, "MGF1") == "MGF1") {
  ------------------
  |  Branch (57:10): [True: 0, False: 0]
  |  Branch (57:10): [True: 0, False: 0]
  |  Branch (57:41): [True: 0, False: 0]
  ------------------
   58|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (58:18): [True: 0, False: 0]
  ------------------
   59|      0|            if(req.arg_count() == 3) {
  ------------------
  |  Branch (59:16): [True: 0, False: 0]
  ------------------
   60|      0|               const size_t salt_size = req.arg_as_integer(2, 0);
   61|      0|               return std::make_unique<PSSR_Raw>(std::move(hash), salt_size);
   62|      0|            } else {
   63|      0|               return std::make_unique<PSSR_Raw>(std::move(hash));
   64|      0|            }
   65|      0|         }
   66|      0|      }
   67|      0|   }
   68|       |
   69|      1|   if(req.algo_name() == "PSS" || req.algo_name() == "PSSR" || req.algo_name() == "EMSA-PSS" ||
  ------------------
  |  Branch (69:7): [True: 0, False: 1]
  |  Branch (69:35): [True: 0, False: 1]
  |  Branch (69:64): [True: 0, False: 1]
  ------------------
   70|      1|      req.algo_name() == "PSS-MGF1" || req.algo_name() == "EMSA4") {
  ------------------
  |  Branch (70:7): [True: 0, False: 1]
  |  Branch (70:40): [True: 0, False: 1]
  ------------------
   71|      0|      if(req.arg_count_between(1, 3) && req.arg(1, "MGF1") == "MGF1") {
  ------------------
  |  Branch (71:10): [True: 0, False: 0]
  |  Branch (71:10): [True: 0, False: 0]
  |  Branch (71:41): [True: 0, False: 0]
  ------------------
   72|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (72:18): [True: 0, False: 0]
  ------------------
   73|      0|            if(req.arg_count() == 3) {
  ------------------
  |  Branch (73:16): [True: 0, False: 0]
  ------------------
   74|      0|               const size_t salt_size = req.arg_as_integer(2, 0);
   75|      0|               return std::make_unique<PSSR>(std::move(hash), salt_size);
   76|      0|            } else {
   77|      0|               return std::make_unique<PSSR>(std::move(hash));
   78|      0|            }
   79|      0|         }
   80|      0|      }
   81|      0|   }
   82|      1|#endif
   83|       |
   84|      1|#if defined(BOTAN_HAS_ISO_9796)
   85|      1|   if(req.algo_name() == "ISO_9796_DS2") {
  ------------------
  |  Branch (85:7): [True: 0, False: 1]
  ------------------
   86|      0|      if(req.arg_count_between(1, 3)) {
  ------------------
  |  Branch (86:10): [True: 0, False: 0]
  ------------------
   87|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (87:18): [True: 0, False: 0]
  ------------------
   88|      0|            const size_t salt_size = req.arg_as_integer(2, hash->output_length());
   89|      0|            const bool implicit = req.arg(1, "exp") == "imp";
   90|      0|            return std::make_unique<ISO_9796_DS2>(std::move(hash), implicit, salt_size);
   91|      0|         }
   92|      0|      }
   93|      0|   }
   94|       |   //ISO-9796-2 DS 3 is deterministic and DS2 without a salt
   95|      1|   if(req.algo_name() == "ISO_9796_DS3") {
  ------------------
  |  Branch (95:7): [True: 0, False: 1]
  ------------------
   96|      0|      if(req.arg_count_between(1, 2)) {
  ------------------
  |  Branch (96:10): [True: 0, False: 0]
  ------------------
   97|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (97:18): [True: 0, False: 0]
  ------------------
   98|      0|            const bool implicit = req.arg(1, "exp") == "imp";
   99|      0|            return std::make_unique<ISO_9796_DS3>(std::move(hash), implicit);
  100|      0|         }
  101|      0|      }
  102|      0|   }
  103|      1|#endif
  104|       |
  105|      1|#if defined(BOTAN_HAS_EMSA_X931)
  106|      1|   if(req.algo_name() == "EMSA_X931" || req.algo_name() == "EMSA2" || req.algo_name() == "X9.31") {
  ------------------
  |  Branch (106:7): [True: 0, False: 1]
  |  Branch (106:41): [True: 0, False: 1]
  |  Branch (106:71): [True: 0, False: 1]
  ------------------
  107|      0|      if(req.arg_count() == 1) {
  ------------------
  |  Branch (107:10): [True: 0, False: 0]
  ------------------
  108|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (108:18): [True: 0, False: 0]
  ------------------
  109|      0|            return std::make_unique<EMSA_X931>(std::move(hash));
  110|      0|         }
  111|      0|      }
  112|      0|   }
  113|      1|#endif
  114|       |
  115|      1|#if defined(BOTAN_HAS_EMSA_RAW)
  116|      1|   if(req.algo_name() == "Raw") {
  ------------------
  |  Branch (116:7): [True: 0, False: 1]
  ------------------
  117|      0|      if(req.arg_count() == 0) {
  ------------------
  |  Branch (117:10): [True: 0, False: 0]
  ------------------
  118|      0|         return std::make_unique<EMSA_Raw>();
  119|      0|      } else {
  120|      0|         auto hash = HashFunction::create(req.arg(0));
  121|      0|         if(hash) {
  ------------------
  |  Branch (121:13): [True: 0, False: 0]
  ------------------
  122|      0|            return std::make_unique<EMSA_Raw>(hash->output_length());
  123|      0|         }
  124|      0|      }
  125|      0|   }
  126|      1|#endif
  127|       |
  128|      1|   return nullptr;
  129|      1|}
_ZN5Botan4EMSA15create_or_throwENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  131|  1.44k|std::unique_ptr<EMSA> EMSA::create_or_throw(std::string_view algo_spec) {
  132|  1.44k|   auto emsa = EMSA::create(algo_spec);
  133|  1.44k|   if(emsa) {
  ------------------
  |  Branch (133:7): [True: 1.44k, False: 1]
  ------------------
  134|  1.44k|      return emsa;
  135|  1.44k|   }
  136|      1|   throw Algorithm_Not_Found(algo_spec);
  137|  1.44k|}

_ZN5Botan13EMSA_PKCS1v156updateEPKhm:
   42|  1.44k|void EMSA_PKCS1v15::update(const uint8_t input[], size_t length) {
   43|  1.44k|   m_hash->update(input, length);
   44|  1.44k|}
_ZN5Botan13EMSA_PKCS1v158raw_dataEv:
   46|  1.44k|std::vector<uint8_t> EMSA_PKCS1v15::raw_data() {
   47|  1.44k|   return m_hash->final_stdvec();
   48|  1.44k|}
_ZN5Botan13EMSA_PKCS1v156verifyERKNSt3__16vectorIhNS1_9allocatorIhEEEES7_m:
   60|  1.36k|bool EMSA_PKCS1v15::verify(const std::vector<uint8_t>& coded, const std::vector<uint8_t>& raw, size_t key_bits) {
   61|  1.36k|   if(raw.size() != m_hash->output_length()) {
  ------------------
  |  Branch (61:7): [True: 0, False: 1.36k]
  ------------------
   62|      0|      return false;
   63|      0|   }
   64|       |
   65|  1.36k|   try {
   66|  1.36k|      return coded == pkcs1v15_sig_encoding(raw, key_bits, m_hash_id);
   67|  1.36k|   } catch(...) {
   68|    310|      return false;
   69|    310|   }
   70|  1.36k|}
_ZN5Botan13EMSA_PKCS1v15C2ENSt3__110unique_ptrINS_12HashFunctionENS1_14default_deleteIS3_EEEE:
   72|  1.44k|EMSA_PKCS1v15::EMSA_PKCS1v15(std::unique_ptr<HashFunction> hash) : m_hash(std::move(hash)) {
   73|  1.44k|   m_hash_id = pkcs_hash_id(m_hash->name());
   74|  1.44k|}
emsa_pkcs1.cpp:_ZN5Botan12_GLOBAL__N_121pkcs1v15_sig_encodingERKNSt3__16vectorIhNS1_9allocatorIhEEEEmNS1_4spanIKhLm18446744073709551615EEE:
   20|  1.36k|                                           std::span<const uint8_t> hash_id) {
   21|  1.36k|   const size_t output_length = output_bits / 8;
   22|       |
   23|  1.36k|   if(output_length < hash_id.size() + msg.size() + 2 + 8) {
  ------------------
  |  Branch (23:7): [True: 310, False: 1.05k]
  ------------------
   24|    310|      throw Encoding_Error("pkcs1v15_sig_encoding: Output length is too small");
   25|    310|   }
   26|       |
   27|  1.05k|   std::vector<uint8_t> padded(output_length);
   28|  1.05k|   BufferStuffer stuffer(padded);
   29|       |
   30|  1.05k|   stuffer.append(0x01);
   31|  1.05k|   stuffer.append(0xFF, stuffer.remaining_capacity() - (1 + hash_id.size() + msg.size()));
   32|  1.05k|   stuffer.append(0x00);
   33|  1.05k|   stuffer.append(hash_id);
   34|  1.05k|   stuffer.append(msg);
   35|  1.05k|   BOTAN_ASSERT_NOMSG(stuffer.full());
  ------------------
  |  |   60|  1.05k|   do {                                                                     \
  |  |   61|  1.05k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.05k]
  |  |  ------------------
  |  |   62|  1.05k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.05k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   36|       |
   37|  1.05k|   return padded;
   38|  1.36k|}

_ZN5Botan12pkcs_hash_idENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   78|  1.44k|std::vector<uint8_t> pkcs_hash_id(std::string_view name) {
   79|       |   // Special case for SSL/TLS RSA signatures
   80|  1.44k|   if(name == "Parallel(MD5,SHA-1)") {
  ------------------
  |  Branch (80:7): [True: 0, False: 1.44k]
  ------------------
   81|      0|      return std::vector<uint8_t>();
   82|      0|   }
   83|       |
   84|       |   // If you add a value to this function, also update test_hash_id.cpp
   85|       |
   86|  1.44k|   if(name == "MD5") {
  ------------------
  |  Branch (86:7): [True: 1.21k, False: 231]
  ------------------
   87|  1.21k|      return std::vector<uint8_t>(MD5_PKCS_ID, MD5_PKCS_ID + sizeof(MD5_PKCS_ID));
   88|  1.21k|   }
   89|       |
   90|    231|   if(name == "RIPEMD-160") {
  ------------------
  |  Branch (90:7): [True: 0, False: 231]
  ------------------
   91|      0|      return std::vector<uint8_t>(RIPEMD_160_PKCS_ID, RIPEMD_160_PKCS_ID + sizeof(RIPEMD_160_PKCS_ID));
   92|      0|   }
   93|       |
   94|    231|   if(name == "SHA-1") {
  ------------------
  |  Branch (94:7): [True: 1, False: 230]
  ------------------
   95|      1|      return std::vector<uint8_t>(SHA_1_PKCS_ID, SHA_1_PKCS_ID + sizeof(SHA_1_PKCS_ID));
   96|      1|   }
   97|       |
   98|    230|   if(name == "SHA-224") {
  ------------------
  |  Branch (98:7): [True: 32, False: 198]
  ------------------
   99|     32|      return std::vector<uint8_t>(SHA_224_PKCS_ID, SHA_224_PKCS_ID + sizeof(SHA_224_PKCS_ID));
  100|     32|   }
  101|       |
  102|    198|   if(name == "SHA-256") {
  ------------------
  |  Branch (102:7): [True: 145, False: 53]
  ------------------
  103|    145|      return std::vector<uint8_t>(SHA_256_PKCS_ID, SHA_256_PKCS_ID + sizeof(SHA_256_PKCS_ID));
  104|    145|   }
  105|       |
  106|     53|   if(name == "SHA-384") {
  ------------------
  |  Branch (106:7): [True: 42, False: 11]
  ------------------
  107|     42|      return std::vector<uint8_t>(SHA_384_PKCS_ID, SHA_384_PKCS_ID + sizeof(SHA_384_PKCS_ID));
  108|     42|   }
  109|       |
  110|     11|   if(name == "SHA-512") {
  ------------------
  |  Branch (110:7): [True: 9, False: 2]
  ------------------
  111|      9|      return std::vector<uint8_t>(SHA_512_PKCS_ID, SHA_512_PKCS_ID + sizeof(SHA_512_PKCS_ID));
  112|      9|   }
  113|       |
  114|      2|   if(name == "SHA-512-256") {
  ------------------
  |  Branch (114:7): [True: 2, False: 0]
  ------------------
  115|      2|      return std::vector<uint8_t>(SHA_512_256_PKCS_ID, SHA_512_256_PKCS_ID + sizeof(SHA_512_256_PKCS_ID));
  116|      2|   }
  117|       |
  118|      0|   if(name == "SHA-3(224)") {
  ------------------
  |  Branch (118:7): [True: 0, False: 0]
  ------------------
  119|      0|      return std::vector<uint8_t>(SHA3_224_PKCS_ID, SHA3_224_PKCS_ID + sizeof(SHA3_224_PKCS_ID));
  120|      0|   }
  121|       |
  122|      0|   if(name == "SHA-3(256)") {
  ------------------
  |  Branch (122:7): [True: 0, False: 0]
  ------------------
  123|      0|      return std::vector<uint8_t>(SHA3_256_PKCS_ID, SHA3_256_PKCS_ID + sizeof(SHA3_256_PKCS_ID));
  124|      0|   }
  125|       |
  126|      0|   if(name == "SHA-3(384)") {
  ------------------
  |  Branch (126:7): [True: 0, False: 0]
  ------------------
  127|      0|      return std::vector<uint8_t>(SHA3_384_PKCS_ID, SHA3_384_PKCS_ID + sizeof(SHA3_384_PKCS_ID));
  128|      0|   }
  129|       |
  130|      0|   if(name == "SHA-3(512)") {
  ------------------
  |  Branch (130:7): [True: 0, False: 0]
  ------------------
  131|      0|      return std::vector<uint8_t>(SHA3_512_PKCS_ID, SHA3_512_PKCS_ID + sizeof(SHA3_512_PKCS_ID));
  132|      0|   }
  133|       |
  134|      0|   if(name == "SM3") {
  ------------------
  |  Branch (134:7): [True: 0, False: 0]
  ------------------
  135|      0|      return std::vector<uint8_t>(SM3_PKCS_ID, SM3_PKCS_ID + sizeof(SM3_PKCS_ID));
  136|      0|   }
  137|       |
  138|      0|   throw Invalid_Argument("No PKCS #1 identifier for " + std::string(name));
  139|      0|}

_ZN5Botan8PEM_Code6decodeERNS_10DataSourceERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   62|    257|secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   63|    257|   const size_t RANDOM_CHAR_LIMIT = 8;
   64|       |
   65|    257|   label.clear();
   66|       |
   67|    257|   const std::string PEM_HEADER1 = "-----BEGIN ";
   68|    257|   const std::string PEM_HEADER2 = "-----";
   69|    257|   size_t position = 0;
   70|       |
   71|  7.17k|   while(position != PEM_HEADER1.length()) {
  ------------------
  |  Branch (71:10): [True: 6.97k, False: 195]
  ------------------
   72|  6.97k|      uint8_t b;
   73|  6.97k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (73:10): [True: 61, False: 6.91k]
  ------------------
   74|     61|         throw Decoding_Error("PEM: No PEM header found");
   75|     61|      }
   76|  6.91k|      if(static_cast<char>(b) == PEM_HEADER1[position]) {
  ------------------
  |  Branch (76:10): [True: 2.41k, False: 4.49k]
  ------------------
   77|  2.41k|         ++position;
   78|  4.49k|      } else if(position >= RANDOM_CHAR_LIMIT) {
  ------------------
  |  Branch (78:17): [True: 1, False: 4.49k]
  ------------------
   79|      1|         throw Decoding_Error("PEM: Malformed PEM header");
   80|  4.49k|      } else {
   81|  4.49k|         position = 0;
   82|  4.49k|      }
   83|  6.91k|   }
   84|    195|   position = 0;
   85|  33.9k|   while(position != PEM_HEADER2.length()) {
  ------------------
  |  Branch (85:10): [True: 33.7k, False: 177]
  ------------------
   86|  33.7k|      uint8_t b;
   87|  33.7k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (87:10): [True: 13, False: 33.7k]
  ------------------
   88|     13|         throw Decoding_Error("PEM: No PEM header found");
   89|     13|      }
   90|  33.7k|      if(static_cast<char>(b) == PEM_HEADER2[position]) {
  ------------------
  |  Branch (90:10): [True: 896, False: 32.8k]
  ------------------
   91|    896|         ++position;
   92|  32.8k|      } else if(position) {
  ------------------
  |  Branch (92:17): [True: 5, False: 32.8k]
  ------------------
   93|      5|         throw Decoding_Error("PEM: Malformed PEM header");
   94|      5|      }
   95|       |
   96|  33.7k|      if(position == 0) {
  ------------------
  |  Branch (96:10): [True: 32.8k, False: 896]
  ------------------
   97|  32.8k|         label += static_cast<char>(b);
   98|  32.8k|      }
   99|  33.7k|   }
  100|       |
  101|    177|   std::vector<char> b64;
  102|       |
  103|    177|   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
  104|    177|   position = 0;
  105|  76.2k|   while(position != PEM_TRAILER.length()) {
  ------------------
  |  Branch (105:10): [True: 76.1k, False: 105]
  ------------------
  106|  76.1k|      uint8_t b;
  107|  76.1k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (107:10): [True: 64, False: 76.1k]
  ------------------
  108|     64|         throw Decoding_Error("PEM: No PEM trailer found");
  109|     64|      }
  110|  76.1k|      if(static_cast<char>(b) == PEM_TRAILER[position]) {
  ------------------
  |  Branch (110:10): [True: 2.13k, False: 73.9k]
  ------------------
  111|  2.13k|         ++position;
  112|  73.9k|      } else if(position) {
  ------------------
  |  Branch (112:17): [True: 8, False: 73.9k]
  ------------------
  113|      8|         throw Decoding_Error("PEM: Malformed PEM trailer");
  114|      8|      }
  115|       |
  116|  76.1k|      if(position == 0) {
  ------------------
  |  Branch (116:10): [True: 73.9k, False: 2.13k]
  ------------------
  117|  73.9k|         b64.push_back(b);
  118|  73.9k|      }
  119|  76.1k|   }
  120|       |
  121|    105|   return base64_decode(b64.data(), b64.size());
  122|    177|}
_ZN5Botan8PEM_Code7matchesERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
  137|  6.77k|bool matches(DataSource& source, std::string_view extra, size_t search_range) {
  138|  6.77k|   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
  139|       |
  140|  6.77k|   secure_vector<uint8_t> search_buf(search_range);
  141|  6.77k|   const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);
  142|       |
  143|  6.77k|   if(got < PEM_HEADER.length()) {
  ------------------
  |  Branch (143:7): [True: 24, False: 6.74k]
  ------------------
  144|     24|      return false;
  145|     24|   }
  146|       |
  147|  6.74k|   size_t index = 0;
  148|       |
  149|  4.47M|   for(size_t j = 0; j != got; ++j) {
  ------------------
  |  Branch (149:22): [True: 4.47M, False: 6.74k]
  ------------------
  150|  4.47M|      if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
  ------------------
  |  Branch (150:10): [True: 16.4k, False: 4.45M]
  ------------------
  151|  16.4k|         ++index;
  152|  4.45M|      } else {
  153|  4.45M|         index = 0;
  154|  4.45M|      }
  155|       |
  156|  4.47M|      if(index == PEM_HEADER.size()) {
  ------------------
  |  Branch (156:10): [True: 4, False: 4.47M]
  ------------------
  157|      4|         return true;
  158|      4|      }
  159|  4.47M|   }
  160|       |
  161|  6.74k|   return false;
  162|  6.74k|}

_ZN5Botan15load_public_keyERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   96|  2.65k|                                            [[maybe_unused]] std::span<const uint8_t> key_bits) {
   97|  2.65k|   const std::string oid_str = alg_id.oid().to_formatted_string();
   98|  2.65k|   const std::vector<std::string> alg_info = split_on(oid_str, '/');
   99|  2.65k|   std::string_view alg_name = alg_info[0];
  100|       |
  101|  2.65k|#if defined(BOTAN_HAS_RSA)
  102|  2.65k|   if(alg_name == "RSA") {
  ------------------
  |  Branch (102:7): [True: 1.71k, False: 940]
  ------------------
  103|  1.71k|      return std::make_unique<RSA_PublicKey>(alg_id, key_bits);
  104|  1.71k|   }
  105|    940|#endif
  106|       |
  107|    940|#if defined(BOTAN_HAS_CURVE_25519)
  108|    940|   if(alg_name == "Curve25519") {
  ------------------
  |  Branch (108:7): [True: 0, False: 940]
  ------------------
  109|      0|      return std::make_unique<Curve25519_PublicKey>(alg_id, key_bits);
  110|      0|   }
  111|    940|#endif
  112|       |
  113|    940|#if defined(BOTAN_HAS_MCELIECE)
  114|    940|   if(alg_name == "McEliece") {
  ------------------
  |  Branch (114:7): [True: 0, False: 940]
  ------------------
  115|      0|      return std::make_unique<McEliece_PublicKey>(key_bits);
  116|      0|   }
  117|    940|#endif
  118|       |
  119|    940|#if defined(BOTAN_HAS_FRODOKEM)
  120|    940|   if(alg_name == "FrodoKEM" || alg_name.starts_with("FrodoKEM-") || alg_name.starts_with("eFrodoKEM-")) {
  ------------------
  |  Branch (120:7): [True: 0, False: 940]
  |  Branch (120:33): [True: 0, False: 940]
  |  Branch (120:70): [True: 0, False: 940]
  ------------------
  121|      0|      return std::make_unique<FrodoKEM_PublicKey>(alg_id, key_bits);
  122|      0|   }
  123|    940|#endif
  124|       |
  125|    940|#if defined(BOTAN_HAS_KYBER) || defined(BOTAN_HAS_KYBER_90S)
  126|    940|   if(alg_name == "Kyber" || alg_name.starts_with("Kyber-")) {
  ------------------
  |  Branch (126:7): [True: 0, False: 940]
  |  Branch (126:30): [True: 0, False: 940]
  ------------------
  127|      0|      return std::make_unique<Kyber_PublicKey>(alg_id, key_bits);
  128|      0|   }
  129|    940|#endif
  130|       |
  131|    940|#if defined(BOTAN_HAS_ECDSA)
  132|    940|   if(alg_name == "ECDSA") {
  ------------------
  |  Branch (132:7): [True: 0, False: 940]
  ------------------
  133|      0|      return std::make_unique<ECDSA_PublicKey>(alg_id, key_bits);
  134|      0|   }
  135|    940|#endif
  136|       |
  137|    940|#if defined(BOTAN_HAS_ECDH)
  138|    940|   if(alg_name == "ECDH") {
  ------------------
  |  Branch (138:7): [True: 0, False: 940]
  ------------------
  139|      0|      return std::make_unique<ECDH_PublicKey>(alg_id, key_bits);
  140|      0|   }
  141|    940|#endif
  142|       |
  143|    940|#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
  144|    940|   if(alg_name == "DH") {
  ------------------
  |  Branch (144:7): [True: 0, False: 940]
  ------------------
  145|      0|      return std::make_unique<DH_PublicKey>(alg_id, key_bits);
  146|      0|   }
  147|    940|#endif
  148|       |
  149|    940|#if defined(BOTAN_HAS_DSA)
  150|    940|   if(alg_name == "DSA") {
  ------------------
  |  Branch (150:7): [True: 0, False: 940]
  ------------------
  151|      0|      return std::make_unique<DSA_PublicKey>(alg_id, key_bits);
  152|      0|   }
  153|    940|#endif
  154|       |
  155|    940|#if defined(BOTAN_HAS_ELGAMAL)
  156|    940|   if(alg_name == "ElGamal") {
  ------------------
  |  Branch (156:7): [True: 0, False: 940]
  ------------------
  157|      0|      return std::make_unique<ElGamal_PublicKey>(alg_id, key_bits);
  158|      0|   }
  159|    940|#endif
  160|       |
  161|    940|#if defined(BOTAN_HAS_ECGDSA)
  162|    940|   if(alg_name == "ECGDSA") {
  ------------------
  |  Branch (162:7): [True: 0, False: 940]
  ------------------
  163|      0|      return std::make_unique<ECGDSA_PublicKey>(alg_id, key_bits);
  164|      0|   }
  165|    940|#endif
  166|       |
  167|    940|#if defined(BOTAN_HAS_ECKCDSA)
  168|    940|   if(alg_name == "ECKCDSA") {
  ------------------
  |  Branch (168:7): [True: 0, False: 940]
  ------------------
  169|      0|      return std::make_unique<ECKCDSA_PublicKey>(alg_id, key_bits);
  170|      0|   }
  171|    940|#endif
  172|       |
  173|    940|#if defined(BOTAN_HAS_ED25519)
  174|    940|   if(alg_name == "Ed25519") {
  ------------------
  |  Branch (174:7): [True: 0, False: 940]
  ------------------
  175|      0|      return std::make_unique<Ed25519_PublicKey>(alg_id, key_bits);
  176|      0|   }
  177|    940|#endif
  178|       |
  179|    940|#if defined(BOTAN_HAS_GOST_34_10_2001)
  180|    940|   if(alg_name == "GOST-34.10" || alg_name == "GOST-34.10-2012-256" || alg_name == "GOST-34.10-2012-512") {
  ------------------
  |  Branch (180:7): [True: 0, False: 940]
  |  Branch (180:35): [True: 0, False: 940]
  |  Branch (180:72): [True: 0, False: 940]
  ------------------
  181|      0|      return std::make_unique<GOST_3410_PublicKey>(alg_id, key_bits);
  182|      0|   }
  183|    940|#endif
  184|       |
  185|    940|#if defined(BOTAN_HAS_SM2)
  186|    940|   if(alg_name == "SM2" || alg_name == "SM2_Sig" || alg_name == "SM2_Enc") {
  ------------------
  |  Branch (186:7): [True: 0, False: 940]
  |  Branch (186:28): [True: 0, False: 940]
  |  Branch (186:53): [True: 0, False: 940]
  ------------------
  187|      0|      return std::make_unique<SM2_PublicKey>(alg_id, key_bits);
  188|      0|   }
  189|    940|#endif
  190|       |
  191|    940|#if defined(BOTAN_HAS_XMSS_RFC8391)
  192|    940|   if(alg_name == "XMSS") {
  ------------------
  |  Branch (192:7): [True: 0, False: 940]
  ------------------
  193|      0|      return std::make_unique<XMSS_PublicKey>(key_bits);
  194|      0|   }
  195|    940|#endif
  196|       |
  197|    940|#if defined(BOTAN_HAS_DILITHIUM) || defined(BOTAN_HAS_DILITHIUM_AES)
  198|    940|   if(alg_name == "Dilithium" || alg_name.starts_with("Dilithium-")) {
  ------------------
  |  Branch (198:7): [True: 0, False: 940]
  |  Branch (198:34): [True: 0, False: 940]
  ------------------
  199|      0|      return std::make_unique<Dilithium_PublicKey>(alg_id, key_bits);
  200|      0|   }
  201|    940|#endif
  202|       |
  203|    940|#if defined(BOTAN_HAS_SPHINCS_PLUS_WITH_SHA2) || defined(BOTAN_HAS_SPHINCS_PLUS_WITH_SHAKE)
  204|    940|   if(alg_name == "SPHINCS+" || alg_name.starts_with("SphincsPlus-")) {
  ------------------
  |  Branch (204:7): [True: 0, False: 940]
  |  Branch (204:33): [True: 0, False: 940]
  ------------------
  205|      0|      return std::make_unique<SphincsPlus_PublicKey>(alg_id, key_bits);
  206|      0|   }
  207|    940|#endif
  208|       |
  209|    940|   throw Decoding_Error(fmt("Unknown or unavailable public key algorithm '{}'", alg_name));
  210|    940|}

_ZN5Botan22create_hex_fingerprintEPKhmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   30|  6.77k|std::string create_hex_fingerprint(const uint8_t bits[], size_t bits_len, std::string_view hash_name) {
   31|  6.77k|   auto hash_fn = HashFunction::create_or_throw(hash_name);
   32|  6.77k|   const std::string hex_hash = hex_encode(hash_fn->process(bits, bits_len));
   33|       |
   34|  6.77k|   std::string fprint;
   35|       |
   36|   182k|   for(size_t i = 0; i != hex_hash.size(); i += 2) {
  ------------------
  |  Branch (36:22): [True: 176k, False: 6.77k]
  ------------------
   37|   176k|      if(i != 0) {
  ------------------
  |  Branch (37:10): [True: 169k, False: 6.77k]
  ------------------
   38|   169k|         fprint.push_back(':');
   39|   169k|      }
   40|       |
   41|   176k|      fprint.push_back(hex_hash[i]);
   42|   176k|      fprint.push_back(hex_hash[i + 1]);
   43|   176k|   }
   44|       |
   45|  6.77k|   return fprint;
   46|  6.77k|}

_ZN5Botan11PK_VerifierC2ERKNS_10Public_KeyERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  341|  1.45k|                         std::string_view provider) {
  342|  1.45k|   m_op = key.create_x509_verification_op(signature_algorithm, provider);
  343|       |
  344|  1.45k|   if(!m_op) {
  ------------------
  |  Branch (344:7): [True: 0, False: 1.45k]
  ------------------
  345|      0|      throw Invalid_Argument(fmt("Key type {} does not support X.509 signature verification", key.algo_name()));
  346|      0|   }
  347|       |
  348|  1.45k|   m_sig_format = key.default_x509_signature_format();
  349|  1.45k|   m_parts = key.message_parts();
  350|  1.45k|   m_part_size = key.message_part_size();
  351|  1.45k|   check_der_format_supported(m_sig_format, m_parts);
  352|  1.45k|}
_ZN5Botan11PK_VerifierD2Ev:
  354|  1.44k|PK_Verifier::~PK_Verifier() = default;
_ZN5Botan11PK_Verifier14verify_messageEPKhmS2_m:
  368|  1.44k|bool PK_Verifier::verify_message(const uint8_t msg[], size_t msg_length, const uint8_t sig[], size_t sig_length) {
  369|  1.44k|   update(msg, msg_length);
  370|  1.44k|   return check_signature(sig, sig_length);
  371|  1.44k|}
_ZN5Botan11PK_Verifier6updateEPKhm:
  377|  1.44k|void PK_Verifier::update(const uint8_t in[], size_t length) {
  378|  1.44k|   m_op->update(in, length);
  379|  1.44k|}
_ZN5Botan11PK_Verifier15check_signatureEPKhm:
  413|  1.44k|bool PK_Verifier::check_signature(const uint8_t sig[], size_t length) {
  414|  1.44k|   try {
  415|  1.44k|      if(m_sig_format == Signature_Format::Standard) {
  ------------------
  |  Branch (415:10): [True: 1.44k, False: 0]
  ------------------
  416|  1.44k|         return m_op->is_valid_signature(sig, length);
  417|  1.44k|      } else if(m_sig_format == Signature_Format::DerSequence) {
  ------------------
  |  Branch (417:17): [True: 0, False: 0]
  ------------------
  418|      0|         bool decoding_success = false;
  419|      0|         std::vector<uint8_t> real_sig;
  420|       |
  421|      0|         try {
  422|      0|            real_sig = decode_der_signature(sig, length, m_parts, m_part_size);
  423|      0|            decoding_success = true;
  424|      0|         } catch(Decoding_Error&) {}
  425|       |
  426|      0|         bool accept = m_op->is_valid_signature(real_sig.data(), real_sig.size());
  427|       |
  428|      0|         return accept && decoding_success;
  ------------------
  |  Branch (428:17): [True: 0, False: 0]
  |  Branch (428:27): [True: 0, False: 0]
  ------------------
  429|      0|      } else {
  430|      0|         throw Internal_Error("PK_Verifier: Invalid signature format enum");
  431|      0|      }
  432|  1.44k|   } catch(Invalid_Argument&) {
  433|      0|      return false;
  434|     79|   } catch(Decoding_Error&) {
  435|     79|      return false;
  436|     79|   } catch(Encoding_Error&) {
  437|      0|      return false;
  438|      0|   }
  439|  1.44k|}
pubkey.cpp:_ZN5Botan12_GLOBAL__N_126check_der_format_supportedENS_16Signature_FormatEm:
  238|  1.44k|void check_der_format_supported(Signature_Format format, size_t parts) {
  239|  1.44k|   if(format != Signature_Format::Standard && parts == 1) {
  ------------------
  |  Branch (239:7): [True: 0, False: 1.44k]
  |  Branch (239:47): [True: 0, False: 0]
  ------------------
  240|      0|      throw Invalid_Argument("This algorithm does not support DER encoding");
  241|      0|   }
  242|  1.44k|}

_ZNK5Botan13RSA_PublicKey11public_dataEv:
  118|  1.44k|std::shared_ptr<const RSA_Public_Data> RSA_PublicKey::public_data() const {
  119|  1.44k|   return m_public;
  120|  1.44k|}
_ZN5Botan13RSA_PublicKey4initEONS_6BigIntES2_:
  144|  1.52k|void RSA_PublicKey::init(BigInt&& n, BigInt&& e) {
  145|  1.52k|   if(n.is_negative() || n.is_even() || n.bits() < 5 /* n >= 3*5 */ || e.is_negative() || e.is_even()) {
  ------------------
  |  Branch (145:7): [True: 15, False: 1.51k]
  |  Branch (145:26): [True: 18, False: 1.49k]
  |  Branch (145:41): [True: 11, False: 1.48k]
  |  Branch (145:72): [True: 10, False: 1.47k]
  |  Branch (145:91): [True: 13, False: 1.45k]
  ------------------
  146|     67|      throw Decoding_Error("Invalid RSA public key parameters");
  147|     67|   }
  148|  1.45k|   m_public = std::make_shared<RSA_Public_Data>(std::move(n), std::move(e));
  149|  1.45k|}
_ZN5Botan13RSA_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
  151|  1.71k|RSA_PublicKey::RSA_PublicKey(const AlgorithmIdentifier& /*unused*/, std::span<const uint8_t> key_bits) {
  152|  1.71k|   BigInt n, e;
  153|  1.71k|   BER_Decoder(key_bits).start_sequence().decode(n).decode(e).end_cons();
  154|       |
  155|  1.71k|   init(std::move(n), std::move(e));
  156|  1.71k|}
_ZNK5Botan13RSA_PublicKey27create_x509_verification_opERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  791|  1.45k|                                                                                 std::string_view provider) const {
  792|  1.45k|   if(provider == "base" || provider.empty()) {
  ------------------
  |  Branch (792:7): [True: 0, False: 1.45k]
  |  Branch (792:29): [True: 1.45k, False: 0]
  ------------------
  793|  1.45k|      return std::make_unique<RSA_Verify_Operation>(*this, parse_rsa_signature_algorithm(alg_id));
  794|  1.45k|   }
  795|       |
  796|      0|   throw Provider_Not_Found(algo_name(), provider);
  797|  1.45k|}
_ZNK5Botan15RSA_Public_Data5get_nEv:
   46|  1.38k|      const BigInt& get_n() const { return m_n; }
_ZNK5Botan15RSA_Public_Data19public_modulus_bitsEv:
   50|  1.36k|      size_t public_modulus_bits() const { return m_public_modulus_bits; }
rsa.cpp:_ZN5Botan12_GLOBAL__N_129parse_rsa_signature_algorithmERKNS_19AlgorithmIdentifierE:
  742|  1.45k|std::string parse_rsa_signature_algorithm(const AlgorithmIdentifier& alg_id) {
  743|  1.45k|   const auto sig_info = split_on(alg_id.oid().to_formatted_string(), '/');
  744|       |
  745|  1.45k|   if(sig_info.empty() || sig_info.size() != 2 || sig_info[0] != "RSA") {
  ------------------
  |  Branch (745:7): [True: 0, False: 1.45k]
  |  Branch (745:27): [True: 9, False: 1.44k]
  |  Branch (745:51): [True: 0, False: 1.44k]
  ------------------
  746|      9|      throw Decoding_Error("Unknown AlgorithmIdentifier for RSA X.509 signatures");
  747|      9|   }
  748|       |
  749|  1.44k|   std::string padding = sig_info[1];
  750|       |
  751|  1.44k|   if(padding == "EMSA4") {
  ------------------
  |  Branch (751:7): [True: 3, False: 1.44k]
  ------------------
  752|       |      // "MUST contain RSASSA-PSS-params"
  753|      3|      if(alg_id.parameters().empty()) {
  ------------------
  |  Branch (753:10): [True: 0, False: 3]
  ------------------
  754|      0|         throw Decoding_Error("PSS params must be provided");
  755|      0|      }
  756|       |
  757|      3|      PSS_Params pss_params(alg_id.parameters());
  758|       |
  759|       |      // hash_algo must be SHA1, SHA2-224, SHA2-256, SHA2-384 or SHA2-512
  760|      3|      const std::string hash_algo = pss_params.hash_function();
  761|      3|      if(hash_algo != "SHA-1" && hash_algo != "SHA-224" && hash_algo != "SHA-256" && hash_algo != "SHA-384" &&
  ------------------
  |  Branch (761:10): [True: 0, False: 3]
  |  Branch (761:34): [True: 0, False: 0]
  |  Branch (761:60): [True: 0, False: 0]
  |  Branch (761:86): [True: 0, False: 0]
  ------------------
  762|      3|         hash_algo != "SHA-512") {
  ------------------
  |  Branch (762:10): [True: 0, False: 0]
  ------------------
  763|      0|         throw Decoding_Error("Unacceptable hash for PSS signatures");
  764|      0|      }
  765|       |
  766|      3|      if(pss_params.mgf_function() != "MGF1") {
  ------------------
  |  Branch (766:10): [True: 0, False: 3]
  ------------------
  767|      0|         throw Decoding_Error("Unacceptable MGF for PSS signatures");
  768|      0|      }
  769|       |
  770|       |      // For MGF1, it is strongly RECOMMENDED that the underlying hash
  771|       |      // function be the same as the one identified by hashAlgorithm
  772|       |      //
  773|       |      // Must be SHA1, SHA2-224, SHA2-256, SHA2-384 or SHA2-512
  774|      3|      if(pss_params.hash_algid() != pss_params.mgf_hash_algid()) {
  ------------------
  |  Branch (774:10): [True: 0, False: 3]
  ------------------
  775|      0|         throw Decoding_Error("Unacceptable MGF hash for PSS signatures");
  776|      0|      }
  777|       |
  778|      3|      if(pss_params.trailer_field() != 1) {
  ------------------
  |  Branch (778:10): [True: 0, False: 3]
  ------------------
  779|      0|         throw Decoding_Error("Unacceptable trailer field for PSS signatures");
  780|      0|      }
  781|       |
  782|      3|      padding += fmt("({},MGF1,{})", hash_algo, pss_params.salt_length());
  783|      3|   }
  784|       |
  785|  1.44k|   return padding;
  786|  1.44k|}
_ZN5Botan15RSA_Public_DataC2EONS_6BigIntES2_:
   38|  1.45k|            m_public_modulus_bytes(m_n.bytes()) {}
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Public_OperationC2ERKNS_13RSA_PublicKeyE:
  623|  1.44k|      explicit RSA_Public_Operation(const RSA_PublicKey& rsa) : m_public(rsa.public_data()) {}
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Public_Operation20public_modulus_bytesEv:
  636|  1.44k|      size_t public_modulus_bytes() const { return m_public->public_modulus_bytes(); }
_ZNK5Botan15RSA_Public_Data20public_modulus_bytesEv:
   52|  1.44k|      size_t public_modulus_bytes() const { return m_public_modulus_bytes; }
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Public_Operation19public_modulus_bitsEv:
  625|  1.36k|      size_t public_modulus_bits() const { return m_public->public_modulus_bits(); }
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Public_Operation9public_opERKNS_6BigIntE:
  628|  1.38k|      BigInt public_op(const BigInt& m) const {
  629|  1.38k|         if(m >= m_public->get_n()) {
  ------------------
  |  Branch (629:13): [True: 15, False: 1.36k]
  ------------------
  630|     15|            throw Decoding_Error("RSA public op - input is too large");
  631|     15|         }
  632|       |
  633|  1.36k|         return m_public->public_op(m);
  634|  1.38k|      }
_ZNK5Botan15RSA_Public_Data9public_opERKNS_6BigIntE:
   40|  1.36k|      BigInt public_op(const BigInt& m) const {
   41|  1.36k|         const size_t powm_window = 1;
   42|  1.36k|         auto powm_m_n = monty_precompute(m_monty_n, m, powm_window, false);
   43|  1.36k|         return monty_execute_vartime(*powm_m_n, m_e);
   44|  1.36k|      }
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_OperationC2ERKNS_13RSA_PublicKeyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  674|  1.44k|            RSA_Public_Operation(rsa), m_emsa(EMSA::create_or_throw(padding)) {}
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_Operation6updateEPKhm:
  665|  1.44k|      void update(const uint8_t msg[], size_t msg_len) override { m_emsa->update(msg, msg_len); }
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_Operation18is_valid_signatureEPKhm:
  667|  1.44k|      bool is_valid_signature(const uint8_t sig[], size_t sig_len) override {
  668|  1.44k|         const auto msg = m_emsa->raw_data();
  669|  1.44k|         const auto message_repr = recover_message_repr(sig, sig_len);
  670|  1.44k|         return m_emsa->verify(message_repr, msg, public_modulus_bits() - 1);
  671|  1.44k|      }
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_Operation20recover_message_reprEPKhm:
  679|  1.44k|      std::vector<uint8_t> recover_message_repr(const uint8_t input[], size_t input_len) {
  680|  1.44k|         if(input_len > public_modulus_bytes()) {
  ------------------
  |  Branch (680:13): [True: 64, False: 1.38k]
  ------------------
  681|     64|            throw Decoding_Error("RSA signature too large to be valid for this key");
  682|     64|         }
  683|  1.38k|         BigInt input_bn(input, input_len);
  684|  1.38k|         return BigInt::encode(public_op(input_bn));
  685|  1.44k|      }

_ZN5Botan4X5098load_keyERNS_10DataSourceE:
   28|  2.98k|std::unique_ptr<Public_Key> load_key(DataSource& source) {
   29|  2.98k|   try {
   30|  2.98k|      AlgorithmIdentifier alg_id;
   31|  2.98k|      std::vector<uint8_t> key_bits;
   32|       |
   33|  2.98k|      if(ASN1::maybe_BER(source) && !PEM_Code::matches(source)) {
  ------------------
  |  Branch (33:10): [True: 2.98k, False: 0]
  |  Branch (33:37): [True: 2.98k, False: 0]
  ------------------
   34|  2.98k|         BER_Decoder(source).start_sequence().decode(alg_id).decode(key_bits, ASN1_Type::BitString).end_cons();
   35|  2.98k|      } else {
   36|      0|         DataSource_Memory ber(PEM_Code::decode_check_label(source, "PUBLIC KEY"));
   37|       |
   38|      0|         BER_Decoder(ber).start_sequence().decode(alg_id).decode(key_bits, ASN1_Type::BitString).end_cons();
   39|      0|      }
   40|       |
   41|  2.98k|      if(key_bits.empty()) {
  ------------------
  |  Branch (41:10): [True: 1, False: 2.98k]
  ------------------
   42|      1|         throw Decoding_Error("X.509 public key decoding");
   43|      1|      }
   44|       |
   45|  2.98k|      return load_public_key(alg_id, key_bits);
   46|  2.98k|   } catch(Decoding_Error& e) {
   47|  1.52k|      throw Decoding_Error("X.509 public key decoding", e);
   48|  1.52k|   }
   49|  2.98k|}

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

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

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

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

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

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

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  12.3k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
   73|  2.11k|Exception::Exception(std::string_view msg, const std::exception& e) : m_msg(fmt("{} failed with {}", msg, e.what())) {}
_ZN5Botan9ExceptionC2EPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   75|    383|Exception::Exception(const char* prefix, std::string_view msg) : m_msg(fmt("{} {}", prefix, msg)) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|  1.71k|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan19Algorithm_Not_FoundC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  115|      1|      Lookup_Error(fmt("Could not find any algorithm named '{}'", name)) {}
_ZN5Botan14Encoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  123|    322|Encoding_Error::Encoding_Error(std::string_view name) : Exception("Encoding error:", name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  10.6k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
  130|  2.11k|Decoding_Error::Decoding_Error(std::string_view msg, const std::exception& e) : Exception(msg, e) {}
_ZN5Botan15Stream_IO_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  135|     61|Stream_IO_Error::Stream_IO_Error(std::string_view err) : Exception("I/O error:", err) {}

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

_ZN5Botan9to_u32bitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   32|   850k|uint32_t to_u32bit(std::string_view str_view) {
   33|   850k|   const std::string str(str_view);
   34|       |
   35|       |   // std::stoul is not strict enough. Ensure that str is digit only [0-9]*
   36|  1.24M|   for(const char chr : str) {
  ------------------
  |  Branch (36:23): [True: 1.24M, False: 850k]
  ------------------
   37|  1.24M|      if(chr < '0' || chr > '9') {
  ------------------
  |  Branch (37:10): [True: 13, False: 1.24M]
  |  Branch (37:23): [True: 5, False: 1.24M]
  ------------------
   38|     18|         throw Invalid_Argument("to_u32bit invalid decimal string '" + str + "'");
   39|     18|      }
   40|  1.24M|   }
   41|       |
   42|   850k|   const unsigned long int x = std::stoul(str);
   43|       |
   44|   850k|   if constexpr(sizeof(unsigned long int) > 4) {
  ------------------
  |  Branch (44:17): [Folded - Ignored]
  ------------------
   45|       |      // x might be uint64
   46|   850k|      if(x > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (46:10): [True: 0, False: 850k]
  ------------------
   47|      0|         throw Invalid_Argument("Integer value of " + str + " exceeds 32 bit range");
   48|      0|      }
   49|   850k|   }
   50|       |
   51|   850k|   return static_cast<uint32_t>(x);
   52|   850k|}
_ZN5Botan8split_onENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEc:
  111|  4.11k|std::vector<std::string> split_on(std::string_view str, char delim) {
  112|  4.11k|   std::vector<std::string> elems;
  113|  4.11k|   if(str.empty()) {
  ------------------
  |  Branch (113:7): [True: 0, False: 4.11k]
  ------------------
  114|      0|      return elems;
  115|      0|   }
  116|       |
  117|  4.11k|   std::string substr;
  118|   122k|   for(auto i = str.begin(); i != str.end(); ++i) {
  ------------------
  |  Branch (118:30): [True: 118k, False: 4.11k]
  ------------------
  119|   118k|      if(*i == delim) {
  ------------------
  |  Branch (119:10): [True: 3.05k, False: 115k]
  ------------------
  120|  3.05k|         if(!substr.empty()) {
  ------------------
  |  Branch (120:13): [True: 3.05k, False: 0]
  ------------------
  121|  3.05k|            elems.push_back(substr);
  122|  3.05k|         }
  123|  3.05k|         substr.clear();
  124|   115k|      } else {
  125|   115k|         substr += *i;
  126|   115k|      }
  127|   118k|   }
  128|       |
  129|  4.11k|   if(substr.empty()) {
  ------------------
  |  Branch (129:7): [True: 0, False: 4.11k]
  ------------------
  130|      0|      throw Invalid_Argument(fmt("Unable to split string '{}", str));
  131|      0|   }
  132|  4.11k|   elems.push_back(substr);
  133|       |
  134|  4.11k|   return elems;
  135|  4.11k|}
_ZN5Botan14ipv4_to_stringEj:
  181|    746|std::string ipv4_to_string(uint32_t ip) {
  182|    746|   std::string str;
  183|    746|   uint8_t bits[4];
  184|    746|   store_be(ip, bits);
  185|       |
  186|  3.73k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (186:22): [True: 2.98k, False: 746]
  ------------------
  187|  2.98k|      if(i > 0) {
  ------------------
  |  Branch (187:10): [True: 2.23k, False: 746]
  ------------------
  188|  2.23k|         str += ".";
  189|  2.23k|      }
  190|  2.98k|      str += std::to_string(bits[i]);
  191|  2.98k|   }
  192|       |
  193|    746|   return str;
  194|    746|}

_ZN5Botan9SCAN_NameC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   58|  1.44k|SCAN_Name::SCAN_Name(std::string_view algo_spec) : m_orig_algo_spec(algo_spec), m_alg_name(), m_args(), m_mode_info() {
   59|  1.44k|   if(algo_spec.empty()) {
  ------------------
  |  Branch (59:7): [True: 0, False: 1.44k]
  ------------------
   60|      0|      throw Invalid_Argument("Expected algorithm name, got empty string");
   61|      0|   }
   62|       |
   63|  1.44k|   std::vector<std::pair<size_t, std::string>> name;
   64|  1.44k|   size_t level = 0;
   65|  1.44k|   std::pair<size_t, std::string> accum = std::make_pair(level, "");
   66|       |
   67|  1.44k|   const std::string decoding_error = "Bad SCAN name '" + m_orig_algo_spec + "': ";
   68|       |
   69|  15.3k|   for(char c : algo_spec) {
  ------------------
  |  Branch (69:15): [True: 15.3k, False: 1.44k]
  ------------------
   70|  15.3k|      if(c == '/' || c == ',' || c == '(' || c == ')') {
  ------------------
  |  Branch (70:10): [True: 0, False: 15.3k]
  |  Branch (70:22): [True: 0, False: 15.3k]
  |  Branch (70:34): [True: 1.44k, False: 13.9k]
  |  Branch (70:46): [True: 1.44k, False: 12.4k]
  ------------------
   71|  2.89k|         if(c == '(') {
  ------------------
  |  Branch (71:13): [True: 1.44k, False: 1.44k]
  ------------------
   72|  1.44k|            ++level;
   73|  1.44k|         } else if(c == ')') {
  ------------------
  |  Branch (73:20): [True: 1.44k, False: 0]
  ------------------
   74|  1.44k|            if(level == 0) {
  ------------------
  |  Branch (74:16): [True: 0, False: 1.44k]
  ------------------
   75|      0|               throw Decoding_Error(decoding_error + "Mismatched parens");
   76|      0|            }
   77|  1.44k|            --level;
   78|  1.44k|         }
   79|       |
   80|  2.89k|         if(c == '/' && level > 0) {
  ------------------
  |  Branch (80:13): [True: 0, False: 2.89k]
  |  Branch (80:25): [True: 0, False: 0]
  ------------------
   81|      0|            accum.second.push_back(c);
   82|  2.89k|         } else {
   83|  2.89k|            if(!accum.second.empty()) {
  ------------------
  |  Branch (83:16): [True: 2.89k, False: 0]
  ------------------
   84|  2.89k|               name.push_back(accum);
   85|  2.89k|            }
   86|  2.89k|            accum = std::make_pair(level, "");
   87|  2.89k|         }
   88|  12.4k|      } else {
   89|  12.4k|         accum.second.push_back(c);
   90|  12.4k|      }
   91|  15.3k|   }
   92|       |
   93|  1.44k|   if(!accum.second.empty()) {
  ------------------
  |  Branch (93:7): [True: 1, False: 1.44k]
  ------------------
   94|      1|      name.push_back(accum);
   95|      1|   }
   96|       |
   97|  1.44k|   if(level != 0) {
  ------------------
  |  Branch (97:7): [True: 0, False: 1.44k]
  ------------------
   98|      0|      throw Decoding_Error(decoding_error + "Missing close paren");
   99|      0|   }
  100|       |
  101|  1.44k|   if(name.empty()) {
  ------------------
  |  Branch (101:7): [True: 0, False: 1.44k]
  ------------------
  102|      0|      throw Decoding_Error(decoding_error + "Empty name");
  103|      0|   }
  104|       |
  105|  1.44k|   m_alg_name = name[0].second;
  106|       |
  107|  1.44k|   bool in_modes = false;
  108|       |
  109|  2.89k|   for(size_t i = 1; i != name.size(); ++i) {
  ------------------
  |  Branch (109:22): [True: 1.44k, False: 1.44k]
  ------------------
  110|  1.44k|      if(name[i].first == 0) {
  ------------------
  |  Branch (110:10): [True: 0, False: 1.44k]
  ------------------
  111|      0|         m_mode_info.push_back(make_arg(name, i));
  112|      0|         in_modes = true;
  113|  1.44k|      } else if(name[i].first == 1 && !in_modes) {
  ------------------
  |  Branch (113:17): [True: 1.44k, False: 0]
  |  Branch (113:39): [True: 1.44k, False: 0]
  ------------------
  114|  1.44k|         m_args.push_back(make_arg(name, i));
  115|  1.44k|      }
  116|  1.44k|   }
  117|  1.44k|}
_ZNK5Botan9SCAN_Name3argEm:
  119|  2.89k|std::string SCAN_Name::arg(size_t i) const {
  120|  2.89k|   if(i >= arg_count()) {
  ------------------
  |  Branch (120:7): [True: 0, False: 2.89k]
  ------------------
  121|      0|      throw Invalid_Argument("SCAN_Name::arg " + std::to_string(i) + " out of range for '" + to_string() + "'");
  122|      0|   }
  123|  2.89k|   return m_args[i];
  124|  2.89k|}
scan_name.cpp:_ZN5Botan12_GLOBAL__N_18make_argERKNSt3__16vectorINS1_4pairImNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEm:
   17|  1.44k|std::string make_arg(const std::vector<std::pair<size_t, std::string>>& name, size_t start) {
   18|  1.44k|   std::string output = name[start].second;
   19|  1.44k|   size_t level = name[start].first;
   20|       |
   21|  1.44k|   size_t paren_depth = 0;
   22|       |
   23|  1.44k|   for(size_t i = start + 1; i != name.size(); ++i) {
  ------------------
  |  Branch (23:30): [True: 0, False: 1.44k]
  ------------------
   24|      0|      if(name[i].first <= name[start].first) {
  ------------------
  |  Branch (24:10): [True: 0, False: 0]
  ------------------
   25|      0|         break;
   26|      0|      }
   27|       |
   28|      0|      if(name[i].first > level) {
  ------------------
  |  Branch (28:10): [True: 0, False: 0]
  ------------------
   29|      0|         output += "(" + name[i].second;
   30|      0|         ++paren_depth;
   31|      0|      } else if(name[i].first < level) {
  ------------------
  |  Branch (31:17): [True: 0, False: 0]
  ------------------
   32|      0|         for(size_t j = name[i].first; j < level; j++) {
  ------------------
  |  Branch (32:40): [True: 0, False: 0]
  ------------------
   33|      0|            output += ")";
   34|      0|            --paren_depth;
   35|      0|         }
   36|      0|         output += "," + name[i].second;
   37|      0|      } else {
   38|      0|         if(output[output.size() - 1] != '(') {
  ------------------
  |  Branch (38:13): [True: 0, False: 0]
  ------------------
   39|      0|            output += ",";
   40|      0|         }
   41|      0|         output += name[i].second;
   42|      0|      }
   43|       |
   44|      0|      level = name[i].first;
   45|      0|   }
   46|       |
   47|  1.44k|   for(size_t i = 0; i != paren_depth; ++i) {
  ------------------
  |  Branch (47:22): [True: 0, False: 1.44k]
  ------------------
   48|      0|      output += ")";
   49|      0|   }
   50|       |
   51|  1.44k|   return output;
   52|  1.44k|}

_ZN5Botan15AlternativeNameC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_S5_S5_:
   27|  11.9k|                                 std::string_view ip) {
   28|  11.9k|   add_attribute("RFC822", email_addr);
   29|  11.9k|   add_attribute("DNS", dns);
   30|  11.9k|   add_attribute("URI", uri);
   31|  11.9k|   add_attribute("IP", ip);
   32|  11.9k|}
_ZN5Botan15AlternativeName13add_attributeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   37|  53.8k|void AlternativeName::add_attribute(std::string_view type, std::string_view value) {
   38|  53.8k|   if(type.empty() || value.empty()) {
  ------------------
  |  Branch (38:7): [True: 0, False: 53.8k]
  |  Branch (38:23): [True: 47.9k, False: 5.85k]
  ------------------
   39|  47.9k|      return;
   40|  47.9k|   }
   41|       |
   42|  5.85k|   auto range = m_alt_info.equal_range(type);
   43|  19.5k|   for(auto j = range.first; j != range.second; ++j) {
  ------------------
  |  Branch (43:30): [True: 13.9k, False: 5.67k]
  ------------------
   44|  13.9k|      if(j->second == value) {
  ------------------
  |  Branch (44:10): [True: 182, False: 13.7k]
  ------------------
   45|    182|         return;
   46|    182|      }
   47|  13.9k|   }
   48|       |
   49|  5.67k|   m_alt_info.emplace(type, value);
   50|  5.67k|}
_ZN5Botan15AlternativeName13add_othernameERKNS_3OIDENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS_9ASN1_TypeE:
   55|    357|void AlternativeName::add_othername(const OID& oid, std::string_view value, ASN1_Type type) {
   56|    357|   if(value.empty()) {
  ------------------
  |  Branch (56:7): [True: 10, False: 347]
  ------------------
   57|     10|      return;
   58|     10|   }
   59|    347|   multimap_insert(m_othernames, oid, ASN1_String(value, type));
   60|    347|}
_ZNK5Botan15AlternativeName8contentsEv:
   65|    667|std::multimap<std::string, std::string> AlternativeName::contents() const {
   66|    667|   std::multimap<std::string, std::string> names;
   67|       |
   68|  1.38k|   for(const auto& name : m_alt_info) {
  ------------------
  |  Branch (68:25): [True: 1.38k, False: 667]
  ------------------
   69|  1.38k|      names.emplace(name.first, name.second);
   70|  1.38k|   }
   71|       |
   72|    667|   for(const auto& othername : m_othernames) {
  ------------------
  |  Branch (72:30): [True: 0, False: 667]
  ------------------
   73|      0|      multimap_insert(names, othername.first.to_formatted_string(), othername.second.value());
   74|      0|   }
   75|       |
   76|    667|   return names;
   77|    667|}
_ZN5Botan15AlternativeName11decode_fromERNS_11BER_DecoderE:
  179|  2.82k|void AlternativeName::decode_from(BER_Decoder& source) {
  180|  2.82k|   BER_Decoder names = source.start_sequence();
  181|       |
  182|       |   // FIXME this is largely a duplication of GeneralName::decode_from
  183|       |
  184|  13.2k|   while(names.more_items()) {
  ------------------
  |  Branch (184:10): [True: 10.4k, False: 2.81k]
  ------------------
  185|  10.4k|      BER_Object obj = names.get_next_object();
  186|       |
  187|  10.4k|      if(obj.is_a(0, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (187:10): [True: 597, False: 9.85k]
  ------------------
  188|    597|         BER_Decoder othername(obj);
  189|       |
  190|    597|         OID oid;
  191|    597|         othername.decode(oid);
  192|    597|         if(othername.more_items()) {
  ------------------
  |  Branch (192:13): [True: 543, False: 54]
  ------------------
  193|    543|            BER_Object othername_value_outer = othername.get_next_object();
  194|    543|            othername.verify_end();
  195|       |
  196|    543|            if(othername_value_outer.is_a(0, ASN1_Class::ExplicitContextSpecific) == false) {
  ------------------
  |  Branch (196:16): [True: 11, False: 532]
  ------------------
  197|     11|               throw Decoding_Error("Invalid tags on otherName value");
  198|     11|            }
  199|       |
  200|    532|            BER_Decoder othername_value_inner(othername_value_outer);
  201|       |
  202|    532|            BER_Object value = othername_value_inner.get_next_object();
  203|    532|            othername_value_inner.verify_end();
  204|       |
  205|    532|            if(ASN1_String::is_string_type(value.type()) && value.get_class() == ASN1_Class::Universal) {
  ------------------
  |  Branch (205:16): [True: 387, False: 145]
  |  Branch (205:61): [True: 357, False: 30]
  ------------------
  206|    357|               add_othername(oid, ASN1::to_string(value), value.type());
  207|    357|            }
  208|    532|         }
  209|    597|      }
  210|  10.4k|      if(obj.is_a(1, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (210:10): [True: 2.09k, False: 8.34k]
  ------------------
  211|  2.09k|         add_attribute("RFC822", ASN1::to_string(obj));
  212|  8.34k|      } else if(obj.is_a(2, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (212:17): [True: 1.99k, False: 6.34k]
  ------------------
  213|  1.99k|         add_attribute("DNS", ASN1::to_string(obj));
  214|  6.34k|      } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (214:17): [True: 1.00k, False: 5.34k]
  ------------------
  215|  1.00k|         add_attribute("URI", ASN1::to_string(obj));
  216|  5.34k|      } else if(obj.is_a(4, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (216:17): [True: 1.32k, False: 4.02k]
  ------------------
  217|  1.32k|         BER_Decoder dec(obj);
  218|  1.32k|         X509_DN dn;
  219|  1.32k|         std::stringstream ss;
  220|       |
  221|  1.32k|         dec.decode(dn);
  222|  1.32k|         ss << dn;
  223|       |
  224|  1.32k|         add_attribute("DN", ss.str());
  225|  4.02k|      } else if(obj.is_a(7, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (225:17): [True: 485, False: 3.53k]
  ------------------
  226|    485|         if(obj.length() == 4) {
  ------------------
  |  Branch (226:13): [True: 344, False: 141]
  ------------------
  227|    344|            const uint32_t ip = load_be<uint32_t>(obj.bits(), 0);
  228|    344|            add_attribute("IP", ipv4_to_string(ip));
  229|    344|         }
  230|    485|      }
  231|  10.4k|   }
  232|  2.82k|}

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

_ZN5Botan4OCSP8ResponseC2EPKhm:
   85|  4.97k|      m_response_bits(response_bits, response_bits + response_bits_len) {
   86|  4.97k|   BER_Decoder response_outer = BER_Decoder(m_response_bits).start_sequence();
   87|       |
   88|  4.97k|   size_t resp_status = 0;
   89|       |
   90|  4.97k|   response_outer.decode(resp_status, ASN1_Type::Enumerated, ASN1_Class::Universal);
   91|       |
   92|  4.97k|   m_status = static_cast<Response_Status_Code>(resp_status);
   93|       |
   94|  4.97k|   if(m_status != Response_Status_Code::Successful) {
  ------------------
  |  Branch (94:7): [True: 70, False: 4.90k]
  ------------------
   95|     70|      return;
   96|     70|   }
   97|       |
   98|  4.90k|   if(response_outer.more_items()) {
  ------------------
  |  Branch (98:7): [True: 3.97k, False: 926]
  ------------------
   99|  3.97k|      BER_Decoder response_bytes = response_outer.start_context_specific(0).start_sequence();
  100|       |
  101|  3.97k|      response_bytes.decode_and_check(OID("1.3.6.1.5.5.7.48.1.1"), "Unknown response type in OCSP response");
  102|       |
  103|  3.97k|      BER_Decoder basicresponse = BER_Decoder(response_bytes.get_next_octet_string()).start_sequence();
  104|       |
  105|  3.97k|      basicresponse.start_sequence()
  106|  3.97k|         .raw_bytes(m_tbs_bits)
  107|  3.97k|         .end_cons()
  108|  3.97k|         .decode(m_sig_algo)
  109|  3.97k|         .decode(m_signature, ASN1_Type::BitString);
  110|  3.97k|      decode_optional_list(basicresponse, ASN1_Type(0), m_certs);
  111|       |
  112|  3.97k|      size_t responsedata_version = 0;
  113|  3.97k|      Extensions extensions;
  114|       |
  115|  3.97k|      BER_Decoder(m_tbs_bits)
  116|  3.97k|         .decode_optional(responsedata_version, ASN1_Type(0), ASN1_Class::ContextSpecific | ASN1_Class::Constructed)
  117|       |
  118|  3.97k|         .decode_optional(m_signer_name, ASN1_Type(1), ASN1_Class::ContextSpecific | ASN1_Class::Constructed)
  119|       |
  120|  3.97k|         .decode_optional_string(
  121|  3.97k|            m_key_hash, ASN1_Type::OctetString, 2, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)
  122|       |
  123|  3.97k|         .decode(m_produced_at)
  124|       |
  125|  3.97k|         .decode_list(m_responses)
  126|       |
  127|  3.97k|         .decode_optional(extensions, ASN1_Type(1), ASN1_Class::ContextSpecific | ASN1_Class::Constructed);
  128|       |
  129|  3.97k|      const bool has_signer = !m_signer_name.empty();
  130|  3.97k|      const bool has_key_hash = !m_key_hash.empty();
  131|       |
  132|  3.97k|      if(has_signer && has_key_hash) {
  ------------------
  |  Branch (132:10): [True: 0, False: 3.97k]
  |  Branch (132:24): [True: 0, False: 0]
  ------------------
  133|      0|         throw Decoding_Error("OCSP response includes both byName and byKey in responderID field");
  134|      0|      }
  135|  3.97k|      if(!has_signer && !has_key_hash) {
  ------------------
  |  Branch (135:10): [True: 464, False: 3.51k]
  |  Branch (135:25): [True: 456, False: 8]
  ------------------
  136|    456|         throw Decoding_Error("OCSP response contains neither byName nor byKey in responderID field");
  137|    456|      }
  138|  3.97k|   }
  139|       |
  140|  4.44k|   response_outer.end_cons();
  141|  4.44k|}
ocsp.cpp:_ZN5Botan4OCSP12_GLOBAL__N_120decode_optional_listERNS_11BER_DecoderENS_9ASN1_TypeERNSt3__16vectorINS_16X509_CertificateENS5_9allocatorIS7_EEEE:
   29|  3.69k|void decode_optional_list(BER_Decoder& ber, ASN1_Type tag, std::vector<X509_Certificate>& output) {
   30|  3.69k|   BER_Object obj = ber.get_next_object();
   31|       |
   32|  3.69k|   if(obj.is_a(tag, ASN1_Class::ContextSpecific | ASN1_Class::Constructed) == false) {
  ------------------
  |  Branch (32:7): [True: 1.61k, False: 2.07k]
  ------------------
   33|  1.61k|      ber.push_back(obj);
   34|  1.61k|      return;
   35|  1.61k|   }
   36|       |
   37|  2.07k|   BER_Decoder list(obj);
   38|       |
   39|  6.18k|   while(list.more_items()) {
  ------------------
  |  Branch (39:10): [True: 4.10k, False: 2.07k]
  ------------------
   40|  4.10k|      BER_Object certbits = list.get_next_object();
   41|  4.10k|      X509_Certificate cert(certbits.bits(), certbits.length());
   42|  4.10k|      output.push_back(std::move(cert));
   43|  4.10k|   }
   44|  2.07k|}

_ZN5Botan4OCSP6CertID11decode_fromERNS_11BER_DecoderE:
   62|     12|void CertID::decode_from(BER_Decoder& from) {
   63|     12|   from.start_sequence()
   64|     12|      .decode(m_hash_id)
   65|     12|      .decode(m_issuer_dn_hash, ASN1_Type::OctetString)
   66|     12|      .decode(m_issuer_key_hash, ASN1_Type::OctetString)
   67|     12|      .decode(m_subject_serial)
   68|     12|      .end_cons();
   69|     12|}
_ZN5Botan4OCSP14SingleResponse11decode_fromERNS_11BER_DecoderE:
   75|     14|void SingleResponse::decode_from(BER_Decoder& from) {
   76|     14|   BER_Object cert_status;
   77|     14|   Extensions extensions;
   78|       |
   79|     14|   from.start_sequence()
   80|     14|      .decode(m_certid)
   81|     14|      .get_next(cert_status)
   82|     14|      .decode(m_thisupdate)
   83|     14|      .decode_optional(m_nextupdate, ASN1_Type(0), ASN1_Class::ContextSpecific | ASN1_Class::Constructed)
   84|     14|      .decode_optional(extensions, ASN1_Type(1), ASN1_Class::ContextSpecific | ASN1_Class::Constructed)
   85|     14|      .end_cons();
   86|       |
   87|       |   /* CertStatus ::= CHOICE {
   88|       |       good        [0]     IMPLICIT NULL,
   89|       |       revoked     [1]     IMPLICIT RevokedInfo,
   90|       |       unknown     [2]     IMPLICIT UnknownInfo }
   91|       |
   92|       |   RevokedInfo ::= SEQUENCE {
   93|       |       revocationTime              GeneralizedTime,
   94|       |       revocationReason    [0]     EXPLICIT CRLReason OPTIONAL }
   95|       |
   96|       |   UnknownInfo ::= NULL
   97|       |
   98|       |   We should verify the expected body and decode the RevokedInfo
   99|       |   */
  100|     14|   m_cert_status = static_cast<uint32_t>(cert_status.type());
  101|     14|}

_ZN5Botan7X509_DN13add_attributeERKNS_3OIDERKNS_11ASN1_StringE:
  100|  2.45k|void X509_DN::add_attribute(const OID& oid, const ASN1_String& str) {
  101|  2.45k|   if(str.empty()) {
  ------------------
  |  Branch (101:7): [True: 437, False: 2.01k]
  ------------------
  102|    437|      return;
  103|    437|   }
  104|       |
  105|  2.01k|   m_rdn.push_back(std::make_pair(oid, str));
  106|  2.01k|   m_dn_bits.clear();
  107|  2.01k|}
_ZNK5Botan7X509_DN14get_attributesEv:
  112|  6.77k|std::multimap<OID, std::string> X509_DN::get_attributes() const {
  113|  6.77k|   std::multimap<OID, std::string> retval;
  114|       |
  115|  6.77k|   for(auto& i : m_rdn) {
  ------------------
  |  Branch (115:16): [True: 1.02k, False: 6.77k]
  ------------------
  116|  1.02k|      multimap_insert(retval, i.first, i.second.value());
  117|  1.02k|   }
  118|  6.77k|   return retval;
  119|  6.77k|}
_ZN5BotaneqERKNS_7X509_DNES2_:
  220|  3.38k|bool operator==(const X509_DN& dn1, const X509_DN& dn2) {
  221|  3.38k|   auto attr1 = dn1.get_attributes();
  222|  3.38k|   auto attr2 = dn2.get_attributes();
  223|       |
  224|  3.38k|   if(attr1.size() != attr2.size()) {
  ------------------
  |  Branch (224:7): [True: 170, False: 3.21k]
  ------------------
  225|    170|      return false;
  226|    170|   }
  227|       |
  228|  3.21k|   auto p1 = attr1.begin();
  229|  3.21k|   auto p2 = attr2.begin();
  230|       |
  231|  3.22k|   while(true) {
  ------------------
  |  Branch (231:10): [Folded - Ignored]
  ------------------
  232|  3.22k|      if(p1 == attr1.end() && p2 == attr2.end()) {
  ------------------
  |  Branch (232:10): [True: 2.98k, False: 244]
  |  Branch (232:10): [True: 2.98k, False: 244]
  |  Branch (232:31): [True: 2.98k, False: 0]
  ------------------
  233|  2.98k|         break;
  234|  2.98k|      }
  235|    244|      if(p1 == attr1.end()) {
  ------------------
  |  Branch (235:10): [True: 0, False: 244]
  ------------------
  236|      0|         return false;
  237|      0|      }
  238|    244|      if(p2 == attr2.end()) {
  ------------------
  |  Branch (238:10): [True: 0, False: 244]
  ------------------
  239|      0|         return false;
  240|      0|      }
  241|    244|      if(p1->first != p2->first) {
  ------------------
  |  Branch (241:10): [True: 108, False: 136]
  ------------------
  242|    108|         return false;
  243|    108|      }
  244|    136|      if(!x500_name_cmp(p1->second, p2->second)) {
  ------------------
  |  Branch (244:10): [True: 125, False: 11]
  ------------------
  245|    125|         return false;
  246|    125|      }
  247|     11|      ++p1;
  248|     11|      ++p2;
  249|     11|   }
  250|  2.98k|   return true;
  251|  3.21k|}
_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  347|  8.90k|void X509_DN::decode_from(BER_Decoder& source) {
  348|  8.90k|   std::vector<uint8_t> bits;
  349|       |
  350|  8.90k|   source.start_sequence().raw_bytes(bits).end_cons();
  351|       |
  352|  8.90k|   BER_Decoder sequence(bits);
  353|       |
  354|  8.90k|   m_rdn.clear();
  355|       |
  356|  12.1k|   while(sequence.more_items()) {
  ------------------
  |  Branch (356:10): [True: 3.28k, False: 8.90k]
  ------------------
  357|  3.28k|      BER_Decoder rdn = sequence.start_set();
  358|       |
  359|  6.21k|      while(rdn.more_items()) {
  ------------------
  |  Branch (359:13): [True: 2.93k, False: 3.28k]
  ------------------
  360|  2.93k|         OID oid;
  361|  2.93k|         ASN1_String str;
  362|       |
  363|  2.93k|         rdn.start_sequence()
  364|  2.93k|            .decode(oid)
  365|  2.93k|            .decode(str)  // TODO support Any
  366|  2.93k|            .end_cons();
  367|       |
  368|  2.93k|         add_attribute(oid, str);
  369|  2.93k|      }
  370|  3.28k|   }
  371|       |
  372|       |   // Have to assign last as add_attribute zaps m_dn_bits
  373|  8.90k|   m_dn_bits = bits;
  374|  8.90k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_7X509_DNE:
  408|    770|std::ostream& operator<<(std::ostream& out, const X509_DN& dn) {
  409|    770|   auto info = dn.dn_info();
  410|       |
  411|  1.28k|   for(size_t i = 0; i != info.size(); ++i) {
  ------------------
  |  Branch (411:22): [True: 516, False: 770]
  ------------------
  412|    516|      out << to_short_form(info[i].first) << "=\"";
  413|  5.05k|      for(char c : info[i].second.value()) {
  ------------------
  |  Branch (413:18): [True: 5.05k, False: 516]
  ------------------
  414|  5.05k|         if(c == '\\' || c == '\"') {
  ------------------
  |  Branch (414:13): [True: 106, False: 4.95k]
  |  Branch (414:26): [True: 94, False: 4.85k]
  ------------------
  415|    200|            out << "\\";
  416|    200|         }
  417|  5.05k|         out << c;
  418|  5.05k|      }
  419|    516|      out << "\"";
  420|       |
  421|    516|      if(i + 1 < info.size()) {
  ------------------
  |  Branch (421:10): [True: 0, False: 516]
  ------------------
  422|      0|         out << ",";
  423|      0|      }
  424|    516|   }
  425|    770|   return out;
  426|    770|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_113x500_name_cmpENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   36|    136|bool x500_name_cmp(std::string_view name1, std::string_view name2) {
   37|    136|   auto p1 = name1.begin();
   38|    136|   auto p2 = name2.begin();
   39|       |
   40|    883|   while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (40:10): [True: 872, False: 11]
  |  Branch (40:33): [True: 747, False: 125]
  ------------------
   41|    747|      ++p1;
   42|    747|   }
   43|    899|   while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (43:10): [True: 884, False: 15]
  |  Branch (43:33): [True: 763, False: 121]
  ------------------
   44|    763|      ++p2;
   45|    763|   }
   46|       |
   47|    697|   while(p1 != name1.end() && p2 != name2.end()) {
  ------------------
  |  Branch (47:10): [True: 679, False: 18]
  |  Branch (47:31): [True: 643, False: 36]
  ------------------
   48|    643|      if(is_space(*p1)) {
  ------------------
  |  Branch (48:10): [True: 157, False: 486]
  ------------------
   49|    157|         if(!is_space(*p2)) {
  ------------------
  |  Branch (49:13): [True: 10, False: 147]
  ------------------
   50|     10|            return false;
   51|     10|         }
   52|       |
   53|    723|         while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (53:16): [True: 709, False: 14]
  |  Branch (53:39): [True: 576, False: 133]
  ------------------
   54|    576|            ++p1;
   55|    576|         }
   56|    721|         while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (56:16): [True: 706, False: 15]
  |  Branch (56:39): [True: 574, False: 132]
  ------------------
   57|    574|            ++p2;
   58|    574|         }
   59|       |
   60|    147|         if(p1 == name1.end() && p2 == name2.end()) {
  ------------------
  |  Branch (60:13): [True: 14, False: 133]
  |  Branch (60:34): [True: 1, False: 13]
  ------------------
   61|      1|            return true;
   62|      1|         }
   63|    146|         if(p1 == name1.end() || p2 == name2.end()) {
  ------------------
  |  Branch (63:13): [True: 13, False: 133]
  |  Branch (63:34): [True: 14, False: 119]
  ------------------
   64|     27|            return false;
   65|     27|         }
   66|    146|      }
   67|       |
   68|    605|      if(!caseless_cmp(*p1, *p2)) {
  ------------------
  |  Branch (68:10): [True: 44, False: 561]
  ------------------
   69|     44|         return false;
   70|     44|      }
   71|    561|      ++p1;
   72|    561|      ++p2;
   73|    561|   }
   74|       |
   75|    320|   while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (75:10): [True: 293, False: 27]
  |  Branch (75:33): [True: 266, False: 27]
  ------------------
   76|    266|      ++p1;
   77|    266|   }
   78|    106|   while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (78:10): [True: 69, False: 37]
  |  Branch (78:33): [True: 52, False: 17]
  ------------------
   79|     52|      ++p2;
   80|     52|   }
   81|       |
   82|     54|   if((p1 != name1.end()) || (p2 != name2.end())) {
  ------------------
  |  Branch (82:7): [True: 27, False: 27]
  |  Branch (82:30): [True: 17, False: 10]
  ------------------
   83|     44|      return false;
   84|     44|   }
   85|     10|   return true;
   86|     54|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_112_GLOBAL__N_18is_spaceEc:
   27|  4.33k|bool is_space(char c) {
   28|  4.33k|   return std::isspace(static_cast<unsigned char>(c));
   29|  4.33k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_112_GLOBAL__N_112caseless_cmpEcc:
   23|    605|bool caseless_cmp(char a, char b) {
   24|    605|   return (std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b)));
   25|    605|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_113to_short_formERKNS_3OIDE:
  378|    516|std::string to_short_form(const OID& oid) {
  379|    516|   std::string long_id = oid.to_formatted_string();
  380|       |
  381|    516|   if(long_id == "X520.CommonName") {
  ------------------
  |  Branch (381:7): [True: 10, False: 506]
  ------------------
  382|     10|      return "CN";
  383|     10|   }
  384|       |
  385|    506|   if(long_id == "X520.Country") {
  ------------------
  |  Branch (385:7): [True: 10, False: 496]
  ------------------
  386|     10|      return "C";
  387|     10|   }
  388|       |
  389|    496|   if(long_id == "X520.Organization") {
  ------------------
  |  Branch (389:7): [True: 11, False: 485]
  ------------------
  390|     11|      return "O";
  391|     11|   }
  392|       |
  393|    485|   if(long_id == "X520.OrganizationalUnit") {
  ------------------
  |  Branch (393:7): [True: 25, False: 460]
  ------------------
  394|     25|      return "OU";
  395|     25|   }
  396|       |
  397|    460|   return long_id;
  398|    485|}

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

_ZN5Botan11X509_Object9load_dataERNS_10DataSourceE:
   24|  4.10k|void X509_Object::load_data(DataSource& in) {
   25|  4.10k|   try {
   26|  4.10k|      if(ASN1::maybe_BER(in) && !PEM_Code::matches(in)) {
  ------------------
  |  Branch (26:10): [True: 3.79k, False: 314]
  |  Branch (26:33): [True: 3.78k, False: 4]
  ------------------
   27|  3.78k|         BER_Decoder dec(in);
   28|  3.78k|         decode_from(dec);
   29|  3.78k|      } else {
   30|    318|         std::string got_label;
   31|    318|         DataSource_Memory ber(PEM_Code::decode(in, got_label));
   32|       |
   33|    318|         if(got_label != PEM_label()) {
  ------------------
  |  Branch (33:13): [True: 50, False: 268]
  ------------------
   34|     50|            bool is_alternate = false;
   35|     50|            for(std::string_view alt_label : alternate_PEM_labels()) {
  ------------------
  |  Branch (35:44): [True: 50, False: 50]
  ------------------
   36|     50|               if(got_label == alt_label) {
  ------------------
  |  Branch (36:19): [True: 0, False: 50]
  ------------------
   37|      0|                  is_alternate = true;
   38|      0|                  break;
   39|      0|               }
   40|     50|            }
   41|       |
   42|     50|            if(!is_alternate) {
  ------------------
  |  Branch (42:16): [True: 50, False: 0]
  ------------------
   43|     50|               throw Decoding_Error("Unexpected PEM label for " + PEM_label() + " of " + got_label);
   44|     50|            }
   45|     50|         }
   46|       |
   47|    268|         BER_Decoder dec(ber);
   48|    268|         decode_from(dec);
   49|    268|      }
   50|  4.10k|   } catch(Decoding_Error& e) {
   51|    594|      throw Decoding_Error(PEM_label() + " decoding", e);
   52|    594|   }
   53|  4.10k|}
_ZNK5Botan11X509_Object11encode_intoERNS_11DER_EncoderE:
   55|  3.38k|void X509_Object::encode_into(DER_Encoder& to) const {
   56|  3.38k|   to.start_sequence()
   57|  3.38k|      .start_sequence()
   58|  3.38k|      .raw_bytes(signed_body())
   59|  3.38k|      .end_cons()
   60|  3.38k|      .encode(signature_algorithm())
   61|  3.38k|      .encode(signature(), ASN1_Type::BitString)
   62|  3.38k|      .end_cons();
   63|  3.38k|}
_ZN5Botan11X509_Object11decode_fromERNS_11BER_DecoderE:
   68|  3.78k|void X509_Object::decode_from(BER_Decoder& from) {
   69|  3.78k|   from.start_sequence()
   70|  3.78k|      .start_sequence()
   71|  3.78k|      .raw_bytes(m_tbs_bits)
   72|  3.78k|      .end_cons()
   73|  3.78k|      .decode(m_sig_algo)
   74|  3.78k|      .decode(m_sig, ASN1_Type::BitString)
   75|  3.78k|      .end_cons();
   76|       |
   77|  3.78k|   force_decode();
   78|  3.78k|}
_ZNK5Botan11X509_Object8tbs_dataEv:
   90|  1.44k|std::vector<uint8_t> X509_Object::tbs_data() const {
   91|  1.44k|   return ASN1::put_in_sequence(m_tbs_bits);
   92|  1.44k|}
_ZNK5Botan11X509_Object16verify_signatureERKNS_10Public_KeyE:
  102|  1.45k|std::pair<Certificate_Status_Code, std::string> X509_Object::verify_signature(const Public_Key& pub_key) const {
  103|  1.45k|   try {
  104|  1.45k|      PK_Verifier verifier(pub_key, signature_algorithm());
  105|  1.45k|      const bool valid = verifier.verify_message(tbs_data(), signature());
  106|       |
  107|  1.45k|      if(valid) {
  ------------------
  |  Branch (107:10): [True: 0, False: 1.45k]
  ------------------
  108|      0|         return std::make_pair(Certificate_Status_Code::VERIFIED, verifier.hash_function());
  109|  1.45k|      } else {
  110|  1.45k|         return std::make_pair(Certificate_Status_Code::SIGNATURE_ERROR, "");
  111|  1.45k|      }
  112|  1.45k|   } catch(Decoding_Error&) {
  113|     12|      return std::make_pair(Certificate_Status_Code::SIGNATURE_ALGO_BAD_PARAMS, "");
  114|     12|   } catch(Algorithm_Not_Found&) {
  115|      1|      return std::make_pair(Certificate_Status_Code::SIGNATURE_ALGO_UNKNOWN, "");
  116|      1|   } catch(...) {
  117|       |      // This shouldn't happen, fallback to generic signature error
  118|      0|      return std::make_pair(Certificate_Status_Code::SIGNATURE_ERROR, "");
  119|      0|   }
  120|  1.45k|}

_ZNK5Botan16X509_Certificate9PEM_labelEv:
   70|    694|std::string X509_Certificate::PEM_label() const {
   71|    694|   return "CERTIFICATE";
   72|    694|}
_ZNK5Botan16X509_Certificate20alternate_PEM_labelsEv:
   74|     50|std::vector<std::string> X509_Certificate::alternate_PEM_labels() const {
   75|     50|   return {"X509 CERTIFICATE"};
   76|     50|}
_ZN5Botan16X509_CertificateC2EPKhm:
   87|  4.10k|X509_Certificate::X509_Certificate(const uint8_t data[], size_t len) {
   88|  4.10k|   DataSource_Memory src(data, len);
   89|  4.10k|   load_data(src);
   90|  4.10k|}
_ZN5Botan16X509_Certificate12force_decodeEv:
  282|  3.67k|void X509_Certificate::force_decode() {
  283|  3.67k|   m_data.reset();
  284|  3.67k|   m_data = parse_x509_cert_body(*this);
  285|  3.67k|}
x509cert.cpp:_ZN5Botan12_GLOBAL__N_120parse_x509_cert_bodyERKNS_11X509_ObjectE:
  101|  3.67k|std::unique_ptr<X509_Certificate_Data> parse_x509_cert_body(const X509_Object& obj) {
  102|  3.67k|   auto data = std::make_unique<X509_Certificate_Data>();
  103|       |
  104|  3.67k|   BigInt serial_bn;
  105|  3.67k|   BER_Object public_key;
  106|  3.67k|   BER_Object v3_exts_data;
  107|       |
  108|  3.67k|   BER_Decoder(obj.signed_body())
  109|  3.67k|      .decode_optional(data->m_version, ASN1_Type(0), ASN1_Class::Constructed | ASN1_Class::ContextSpecific)
  110|  3.67k|      .decode(serial_bn)
  111|  3.67k|      .decode(data->m_sig_algo_inner)
  112|  3.67k|      .decode(data->m_issuer_dn)
  113|  3.67k|      .start_sequence()
  114|  3.67k|      .decode(data->m_not_before)
  115|  3.67k|      .decode(data->m_not_after)
  116|  3.67k|      .end_cons()
  117|  3.67k|      .decode(data->m_subject_dn)
  118|  3.67k|      .get_next(public_key)
  119|  3.67k|      .decode_optional_string(data->m_v2_issuer_key_id, ASN1_Type::BitString, 1)
  120|  3.67k|      .decode_optional_string(data->m_v2_subject_key_id, ASN1_Type::BitString, 2)
  121|  3.67k|      .get_next(v3_exts_data)
  122|  3.67k|      .verify_end("TBSCertificate has extra data after extensions block");
  123|       |
  124|  3.67k|   if(data->m_version > 2) {
  ------------------
  |  Branch (124:7): [True: 1, False: 3.67k]
  ------------------
  125|      1|      throw Decoding_Error("Unknown X.509 cert version " + std::to_string(data->m_version));
  126|      1|   }
  127|  3.67k|   if(obj.signature_algorithm() != data->m_sig_algo_inner) {
  ------------------
  |  Branch (127:7): [True: 34, False: 3.64k]
  ------------------
  128|     34|      throw Decoding_Error("X.509 Certificate had differing algorithm identifers in inner and outer ID fields");
  129|     34|   }
  130|       |
  131|  3.64k|   public_key.assert_is_a(ASN1_Type::Sequence, ASN1_Class::Constructed, "X.509 certificate public key");
  132|       |
  133|       |   // crude method to save the serial's sign; will get lost during decoding, otherwise
  134|  3.64k|   data->m_serial_negative = serial_bn.is_negative();
  135|       |
  136|       |   // for general sanity convert wire version (0 based) to standards version (v1 .. v3)
  137|  3.64k|   data->m_version += 1;
  138|       |
  139|  3.64k|   data->m_serial = BigInt::encode(serial_bn);
  140|  3.64k|   data->m_subject_dn_bits = ASN1::put_in_sequence(data->m_subject_dn.get_bits());
  141|  3.64k|   data->m_issuer_dn_bits = ASN1::put_in_sequence(data->m_issuer_dn.get_bits());
  142|       |
  143|  3.64k|   data->m_subject_public_key_bits.assign(public_key.bits(), public_key.bits() + public_key.length());
  144|       |
  145|  3.64k|   data->m_subject_public_key_bits_seq = ASN1::put_in_sequence(data->m_subject_public_key_bits);
  146|       |
  147|  3.64k|   BER_Decoder(data->m_subject_public_key_bits)
  148|  3.64k|      .decode(data->m_subject_public_key_algid)
  149|  3.64k|      .decode(data->m_subject_public_key_bitstring, ASN1_Type::BitString);
  150|       |
  151|  3.64k|   if(v3_exts_data.is_a(3, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (151:7): [True: 1.48k, False: 2.15k]
  ------------------
  152|       |      // Path validation will reject a v1/v2 cert with v3 extensions
  153|  1.48k|      BER_Decoder(v3_exts_data).decode(data->m_v3_extensions).verify_end();
  154|  2.15k|   } else if(v3_exts_data.is_set()) {
  ------------------
  |  Branch (154:14): [True: 9, False: 2.14k]
  ------------------
  155|      9|      throw BER_Bad_Tag("Unknown tag in X.509 cert", v3_exts_data.tagging());
  156|      9|   }
  157|       |
  158|       |   // Now cache some fields from the extensions
  159|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Key_Usage>()) {
  ------------------
  |  Branch (159:12): [True: 20, False: 3.61k]
  ------------------
  160|     20|      data->m_key_constraints = ext->get_constraints();
  161|       |      /*
  162|       |      RFC 5280: When the keyUsage extension appears in a certificate,
  163|       |      at least one of the bits MUST be set to 1.
  164|       |      */
  165|     20|      if(data->m_key_constraints.empty()) {
  ------------------
  |  Branch (165:10): [True: 2, False: 18]
  ------------------
  166|      2|         throw Decoding_Error("Certificate has invalid encoding for KeyUsage");
  167|      2|      }
  168|     20|   }
  169|       |
  170|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Key_ID>()) {
  ------------------
  |  Branch (170:12): [True: 25, False: 3.60k]
  ------------------
  171|     25|      data->m_subject_key_id = ext->get_key_id();
  172|     25|   }
  173|       |
  174|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
  ------------------
  |  Branch (174:12): [True: 24, False: 3.60k]
  ------------------
  175|     24|      data->m_authority_key_id = ext->get_key_id();
  176|     24|   }
  177|       |
  178|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Name_Constraints>()) {
  ------------------
  |  Branch (178:12): [True: 33, False: 3.59k]
  ------------------
  179|     33|      data->m_name_constraints = ext->get_name_constraints();
  180|     33|   }
  181|       |
  182|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Basic_Constraints>()) {
  ------------------
  |  Branch (182:12): [True: 44, False: 3.58k]
  ------------------
  183|     44|      if(ext->get_is_ca() == true) {
  ------------------
  |  Branch (183:10): [True: 26, False: 18]
  ------------------
  184|       |         /*
  185|       |         * RFC 5280 section 4.2.1.3 requires that CAs include KeyUsage in all
  186|       |         * intermediate CA certificates they issue. Currently we accept it being
  187|       |         * missing, as do most other implementations. But it may be worth
  188|       |         * removing this entirely, or alternately adding a warning level
  189|       |         * validation failure for it.
  190|       |         */
  191|     26|         if(data->m_key_constraints.empty() || data->m_key_constraints.includes(Key_Constraints::KeyCertSign)) {
  ------------------
  |  Branch (191:13): [True: 17, False: 9]
  |  Branch (191:48): [True: 8, False: 1]
  ------------------
  192|     25|            data->m_is_ca_certificate = true;
  193|     25|            data->m_path_len_constraint = ext->get_path_limit();
  194|     25|         }
  195|     26|      }
  196|     44|   }
  197|       |
  198|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Issuer_Alternative_Name>()) {
  ------------------
  |  Branch (198:12): [True: 269, False: 3.36k]
  ------------------
  199|    269|      data->m_issuer_alt_name = ext->get_alt_name();
  200|    269|   }
  201|       |
  202|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Alternative_Name>()) {
  ------------------
  |  Branch (202:12): [True: 77, False: 3.55k]
  ------------------
  203|     77|      data->m_subject_alt_name = ext->get_alt_name();
  204|     77|   }
  205|       |
  206|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Extended_Key_Usage>()) {
  ------------------
  |  Branch (206:12): [True: 23, False: 3.60k]
  ------------------
  207|     23|      data->m_extended_key_usage = ext->object_identifiers();
  208|     23|   }
  209|       |
  210|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Certificate_Policies>()) {
  ------------------
  |  Branch (210:12): [True: 27, False: 3.60k]
  ------------------
  211|     27|      data->m_cert_policies = ext->get_policy_oids();
  212|     27|   }
  213|       |
  214|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Information_Access>()) {
  ------------------
  |  Branch (214:12): [True: 33, False: 3.59k]
  ------------------
  215|     33|      data->m_ocsp_responder = ext->ocsp_responder();
  216|     33|      data->m_ca_issuers = ext->ca_issuers();
  217|     33|   }
  218|       |
  219|  3.63k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::CRL_Distribution_Points>()) {
  ------------------
  |  Branch (219:12): [True: 113, False: 3.51k]
  ------------------
  220|    113|      data->m_crl_distribution_points = ext->crl_distribution_urls();
  221|    113|   }
  222|       |
  223|       |   // Check for self-signed vs self-issued certificates
  224|  3.63k|   if(data->m_subject_dn == data->m_issuer_dn) {
  ------------------
  |  Branch (224:7): [True: 2.98k, False: 646]
  ------------------
  225|  2.98k|      if(data->m_subject_key_id.empty() == false && data->m_authority_key_id.empty() == false) {
  ------------------
  |  Branch (225:10): [True: 5, False: 2.98k]
  |  Branch (225:53): [True: 4, False: 1]
  ------------------
  226|      4|         data->m_self_signed = (data->m_subject_key_id == data->m_authority_key_id);
  227|  2.98k|      } else {
  228|       |         /*
  229|       |         If a parse error or unknown algorithm is encountered, default
  230|       |         to assuming it is self signed. We have no way of being certain but
  231|       |         that is usually the default case (self-issued is rare in practice).
  232|       |         */
  233|  2.98k|         data->m_self_signed = true;
  234|       |
  235|  2.98k|         try {
  236|  2.98k|            auto pub_key = X509::load_key(data->m_subject_public_key_bits_seq);
  237|       |
  238|  2.98k|            const auto sig_status = obj.verify_signature(*pub_key);
  239|       |
  240|  2.98k|            if(sig_status.first == Certificate_Status_Code::OK ||
  ------------------
  |  Branch (240:16): [True: 1.52k, False: 1.45k]
  ------------------
  241|  2.98k|               sig_status.first == Certificate_Status_Code::SIGNATURE_ALGO_UNKNOWN) {
  ------------------
  |  Branch (241:16): [True: 1, False: 1.45k]
  ------------------
  242|      1|               data->m_self_signed = true;
  243|  2.98k|            } else {
  244|  2.98k|               data->m_self_signed = false;
  245|  2.98k|            }
  246|  2.98k|         } catch(...) {
  247|       |            // ignore errors here to allow parsing to continue
  248|  1.52k|         }
  249|  2.98k|      }
  250|  2.98k|   }
  251|       |
  252|  3.63k|   const std::vector<uint8_t> full_encoding = obj.BER_encode();
  253|       |
  254|  3.63k|   auto sha1 = HashFunction::create("SHA-1");
  255|  3.63k|   if(sha1) {
  ------------------
  |  Branch (255:7): [True: 3.38k, False: 245]
  ------------------
  256|  3.38k|      sha1->update(data->m_subject_public_key_bitstring);
  257|  3.38k|      data->m_subject_public_key_bitstring_sha1 = sha1->final_stdvec();
  258|       |      // otherwise left as empty, and we will throw if subject_public_key_bitstring_sha1 is called
  259|       |
  260|  3.38k|      data->m_fingerprint_sha1 = create_hex_fingerprint(full_encoding, "SHA-1");
  261|  3.38k|   }
  262|       |
  263|  3.63k|   auto sha256 = HashFunction::create("SHA-256");
  264|  3.63k|   if(sha256) {
  ------------------
  |  Branch (264:7): [True: 3.38k, False: 245]
  ------------------
  265|  3.38k|      sha256->update(data->m_issuer_dn_bits);
  266|  3.38k|      data->m_issuer_dn_bits_sha256 = sha256->final_stdvec();
  267|       |
  268|  3.38k|      sha256->update(data->m_subject_dn_bits);
  269|  3.38k|      data->m_subject_dn_bits_sha256 = sha256->final_stdvec();
  270|       |
  271|  3.38k|      data->m_fingerprint_sha256 = create_hex_fingerprint(full_encoding, "SHA-256");
  272|  3.38k|   }
  273|       |
  274|  3.63k|   return data;
  275|  3.63k|}