_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EED2Ev:
   65|    123|      ~AlignmentBuffer() { secure_scrub_memory(m_buffer.data(), m_buffer.size()); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EED2Ev:
   65|  18.7k|      ~AlignmentBuffer() { secure_scrub_memory(m_buffer.data(), m_buffer.size()); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EEC2Ev:
   63|  18.7k|      AlignmentBuffer() : m_position(0) {}
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE5clearEv:
   72|  42.1k|      void clear() {
   73|  42.1k|         clear_mem(m_buffer.data(), m_buffer.size());
   74|  42.1k|         m_position = 0;
   75|  42.1k|      }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EEC2Ev:
   63|    663|      AlignmentBuffer() : m_position(0) {}
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE5clearEv:
   72|  1.32k|      void clear() {
   73|  1.32k|         clear_mem(m_buffer.data(), m_buffer.size());
   74|  1.32k|         m_position = 0;
   75|  1.32k|      }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EED2Ev:
   65|    663|      ~AlignmentBuffer() { secure_scrub_memory(m_buffer.data(), m_buffer.size()); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE21handle_unaligned_dataERNS_12BufferSlicerE:
  167|  39.4k|      [[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|  39.4k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (171:31): [True: 0, False: 39.4k]
  ------------------
  172|       |
  173|  39.4k|         if(in_alignment() && slicer.remaining() >= m_buffer.size() + defer) {
  ------------------
  |  Branch (173:13): [True: 39.1k, False: 287]
  |  Branch (173:31): [True: 15.8k, False: 23.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|  15.8k|            return std::nullopt;
  178|  15.8k|         }
  179|       |
  180|       |         // Fill the buffer with as much input data as needed to reach alignment
  181|       |         // or until the input source is depleted.
  182|  23.5k|         const auto elements_to_consume = std::min(m_buffer.size() - m_position, slicer.remaining());
  183|  23.5k|         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|  23.5k|         if(ready_to_consume() && (!defers_final_block() || !slicer.empty())) {
  ------------------
  |  Branch (189:13): [True: 6, False: 23.5k]
  |  Branch (189:36): [True: 6, False: 0]
  |  Branch (189:61): [True: 0, False: 0]
  ------------------
  190|      6|            return consume();
  191|  23.5k|         } else {
  192|  23.5k|            return std::nullopt;
  193|  23.5k|         }
  194|  23.5k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18defers_final_blockEv:
  234|  56.5k|      constexpr bool defers_final_block() const {
  235|  56.5k|         return FINAL_BLOCK_STRATEGY == AlignmentBufferFinalBlock::must_be_deferred;
  236|  56.5k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE6appendENSt3__14spanIKhLm18446744073709551615EEE:
   91|  47.0k|      void append(std::span<const T> elements) {
   92|  47.0k|         BOTAN_ASSERT_NOMSG(elements.size() <= elements_until_alignment());
  ------------------
  |  |   60|  47.0k|   do {                                                                     \
  |  |   61|  47.0k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 47.0k]
  |  |  ------------------
  |  |   62|  47.0k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  47.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   93|  47.0k|         std::copy(elements.begin(), elements.end(), m_buffer.begin() + m_position);
   94|  47.0k|         m_position += elements.size();
   95|  47.0k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE24elements_until_alignmentEv:
  222|   118k|      size_t elements_until_alignment() const { return m_buffer.size() - m_position; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE16ready_to_consumeEv:
  232|  95.8k|      bool ready_to_consume() const { return m_position == m_buffer.size(); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE7consumeEv:
  201|  24.4k|      [[nodiscard]] std::span<const T> consume() {
  202|  24.4k|         BOTAN_ASSERT_NOMSG(ready_to_consume());
  ------------------
  |  |   60|  24.4k|   do {                                                                     \
  |  |   61|  24.4k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 24.4k]
  |  |  ------------------
  |  |   62|  24.4k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  24.4k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  203|  24.4k|         m_position = 0;
  204|  24.4k|         return m_buffer;
  205|  24.4k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE12in_alignmentEv:
  227|  95.9k|      bool in_alignment() const { return m_position == 0; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE23aligned_data_to_processERNS_12BufferSlicerE:
  127|  15.7k|      [[nodiscard]] std::tuple<std::span<const uint8_t>, size_t> aligned_data_to_process(BufferSlicer& slicer) const {
  128|  15.7k|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|  15.7k|   do {                                                                     \
  |  |   61|  15.7k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 15.7k]
  |  |  ------------------
  |  |   62|  15.7k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  15.7k|   } 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|  15.7k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (132:31): [True: 0, False: 15.7k]
  ------------------
  133|  15.7k|         const size_t full_blocks_to_process = (slicer.remaining() - defer) / m_buffer.size();
  134|  15.7k|         return {slicer.take(full_blocks_to_process * m_buffer.size()), full_blocks_to_process};
  135|  15.7k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18fill_up_with_zerosEv:
   80|  24.4k|      void fill_up_with_zeros() {
   81|  24.4k|         if(!ready_to_consume()) {
  ------------------
  |  Branch (81:13): [True: 24.4k, False: 65]
  ------------------
   82|  24.4k|            clear_mem(&m_buffer[m_position], elements_until_alignment());
   83|  24.4k|            m_position = m_buffer.size();
   84|  24.4k|         }
   85|  24.4k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE20directly_modify_lastEm:
  114|  23.2k|      std::span<T> directly_modify_last(size_t elements) {
  115|  23.2k|         BOTAN_ASSERT_NOMSG(size() >= elements);
  ------------------
  |  |   60|  23.2k|   do {                                                                     \
  |  |   61|  23.2k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 23.2k]
  |  |  ------------------
  |  |   62|  23.2k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  23.2k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  23.2k|         return std::span(m_buffer).last(elements);
  117|  23.2k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE4sizeEv:
  218|  23.4k|      constexpr size_t size() const { return m_buffer.size(); }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE21handle_unaligned_dataERNS_12BufferSlicerE:
  167|  1.31k|      [[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|  1.31k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (171:31): [True: 0, False: 1.31k]
  ------------------
  172|       |
  173|  1.31k|         if(in_alignment() && slicer.remaining() >= m_buffer.size() + defer) {
  ------------------
  |  Branch (173:13): [True: 1.31k, False: 0]
  |  Branch (173:31): [True: 663, False: 653]
  ------------------
  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|    663|            return std::nullopt;
  178|    663|         }
  179|       |
  180|       |         // Fill the buffer with as much input data as needed to reach alignment
  181|       |         // or until the input source is depleted.
  182|    653|         const auto elements_to_consume = std::min(m_buffer.size() - m_position, slicer.remaining());
  183|    653|         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|    653|         if(ready_to_consume() && (!defers_final_block() || !slicer.empty())) {
  ------------------
  |  Branch (189:13): [True: 0, False: 653]
  |  Branch (189:36): [True: 0, False: 0]
  |  Branch (189:61): [True: 0, False: 0]
  ------------------
  190|      0|            return consume();
  191|    653|         } else {
  192|    653|            return std::nullopt;
  193|    653|         }
  194|    653|      }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE18defers_final_blockEv:
  234|  1.97k|      constexpr bool defers_final_block() const {
  235|  1.97k|         return FINAL_BLOCK_STRATEGY == AlignmentBufferFinalBlock::must_be_deferred;
  236|  1.97k|      }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE6appendENSt3__14spanIKhLm18446744073709551615EEE:
   91|  1.31k|      void append(std::span<const T> elements) {
   92|  1.31k|         BOTAN_ASSERT_NOMSG(elements.size() <= elements_until_alignment());
  ------------------
  |  |   60|  1.31k|   do {                                                                     \
  |  |   61|  1.31k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.31k]
  |  |  ------------------
  |  |   62|  1.31k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.31k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   93|  1.31k|         std::copy(elements.begin(), elements.end(), m_buffer.begin() + m_position);
   94|  1.31k|         m_position += elements.size();
   95|  1.31k|      }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE24elements_until_alignmentEv:
  222|  3.32k|      size_t elements_until_alignment() const { return m_buffer.size() - m_position; }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE16ready_to_consumeEv:
  232|  2.71k|      bool ready_to_consume() const { return m_position == m_buffer.size(); }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE7consumeEv:
  201|    699|      [[nodiscard]] std::span<const T> consume() {
  202|    699|         BOTAN_ASSERT_NOMSG(ready_to_consume());
  ------------------
  |  |   60|    699|   do {                                                                     \
  |  |   61|    699|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 699]
  |  |  ------------------
  |  |   62|    699|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    699|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  203|    699|         m_position = 0;
  204|    699|         return m_buffer;
  205|    699|      }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE12in_alignmentEv:
  227|  3.29k|      bool in_alignment() const { return m_position == 0; }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE23aligned_data_to_processERNS_12BufferSlicerE:
  127|    663|      [[nodiscard]] std::tuple<std::span<const uint8_t>, size_t> aligned_data_to_process(BufferSlicer& slicer) const {
  128|    663|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|    663|   do {                                                                     \
  |  |   61|    663|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   62|    663|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    663|   } 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|    663|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (132:31): [True: 0, False: 663]
  ------------------
  133|    663|         const size_t full_blocks_to_process = (slicer.remaining() - defer) / m_buffer.size();
  134|    663|         return {slicer.take(full_blocks_to_process * m_buffer.size()), full_blocks_to_process};
  135|    663|      }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE18fill_up_with_zerosEv:
   80|    699|      void fill_up_with_zeros() {
   81|    699|         if(!ready_to_consume()) {
  ------------------
  |  Branch (81:13): [True: 686, False: 13]
  ------------------
   82|    686|            clear_mem(&m_buffer[m_position], elements_until_alignment());
   83|    686|            m_position = m_buffer.size();
   84|    686|         }
   85|    699|      }
_ZN5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE20directly_modify_lastEm:
  114|    663|      std::span<T> directly_modify_last(size_t elements) {
  115|    663|         BOTAN_ASSERT_NOMSG(size() >= elements);
  ------------------
  |  |   60|    663|   do {                                                                     \
  |  |   61|    663|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   62|    663|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    663|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|    663|         return std::span(m_buffer).last(elements);
  117|    663|      }
_ZNK5Botan15AlignmentBufferIhLm128ELNS_25AlignmentBufferFinalBlockE0EE4sizeEv:
  218|    663|      constexpr size_t size() const { return m_buffer.size(); }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE29next_aligned_block_to_processERNS_12BufferSlicerE:
  144|  1.35k|      [[nodiscard]] std::optional<std::span<const uint8_t>> next_aligned_block_to_process(BufferSlicer& slicer) const {
  145|  1.35k|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|  1.35k|   do {                                                                     \
  |  |   61|  1.35k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.35k]
  |  |  ------------------
  |  |   62|  1.35k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.35k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|       |
  147|       |         // When the final block is to be deferred, the last block must not be
  148|       |         // selected for processing if there is no (unaligned) extra input data.
  149|  1.35k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (149:31): [True: 0, False: 1.35k]
  ------------------
  150|  1.35k|         if(slicer.remaining() < m_buffer.size() + defer) {
  ------------------
  |  Branch (150:13): [True: 151, False: 1.20k]
  ------------------
  151|    151|            return std::nullopt;
  152|    151|         }
  153|       |
  154|  1.20k|         return slicer.take(m_buffer.size());
  155|  1.35k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18elements_in_bufferEv:
  220|    151|      size_t elements_in_buffer() const { return m_position; }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE21directly_modify_firstEm:
  103|    151|      std::span<T> directly_modify_first(size_t elements) {
  104|    151|         BOTAN_ASSERT_NOMSG(size() >= elements);
  ------------------
  |  |   60|    151|   do {                                                                     \
  |  |   61|    151|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 151]
  |  |  ------------------
  |  |   62|    151|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    151|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  105|    151|         return std::span(m_buffer).first(elements);
  106|    151|      }
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EEC2Ev:
   63|    123|      AlignmentBuffer() : m_position(0) {}
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE5clearEv:
   72|    123|      void clear() {
   73|    123|         clear_mem(m_buffer.data(), m_buffer.size());
   74|    123|         m_position = 0;
   75|    123|      }
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE21handle_unaligned_dataERNS_12BufferSlicerE:
  167|    246|      [[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|    246|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (171:31): [True: 0, False: 246]
  ------------------
  172|       |
  173|    246|         if(in_alignment() && slicer.remaining() >= m_buffer.size() + defer) {
  ------------------
  |  Branch (173:13): [True: 246, False: 0]
  |  Branch (173:31): [True: 123, False: 123]
  ------------------
  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|    123|            return std::nullopt;
  178|    123|         }
  179|       |
  180|       |         // Fill the buffer with as much input data as needed to reach alignment
  181|       |         // or until the input source is depleted.
  182|    123|         const auto elements_to_consume = std::min(m_buffer.size() - m_position, slicer.remaining());
  183|    123|         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|    123|         if(ready_to_consume() && (!defers_final_block() || !slicer.empty())) {
  ------------------
  |  Branch (189:13): [True: 0, False: 123]
  |  Branch (189:36): [True: 0, False: 0]
  |  Branch (189:61): [True: 0, False: 0]
  ------------------
  190|      0|            return consume();
  191|    123|         } else {
  192|    123|            return std::nullopt;
  193|    123|         }
  194|    123|      }
_ZNK5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE18defers_final_blockEv:
  234|    369|      constexpr bool defers_final_block() const {
  235|    369|         return FINAL_BLOCK_STRATEGY == AlignmentBufferFinalBlock::must_be_deferred;
  236|    369|      }
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE6appendENSt3__14spanIKhLm18446744073709551615EEE:
   91|    123|      void append(std::span<const T> elements) {
   92|    123|         BOTAN_ASSERT_NOMSG(elements.size() <= elements_until_alignment());
  ------------------
  |  |   60|    123|   do {                                                                     \
  |  |   61|    123|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 123]
  |  |  ------------------
  |  |   62|    123|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    123|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   93|    123|         std::copy(elements.begin(), elements.end(), m_buffer.begin() + m_position);
   94|    123|         m_position += elements.size();
   95|    123|      }
_ZNK5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE24elements_until_alignmentEv:
  222|    246|      size_t elements_until_alignment() const { return m_buffer.size() - m_position; }
_ZNK5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE16ready_to_consumeEv:
  232|    369|      bool ready_to_consume() const { return m_position == m_buffer.size(); }
_ZNK5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE12in_alignmentEv:
  227|    738|      bool in_alignment() const { return m_position == 0; }
_ZNK5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE23aligned_data_to_processERNS_12BufferSlicerE:
  127|    123|      [[nodiscard]] std::tuple<std::span<const uint8_t>, size_t> aligned_data_to_process(BufferSlicer& slicer) const {
  128|    123|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|    123|   do {                                                                     \
  |  |   61|    123|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 123]
  |  |  ------------------
  |  |   62|    123|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    123|   } 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|    123|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (132:31): [True: 0, False: 123]
  ------------------
  133|    123|         const size_t full_blocks_to_process = (slicer.remaining() - defer) / m_buffer.size();
  134|    123|         return {slicer.take(full_blocks_to_process * m_buffer.size()), full_blocks_to_process};
  135|    123|      }
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE18fill_up_with_zerosEv:
   80|    123|      void fill_up_with_zeros() {
   81|    123|         if(!ready_to_consume()) {
  ------------------
  |  Branch (81:13): [True: 123, False: 0]
  ------------------
   82|    123|            clear_mem(&m_buffer[m_position], elements_until_alignment());
   83|    123|            m_position = m_buffer.size();
   84|    123|         }
   85|    123|      }
_ZN5Botan15AlignmentBufferIhLm32ELNS_25AlignmentBufferFinalBlockE0EE7consumeEv:
  201|    123|      [[nodiscard]] std::span<const T> consume() {
  202|    123|         BOTAN_ASSERT_NOMSG(ready_to_consume());
  ------------------
  |  |   60|    123|   do {                                                                     \
  |  |   61|    123|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 123]
  |  |  ------------------
  |  |   62|    123|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    123|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  203|    123|         m_position = 0;
  204|    123|         return m_buffer;
  205|    123|      }

_ZN5Botan10ct_is_zeroIjEET_S1_:
   35|  98.3k|{
   36|  98.3k|   return expand_top_bit<T>(~x & (x - 1));
   37|  98.3k|}
_ZN5Botan14expand_top_bitIjEET_S1_:
   25|  98.3k|{
   26|  98.3k|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  98.3k|}
_ZN5Botan8high_bitIjEEmT_:
   60|  19.6k|{
   61|  19.6k|   size_t hb = 0;
   62|       |
   63|   118k|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 98.3k, False: 19.6k]
  ------------------
   64|  98.3k|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|  98.3k|      hb += z;
   66|  98.3k|      n >>= z;
   67|  98.3k|   }
   68|       |
   69|  19.6k|   hb += n;
   70|       |
   71|  19.6k|   return hb;
   72|  19.6k|}
_ZN5Botan14expand_top_bitIhEET_S1_:
   25|  5.74M|{
   26|  5.74M|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|  5.74M|}
_ZN5Botan17significant_bytesImEEmT_:
   82|  12.7k|{
   83|  12.7k|   size_t b = 0;
   84|       |
   85|  51.1k|   for(size_t s = 8 * sizeof(n) / 2; s >= 8; s /= 2) {
  ------------------
  |  Branch (85:38): [True: 38.3k, False: 12.7k]
  ------------------
   86|  38.3k|      const size_t z = s * (~ct_is_zero(n >> s) & 1);
   87|  38.3k|      b += z / 8;
   88|  38.3k|      n >>= z;
   89|  38.3k|   }
   90|       |
   91|  12.7k|   b += (n != 0);
   92|       |
   93|  12.7k|   return b;
   94|  12.7k|}
_ZN5Botan10ct_is_zeroImEET_S1_:
   35|   122M|{
   36|   122M|   return expand_top_bit<T>(~x & (x - 1));
   37|   122M|}
_ZN5Botan14expand_top_bitImEET_S1_:
   25|   150M|{
   26|   150M|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|   150M|}
_ZN5Botan6chooseIhEET_S1_S1_S1_:
  180|  5.74M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|  5.74M|   return (b ^ (mask & (a ^ b)));
  183|  5.74M|}
_ZN5Botan13is_power_of_2ImEEbT_:
   47|   115k|{
   48|   115k|   return (arg != 0) && (arg != 1) && ((arg & static_cast<T>(arg - 1)) == 0);
  ------------------
  |  Branch (48:11): [True: 115k, False: 0]
  |  Branch (48:25): [True: 115k, False: 0]
  |  Branch (48:39): [True: 103k, False: 11.9k]
  ------------------
   49|   115k|}
_ZN5Botan6chooseIjEET_S1_S1_S1_:
  180|  9.69M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|  9.69M|   return (b ^ (mask & (a ^ b)));
  183|  9.69M|}
_ZN5Botan8majorityIjEET_S1_S1_S1_:
  186|  4.83M|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|  4.83M|   return choose(a ^ b, c, b);
  197|  4.83M|}
_ZN5Botan6chooseImEET_S1_S1_S1_:
  180|   297M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   297M|   return (b ^ (mask & (a ^ b)));
  183|   297M|}
_ZN5Botan8majorityImEET_S1_S1_S1_:
  186|   181k|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|   181k|   return choose(a ^ b, c, b);
  197|   181k|}
_ZN5Botan8high_bitImEEmT_:
   60|   177k|{
   61|   177k|   size_t hb = 0;
   62|       |
   63|  1.24M|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 1.06M, False: 177k]
  ------------------
   64|  1.06M|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|  1.06M|      hb += z;
   66|  1.06M|      n >>= z;
   67|  1.06M|   }
   68|       |
   69|   177k|   hb += n;
   70|       |
   71|   177k|   return hb;
   72|   177k|}
_ZN5Botan10ct_is_zeroIhEET_S1_:
   35|  1.93M|{
   36|  1.93M|   return expand_top_bit<T>(~x & (x - 1));
   37|  1.93M|}
_ZN5Botan10ct_is_zeroIiEET_S1_:
   35|     84|{
   36|     84|   return expand_top_bit<T>(~x & (x - 1));
   37|     84|}
_ZN5Botan14expand_top_bitIiEET_S1_:
   25|     84|{
   26|     84|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|     84|}
_ZN5Botan3ctzImEEmT_:
  104|   384k|{
  105|       |   /*
  106|       |   * If n == 0 then this function will compute 8*sizeof(T)-1, so
  107|       |   * initialize lb to 1 if n == 0 to produce the expected result.
  108|       |   */
  109|   384k|   size_t lb = ct_is_zero(n) & 1;
  110|       |
  111|  2.69M|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (111:38): [True: 2.30M, False: 384k]
  ------------------
  112|  2.30M|      const T mask = (static_cast<T>(1) << s) - 1;
  113|  2.30M|      const size_t z = s * (ct_is_zero(n & mask) & 1);
  114|  2.30M|      lb += z;
  115|  2.30M|      n >>= z;
  116|  2.30M|   }
  117|       |
  118|   384k|   return lb;
  119|   384k|}
_ZN5Botan12ceil_tobytesImEET_S1_:
  146|     48|{
  147|     48|   return (bits + 7) / 8;
  148|     48|}
_ZN5Botan8high_bitIhEEmT_:
   60|     28|{
   61|     28|   size_t hb = 0;
   62|       |
   63|    112|   for(size_t s = 8 * sizeof(T) / 2; s > 0; s /= 2) {
  ------------------
  |  Branch (63:38): [True: 84, False: 28]
  ------------------
   64|     84|      const size_t z = s * ((~ct_is_zero(n >> s)) & 1);
   65|     84|      hb += z;
   66|     84|      n >>= z;
   67|     84|   }
   68|       |
   69|     28|   hb += n;
   70|       |
   71|     28|   return hb;
   72|     28|}

_ZN5Botan13reverse_bytesEt:
   19|  4.16k|inline constexpr uint16_t reverse_bytes(uint16_t x) {
   20|  4.16k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap16)
   21|  4.16k|   return __builtin_bswap16(x);
   22|       |#else
   23|       |   return static_cast<uint16_t>((x << 8) | (x >> 8));
   24|       |#endif
   25|  4.16k|}
_ZN5Botan13reverse_bytesEj:
   33|  1.11M|inline constexpr uint32_t reverse_bytes(uint32_t x) {
   34|  1.11M|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   35|  1.11M|   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.11M|}
_ZN5Botan13reverse_bytesEm:
   48|   230k|inline constexpr uint64_t reverse_bytes(uint64_t x) {
   49|   230k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   50|   230k|   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|   230k|}

_ZNK5Botan14calendar_point4yearEv:
   24|    510|      uint32_t year() const { return m_year; }
_ZNK5Botan14calendar_point5monthEv:
   27|    510|      uint32_t month() const { return m_month; }
_ZNK5Botan14calendar_point3dayEv:
   30|    510|      uint32_t day() const { return m_day; }
_ZNK5Botan14calendar_point4hourEv:
   33|    510|      uint32_t hour() const { return m_hour; }
_ZNK5Botan14calendar_point7minutesEv:
   36|    510|      uint32_t minutes() const { return m_minutes; }
_ZNK5Botan14calendar_point7secondsEv:
   41|    510|      uint32_t seconds() const { return m_seconds; }

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

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

_ZN5Botan2CT4MaskIhE3setEv:
   99|  23.3k|      static Mask<T> set() { return Mask<T>(static_cast<T>(~0)); }
_ZN5Botan2CT4MaskIhEC2Eh:
  280|  8.34M|      Mask(T m) : m_mask(m) {}
_ZN5Botan2CT4MaskIhE15is_within_rangeEhhh:
  150|  2.51M|      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|  2.51M|         const T v_lt_l = v ^ ((v ^ l) | ((v - l) ^ v));
  154|  2.51M|         const T v_gt_u = u ^ ((u ^ v) | ((u - v) ^ u));
  155|  2.51M|         const T either = v_lt_l | v_gt_u;
  156|  2.51M|         return ~Mask<T>(expand_top_bit(either));
  157|  2.51M|      }
_ZNK5Botan2CT4MaskIhEcoEv:
  213|  2.57M|      Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskIhE5valueEv:
  277|  8.34M|      T value() const { return m_mask; }
_ZN5Botan2CT4MaskIhE9is_any_ofEhSt16initializer_listIhE:
  159|   836k|      static Mask<T> is_any_of(T v, std::initializer_list<T> accepted) {
  160|   836k|         T accept = 0;
  161|       |
  162|  3.34M|         for(auto a : accepted) {
  ------------------
  |  Branch (162:21): [True: 3.34M, False: 836k]
  ------------------
  163|  3.34M|            const T diff = a ^ v;
  164|  3.34M|            const T eq_zero = ~diff & (diff - 1);
  165|  3.34M|            accept |= eq_zero;
  166|  3.34M|         }
  167|       |
  168|   836k|         return Mask<T>(expand_top_bit(accept));
  169|   836k|      }
_ZNK5Botan2CT4MaskIhE7as_boolEv:
  272|  23.4k|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskIhE16unpoisoned_valueEv:
  263|  23.4k|      T unpoisoned_value() const {
  264|  23.4k|         T r = value();
  265|  23.4k|         CT::unpoison(r);
  266|  23.4k|         return r;
  267|  23.4k|      }
_ZN5Botan2CT8unpoisonIhEEvRT_:
   64|  23.4k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  23.4k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  23.4k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  23.4k|#endif
   70|  23.4k|}
_ZN5Botan2CT4MaskIhE5is_ltEhh:
  133|   462k|      static Mask<T> is_lt(T x, T y) { return Mask<T>(expand_top_bit<T>(x ^ ((x ^ y) | ((x - y) ^ x)))); }
_ZNK5Botan2CT4MaskIhE6selectEhh:
  228|  5.74M|      T select(T x, T y) const { return choose(value(), x, y); }
_ZN5Botan2CT4MaskImE8is_equalEmm:
  128|  22.3M|      static Mask<T> is_equal(T x, T y) { return Mask<T>::is_zero(static_cast<T>(x ^ y)); }
_ZN5Botan2CT4MaskImE5is_ltEmm:
  133|  28.0M|      static Mask<T> is_lt(T x, T y) { return Mask<T>(expand_top_bit<T>(x ^ ((x ^ y) | ((x - y) ^ x)))); }
_ZN5Botan2CT4MaskImEC2Em:
  280|   164M|      Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskImE11select_maskES2_S2_:
  239|  21.6M|      Mask<T> select_mask(Mask<T> x, Mask<T> y) const { return Mask<T>(select(x.value(), y.value())); }
_ZNK5Botan2CT4MaskImE5valueEv:
  277|   405M|      T value() const { return m_mask; }
_ZN5Botan2CT4MaskImEoRES2_:
  190|   387k|      Mask<T>& operator|=(Mask<T> o) {
  191|   387k|         m_mask |= o.value();
  192|   387k|         return (*this);
  193|   387k|      }
_ZN5Botan2CT4MaskImEaNES2_:
  174|  15.1k|      Mask<T>& operator&=(Mask<T> o) {
  175|  15.1k|         m_mask &= o.value();
  176|  15.1k|         return (*this);
  177|  15.1k|      }
_ZNK5Botan2CT4MaskImE13if_set_returnEm:
  218|  16.9M|      T if_set_return(T x) const { return m_mask & x; }
_ZN5Botan2CT4MaskImE6expandEm:
  109|  39.8M|      static Mask<T> expand(T v) { return ~Mask<T>::is_zero(v); }
_ZNK5Botan2CT4MaskImEcoEv:
  213|  45.5M|      Mask<T> operator~() const { return Mask<T>(~value()); }
_ZNK5Botan2CT4MaskImE6selectEmm:
  228|   297M|      T select(T x, T y) const { return choose(value(), x, y); }
_ZNK5Botan2CT4MaskImE8select_nEPmPKmS5_m:
  245|  16.3M|      void select_n(T output[], const T x[], const T y[], size_t len) const {
  246|  83.3M|         for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (246:28): [True: 67.0M, False: 16.3M]
  ------------------
  247|  67.0M|            output[i] = this->select(x[i], y[i]);
  248|  67.0M|         }
  249|  16.3M|      }
_ZN5Botan2CT4MaskImE7is_zeroEm:
  123|  63.1M|      static Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(x)); }
_ZN5Botan2CT8unpoisonImEEvRT_:
   64|  11.1M|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|  11.1M|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|  11.1M|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|  11.1M|#endif
   70|  11.1M|}
_ZNK5Botan2CT4MaskImE7as_boolEv:
  272|  6.38M|      bool as_bool() const { return unpoisoned_value() != 0; }
_ZNK5Botan2CT4MaskImE16unpoisoned_valueEv:
  263|  6.38M|      T unpoisoned_value() const {
  264|  6.38M|         T r = value();
  265|  6.38M|         CT::unpoison(r);
  266|  6.38M|         return r;
  267|  6.38M|      }
_ZN5Botan2CT8unpoisonIKmEEvRT_:
   64|   177k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|   177k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|   177k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|   177k|#endif
   70|   177k|}
_ZN5Botan2CT4MaskIhE6expandEh:
  109|  67.3k|      static Mask<T> expand(T v) { return ~Mask<T>::is_zero(v); }
_ZN5Botan2CT4MaskIhE7is_zeroEh:
  123|  1.93M|      static Mask<T> is_zero(T x) { return Mask<T>(ct_is_zero<T>(x)); }
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES3_PS3_PKS3_S7_m:
  292|   422k|inline Mask<T> conditional_copy_mem(T cnd, T* to, const T* from0, const T* from1, size_t elems) {
  293|   422k|   const auto mask = CT::Mask<T>::expand(cnd);
  294|   422k|   return CT::conditional_copy_mem(mask, to, from0, from1, elems);
  295|   422k|}
_ZN5Botan2CT20conditional_copy_memImEENS0_4MaskIT_EES4_PS3_PKS3_S7_m:
  286|   422k|inline Mask<T> conditional_copy_mem(Mask<T> mask, T* to, const T* from0, const T* from1, size_t elems) {
  287|   422k|   mask.select_n(to, from0, from1, elems);
  288|   422k|   return mask;
  289|   422k|}
_ZN5Botan2CT20conditional_swap_ptrIPKmEEvbRT_S5_:
  315|  44.5k|inline void conditional_swap_ptr(bool cnd, T& x, T& y) {
  316|  44.5k|   uintptr_t xp = reinterpret_cast<uintptr_t>(x);
  317|  44.5k|   uintptr_t yp = reinterpret_cast<uintptr_t>(y);
  318|       |
  319|  44.5k|   conditional_swap<uintptr_t>(cnd, xp, yp);
  320|       |
  321|  44.5k|   x = reinterpret_cast<T>(xp);
  322|  44.5k|   y = reinterpret_cast<T>(yp);
  323|  44.5k|}
_ZN5Botan2CT16conditional_swapImEEvbRT_S3_:
  305|  89.0k|inline void conditional_swap(bool cnd, T& x, T& y) {
  306|  89.0k|   const auto swap = CT::Mask<T>::expand(cnd);
  307|       |
  308|  89.0k|   T t0 = swap.select(y, x);
  309|  89.0k|   T t1 = swap.select(x, y);
  310|  89.0k|   x = t0;
  311|  89.0k|   y = t1;
  312|  89.0k|}
_ZN5Botan2CT8is_equalIhEENS0_4MaskIT_EEPKS3_S6_m:
  339|     65|inline CT::Mask<T> is_equal(const T x[], const T y[], size_t len) {
  340|     65|   volatile T difference = 0;
  341|       |
  342|  4.44k|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (342:22): [True: 4.38k, False: 65]
  ------------------
  343|  4.38k|      difference = difference | (x[i] ^ y[i]);
  344|  4.38k|   }
  345|       |
  346|     65|   return CT::Mask<T>::is_zero(difference);
  347|     65|}
_ZN5Botan2CT4MaskIhE8is_equalEhh:
  128|  1.86M|      static Mask<T> is_equal(T x, T y) { return Mask<T>::is_zero(static_cast<T>(x ^ y)); }
_ZN5Botan2CT4MaskImE6is_gteEmm:
  148|  5.71M|      static Mask<T> is_gte(T x, T y) { return ~Mask<T>::is_lt(x, y); }
_ZN5Botan2CTorENS0_4MaskImEES2_:
  208|  5.71M|      friend Mask<T> operator|(Mask<T> x, Mask<T> y) { return Mask<T>(x.value() | y.value()); }
_ZN5Botan2CTeoENS0_4MaskImEES2_:
  203|  4.39k|      friend Mask<T> operator^(Mask<T> x, Mask<T> y) { return Mask<T>(x.value() ^ y.value()); }
_ZN5Botan2CT4MaskImE3setEv:
   99|  1.74k|      static Mask<T> set() { return Mask<T>(static_cast<T>(~0)); }
_ZN5Botan2CT6poisonImEEvPKT_m:
   46|  1.74k|inline void poison(const T* p, size_t n) {
   47|       |#if defined(BOTAN_HAS_VALGRIND)
   48|       |   VALGRIND_MAKE_MEM_UNDEFINED(p, n * sizeof(T));
   49|       |#else
   50|  1.74k|   BOTAN_UNUSED(p, n);
  ------------------
  |  |  118|  1.74k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   51|  1.74k|#endif
   52|  1.74k|}
_ZN5Botan2CT4MaskImE15if_set_zero_outEPmm:
  254|  1.74k|      void if_set_zero_out(T buf[], size_t elems) {
  255|  8.65k|         for(size_t i = 0; i != elems; ++i) {
  ------------------
  |  Branch (255:28): [True: 6.91k, False: 1.74k]
  ------------------
  256|  6.91k|            buf[i] = this->if_not_set_return(buf[i]);
  257|  6.91k|         }
  258|  1.74k|      }
_ZNK5Botan2CT4MaskImE17if_not_set_returnEm:
  223|   391k|      T if_not_set_return(T x) const { return ~m_mask & x; }
_ZN5Botan2CT8unpoisonImEEvPKT_m:
   55|  1.74k|inline void unpoison(const T* p, size_t n) {
   56|       |#if defined(BOTAN_HAS_VALGRIND)
   57|       |   VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
   58|       |#else
   59|  1.74k|   BOTAN_UNUSED(p, n);
  ------------------
  |  |  118|  1.74k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   60|  1.74k|#endif
   61|  1.74k|}
_ZN5Botan2CT4MaskImE7clearedEv:
  104|  45.4k|      static Mask<T> cleared() { return Mask<T>(0); }
_ZN5Botan2CTanENS0_4MaskImEES2_:
  198|   468k|      friend Mask<T> operator&(Mask<T> x, Mask<T> y) { return Mask<T>(x.value() & y.value()); }
_ZN5Botan2CT9all_zerosImEENS0_4MaskIT_EEPKS3_m:
  326|   937k|inline CT::Mask<T> all_zeros(const T elem[], size_t len) {
  327|   937k|   T sum = 0;
  328|  4.69M|   for(size_t i = 0; i != len; ++i) {
  ------------------
  |  Branch (328:22): [True: 3.75M, False: 937k]
  ------------------
  329|  3.75M|      sum |= elem[i];
  330|  3.75M|   }
  331|   937k|   return CT::Mask<T>::is_zero(sum);
  332|   937k|}
_ZN5Botan2CT22conditional_assign_memImEENS0_4MaskIT_EES3_PS3_PKS3_m:
  298|  15.9M|inline Mask<T> conditional_assign_mem(T cnd, T* sink, const T* src, size_t elems) {
  299|  15.9M|   const auto mask = CT::Mask<T>::expand(cnd);
  300|  15.9M|   mask.select_n(sink, src, sink, elems);
  301|  15.9M|   return mask;
  302|  15.9M|}
_ZN5Botan2CT8unpoisonIlEEvRT_:
   64|   262k|inline void unpoison(T& p) {
   65|       |#if defined(BOTAN_HAS_VALGRIND)
   66|       |   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
   67|       |#else
   68|   262k|   BOTAN_UNUSED(p);
  ------------------
  |  |  118|   262k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   69|   262k|#endif
   70|   262k|}

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

_ZNK5Botan12DL_PublicKey5groupEv:
   29|     42|      const DL_Group& group() const { return m_group; }

_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.29k|      virtual ~EMSA() = default;

_ZNK5Botan13EMSA_PKCS1v1513hash_functionEv:
   38|     14|      std::string hash_function() const override { return m_hash->name(); }

_ZN5Botan10fmt_detail6do_fmtERNSt3__119basic_ostringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EE:
   20|  26.8k|inline void do_fmt(std::ostringstream& oss, std::string_view format) {
   21|  26.8k|   oss << format;
   22|  26.8k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  17.4k|std::string fmt(std::string_view format, const T&... args) {
   54|  17.4k|   std::ostringstream oss;
   55|  17.4k|   oss.imbue(std::locale::classic());
   56|  17.4k|   fmt_detail::do_fmt(oss, format, args...);
   57|  17.4k|   return oss.str();
   58|  17.4k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  21.1k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  21.1k|   size_t i = 0;
   27|       |
   28|   206k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 206k, False: 0]
  ------------------
   29|   206k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 21.1k, False: 185k]
  |  Branch (29:30): [True: 21.1k, False: 0]
  |  Branch (29:59): [True: 21.1k, False: 0]
  ------------------
   30|  21.1k|         oss << val;
   31|  21.1k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|   185k|      } else {
   33|   185k|         oss << format[i];
   34|   185k|      }
   35|       |
   36|   185k|      i += 1;
   37|   185k|   }
   38|  21.1k|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPKcEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|  4.34k|std::string fmt(std::string_view format, const T&... args) {
   54|  4.34k|   std::ostringstream oss;
   55|  4.34k|   oss.imbue(std::locale::classic());
   56|  4.34k|   fmt_detail::do_fmt(oss, format, args...);
   57|  4.34k|   return oss.str();
   58|  4.34k|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJPKcEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|  4.34k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.34k|   size_t i = 0;
   27|       |
   28|  4.34k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 4.34k, False: 0]
  ------------------
   29|  4.34k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.34k, False: 0]
  |  Branch (29:30): [True: 4.34k, False: 0]
  |  Branch (29:59): [True: 4.34k, False: 0]
  ------------------
   30|  4.34k|         oss << val;
   31|  4.34k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  4.34k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  4.34k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJEEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|  4.45k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  4.45k|   size_t i = 0;
   27|       |
   28|  61.0k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 61.0k, False: 0]
  ------------------
   29|  61.0k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 4.45k, False: 56.6k]
  |  Branch (29:30): [True: 4.45k, False: 0]
  |  Branch (29:59): [True: 4.45k, False: 0]
  ------------------
   30|  4.45k|         oss << val;
   31|  4.45k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  56.6k|      } else {
   33|  56.6k|         oss << format[i];
   34|  56.6k|      }
   35|       |
   36|  56.6k|      i += 1;
   37|  56.6k|   }
   38|  4.45k|}
_ZN5Botan3fmtIJPKcNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEENS3_12basic_stringIcS6_NS3_9allocatorIcEEEES7_DpRKT_:
   53|  3.67k|std::string fmt(std::string_view format, const T&... args) {
   54|  3.67k|   std::ostringstream oss;
   55|  3.67k|   oss.imbue(std::locale::classic());
   56|  3.67k|   fmt_detail::do_fmt(oss, format, args...);
   57|  3.67k|   return oss.str();
   58|  3.67k|}
_ZN5Botan10fmt_detail6do_fmtIPKcJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEEvRNS4_19basic_ostringstreamIcS7_NS4_9allocatorIcEEEES8_RKT_DpRKT0_:
   25|  3.67k|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|  3.67k|   size_t i = 0;
   27|       |
   28|  3.67k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.67k, False: 0]
  ------------------
   29|  3.67k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 3.67k, False: 0]
  |  Branch (29:30): [True: 3.67k, False: 0]
  |  Branch (29:59): [True: 3.67k, False: 0]
  ------------------
   30|  3.67k|         oss << val;
   31|  3.67k|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  3.67k|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|  3.67k|}
_ZN5Botan10fmt_detail6do_fmtImJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|     63|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     63|   size_t i = 0;
   27|       |
   28|    462|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 462, False: 0]
  ------------------
   29|    462|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 63, False: 399]
  |  Branch (29:30): [True: 63, False: 0]
  |  Branch (29:59): [True: 63, False: 0]
  ------------------
   30|     63|         oss << val;
   31|     63|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    399|      } else {
   33|    399|         oss << format[i];
   34|    399|      }
   35|       |
   36|    399|      i += 1;
   37|    399|   }
   38|     63|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEjEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEES5_DpRKT_:
   53|    241|std::string fmt(std::string_view format, const T&... args) {
   54|    241|   std::ostringstream oss;
   55|    241|   oss.imbue(std::locale::classic());
   56|    241|   fmt_detail::do_fmt(oss, format, args...);
   57|    241|   return oss.str();
   58|    241|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJjEEEvRNS2_19basic_ostringstreamIcS5_NS2_9allocatorIcEEEES6_RKT_DpRKT0_:
   25|    241|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    241|   size_t i = 0;
   27|       |
   28|    241|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 241, False: 0]
  ------------------
   29|    241|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 241, False: 0]
  |  Branch (29:30): [True: 241, False: 0]
  |  Branch (29:59): [True: 241, False: 0]
  ------------------
   30|    241|         oss << val;
   31|    241|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    241|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    241|}
_ZN5Botan10fmt_detail6do_fmtIjJEEEvRNSt3__119basic_ostringstreamIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    313|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    313|   size_t i = 0;
   27|       |
   28|  3.17k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 3.17k, False: 0]
  ------------------
   29|  3.17k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 313, False: 2.85k]
  |  Branch (29:30): [True: 313, False: 0]
  |  Branch (29:59): [True: 313, False: 0]
  ------------------
   30|    313|         oss << val;
   31|    313|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  2.85k|      } else {
   33|  2.85k|         oss << format[i];
   34|  2.85k|      }
   35|       |
   36|  2.85k|      i += 1;
   37|  2.85k|   }
   38|    313|}
_ZN5Botan3fmtIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|     72|std::string fmt(std::string_view format, const T&... args) {
   54|     72|   std::ostringstream oss;
   55|     72|   oss.imbue(std::locale::classic());
   56|     72|   fmt_detail::do_fmt(oss, format, args...);
   57|     72|   return oss.str();
   58|     72|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|    893|std::string fmt(std::string_view format, const T&... args) {
   54|    893|   std::ostringstream oss;
   55|    893|   oss.imbue(std::locale::classic());
   56|    893|   fmt_detail::do_fmt(oss, format, args...);
   57|    893|   return oss.str();
   58|    893|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|    894|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    894|   size_t i = 0;
   27|       |
   28|  10.3k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 10.3k, False: 0]
  ------------------
   29|  10.3k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 894, False: 9.47k]
  |  Branch (29:30): [True: 894, False: 0]
  |  Branch (29:59): [True: 894, False: 0]
  ------------------
   30|    894|         oss << val;
   31|    894|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  9.47k|      } else {
   33|  9.47k|         oss << format[i];
   34|  9.47k|      }
   35|       |
   36|  9.47k|      i += 1;
   37|  9.47k|   }
   38|    894|}
_ZN5Botan3fmtIJmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_17basic_string_viewIcS4_EEDpRKT_:
   53|      7|std::string fmt(std::string_view format, const T&... args) {
   54|      7|   std::ostringstream oss;
   55|      7|   oss.imbue(std::locale::classic());
   56|      7|   fmt_detail::do_fmt(oss, format, args...);
   57|      7|   return oss.str();
   58|      7|}
_ZN5Botan3fmtIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEEES7_NS1_17basic_string_viewIcS4_EEDpRKT_:
   53|     56|std::string fmt(std::string_view format, const T&... args) {
   54|     56|   std::ostringstream oss;
   55|     56|   oss.imbue(std::locale::classic());
   56|     56|   fmt_detail::do_fmt(oss, format, args...);
   57|     56|   return oss.str();
   58|     56|}
_ZN5Botan10fmt_detail6do_fmtINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEJmEEEvRNS2_19basic_ostringstreamIcS5_S7_EENS2_17basic_string_viewIcS5_EERKT_DpRKT0_:
   25|     56|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     56|   size_t i = 0;
   27|       |
   28|    112|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 112, False: 0]
  ------------------
   29|    112|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 56, False: 56]
  |  Branch (29:30): [True: 56, False: 0]
  |  Branch (29:59): [True: 56, False: 0]
  ------------------
   30|     56|         oss << val;
   31|     56|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     56|      } else {
   33|     56|         oss << format[i];
   34|     56|      }
   35|       |
   36|     56|      i += 1;
   37|     56|   }
   38|     56|}
_ZN5Botan3fmtIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEEEEES9_S5_DpRKT_:
   53|      1|std::string fmt(std::string_view format, const T&... args) {
   54|      1|   std::ostringstream oss;
   55|      1|   oss.imbue(std::locale::classic());
   56|      1|   fmt_detail::do_fmt(oss, format, args...);
   57|      1|   return oss.str();
   58|      1|}
_ZN5Botan10fmt_detail6do_fmtINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEJNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEEvRNS2_19basic_ostringstreamIcS5_S9_EES6_RKT_DpRKT0_:
   25|      1|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      1|   size_t i = 0;
   27|       |
   28|     30|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 30, False: 0]
  ------------------
   29|     30|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1, False: 29]
  |  Branch (29:30): [True: 1, False: 0]
  |  Branch (29:59): [True: 1, False: 0]
  ------------------
   30|      1|         oss << val;
   31|      1|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     29|      } else {
   33|     29|         oss << format[i];
   34|     29|      }
   35|       |
   36|     29|      i += 1;
   37|     29|   }
   38|      1|}
_ZN5Botan3fmtIJPKcS2_S2_EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EEDpRKT_:
   53|    108|std::string fmt(std::string_view format, const T&... args) {
   54|    108|   std::ostringstream oss;
   55|    108|   oss.imbue(std::locale::classic());
   56|    108|   fmt_detail::do_fmt(oss, format, args...);
   57|    108|   return oss.str();
   58|    108|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_S3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    108|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    108|   size_t i = 0;
   27|       |
   28|    108|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 108, False: 0]
  ------------------
   29|    108|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 108, False: 0]
  |  Branch (29:30): [True: 108, False: 0]
  |  Branch (29:59): [True: 108, False: 0]
  ------------------
   30|    108|         oss << val;
   31|    108|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    108|      } else {
   33|      0|         oss << format[i];
   34|      0|      }
   35|       |
   36|      0|      i += 1;
   37|      0|   }
   38|    108|}
_ZN5Botan10fmt_detail6do_fmtIPKcJS3_EEEvRNSt3__119basic_ostringstreamIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_17basic_string_viewIcS7_EERKT_DpRKT0_:
   25|    108|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|    108|   size_t i = 0;
   27|       |
   28|    540|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 540, False: 0]
  ------------------
   29|    540|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 108, False: 432]
  |  Branch (29:30): [True: 108, False: 0]
  |  Branch (29:59): [True: 108, False: 0]
  ------------------
   30|    108|         oss << val;
   31|    108|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|    432|      } else {
   33|    432|         oss << format[i];
   34|    432|      }
   35|       |
   36|    432|      i += 1;
   37|    432|   }
   38|    108|}
_ZN5Botan3fmtIJNS_3OIDEEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EEDpRKT_:
   53|      1|std::string fmt(std::string_view format, const T&... args) {
   54|      1|   std::ostringstream oss;
   55|      1|   oss.imbue(std::locale::classic());
   56|      1|   fmt_detail::do_fmt(oss, format, args...);
   57|      1|   return oss.str();
   58|      1|}
_ZN5Botan10fmt_detail6do_fmtINS_3OIDEJEEEvRNSt3__119basic_ostringstreamIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_17basic_string_viewIcS6_EERKT_DpRKT0_:
   25|      1|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|      1|   size_t i = 0;
   27|       |
   28|     14|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 14, False: 0]
  ------------------
   29|     14|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 1, False: 13]
  |  Branch (29:30): [True: 1, False: 0]
  |  Branch (29:59): [True: 1, False: 0]
  ------------------
   30|      1|         oss << val;
   31|      1|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|     13|      } else {
   33|     13|         oss << format[i];
   34|     13|      }
   35|       |
   36|     13|      i += 1;
   37|     13|   }
   38|      1|}
_ZN5Botan3fmtIJNS_3OIDENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEES6_DpRKT_:
   53|     48|std::string fmt(std::string_view format, const T&... args) {
   54|     48|   std::ostringstream oss;
   55|     48|   oss.imbue(std::locale::classic());
   56|     48|   fmt_detail::do_fmt(oss, format, args...);
   57|     48|   return oss.str();
   58|     48|}
_ZN5Botan10fmt_detail6do_fmtINS_3OIDEJNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEEvRNS3_19basic_ostringstreamIcS6_NS3_9allocatorIcEEEES7_RKT_DpRKT0_:
   25|     48|void do_fmt(std::ostringstream& oss, std::string_view format, const T& val, const Ts&... rest) {
   26|     48|   size_t i = 0;
   27|       |
   28|  1.72k|   while(i < format.size()) {
  ------------------
  |  Branch (28:10): [True: 1.72k, False: 0]
  ------------------
   29|  1.72k|      if(format[i] == '{' && (format.size() > (i + 1)) && format.at(i + 1) == '}') {
  ------------------
  |  Branch (29:10): [True: 48, False: 1.68k]
  |  Branch (29:30): [True: 48, False: 0]
  |  Branch (29:59): [True: 48, False: 0]
  ------------------
   30|     48|         oss << val;
   31|     48|         return do_fmt(oss, format.substr(i + 2), rest...);
   32|  1.68k|      } else {
   33|  1.68k|         oss << format[i];
   34|  1.68k|      }
   35|       |
   36|  1.68k|      i += 1;
   37|  1.68k|   }
   38|     48|}

_ZNK5Botan20GOST_28147_89_Params10param_nameEv:
   33|    123|      std::string param_name() const { return m_name; }

_ZNK5Botan10GOST_34_114nameEv:
   22|      1|      std::string name() const override { return "GOST-R-34.11-94"; }
_ZNK5Botan10GOST_34_1113output_lengthEv:
   24|    123|      size_t output_length() const override { return 32; }

_ZN5Botan11make_uint16Ehh:
   50|    354|inline constexpr uint16_t make_uint16(uint8_t i0, uint8_t i1) {
   51|    354|   return static_cast<uint16_t>((static_cast<uint16_t>(i0) << 8) | i1);
   52|    354|}
_ZN5Botan8get_byteILm0EmEEhT0_:
   39|  42.8k|{
   40|  42.8k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  42.8k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  42.8k|}
_ZN5Botan12get_byte_varImEEhmT_:
   27|   284k|inline constexpr uint8_t get_byte_var(size_t byte_num, T input) {
   28|   284k|   return static_cast<uint8_t>(input >> (((~byte_num) & (sizeof(T) - 1)) << 3));
   29|   284k|}
_ZN5Botan7load_leIjEET_PKhm:
  238|  73.8k|inline constexpr T load_le(const uint8_t in[], size_t off) {
  239|       |   // asserts that *in points to the correct amount of memory
  240|  73.8k|   return load_le<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  241|  73.8k|}
_ZN5Botan7load_leIjNSt3__14spanIKhLm4EEEEET_OT0_:
  117|  73.8k|inline constexpr T load_le(InR&& in_range) {
  118|  73.8k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
  119|  73.8k|   std::span in{in_range};
  120|  73.8k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (120:17): [Folded - Ignored]
  ------------------
  121|  73.8k|      return static_cast<T>(in[0]);
  122|  73.8k|   } else {
  123|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  124|       |      return reverse_bytes(typecast_copy<T>(in));
  125|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  126|  73.8k|      return typecast_copy<T>(in);
  127|       |#else
  128|       |      return [&]<size_t... i>(std::index_sequence<i...>) {
  129|       |         return ((static_cast<T>(in[i]) << (i * 8)) | ...);
  130|       |      }
  131|       |      (std::make_index_sequence<sizeof(T)>());
  132|       |#endif
  133|  73.8k|   }
  134|  73.8k|}
_ZN5Botan8store_leImEEvT_Ph:
  418|    366|inline constexpr void store_le(T in, uint8_t out[sizeof(T)]) {
  419|    366|   store_le(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  420|    366|}
_ZN5Botan8store_leImNSt3__14spanIhLm8EEEEEvT_OT0_:
  383|    366|inline constexpr void store_le(T in, OutR&& out_range) {
  384|    366|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  385|    366|   std::span out{out_range};
  386|    366|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (386:17): [Folded - Ignored]
  ------------------
  387|    366|      out[0] = static_cast<uint8_t>(in);
  388|    366|   } 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|    366|      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|    366|   }
  400|    366|}
_ZN5Botan15copy_out_vec_leIjNS_16secure_allocatorIjEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  540|     92|void copy_out_vec_le(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  541|     92|   copy_out_le(out, out_bytes, in.data());
  542|     92|}
_ZN5Botan11copy_out_leIjEEvPhmPKT_:
  526|     92|void copy_out_le(uint8_t out[], size_t out_bytes, const T in[]) {
  527|    460|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (527:10): [True: 368, False: 92]
  ------------------
  528|    368|      store_le(in[0], out);
  529|    368|      out += sizeof(T);
  530|    368|      out_bytes -= sizeof(T);
  531|    368|      in += 1;
  532|    368|   }
  533|       |
  534|     92|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (534:22): [True: 0, False: 92]
  ------------------
  535|      0|      out[i] = get_byte_var(sizeof(T) - 1 - (i % 8), in[0]);
  536|      0|   }
  537|     92|}
_ZN5Botan8store_leIjEEvT_Ph:
  418|    368|inline constexpr void store_le(T in, uint8_t out[sizeof(T)]) {
  419|    368|   store_le(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  420|    368|}
_ZN5Botan8store_leIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  383|  15.1k|inline constexpr void store_le(T in, OutR&& out_range) {
  384|  15.1k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  385|  15.1k|   std::span out{out_range};
  386|  15.1k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (386:17): [Folded - Ignored]
  ------------------
  387|  15.1k|      out[0] = static_cast<uint8_t>(in);
  388|  15.1k|   } 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|  15.1k|      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|  15.1k|   }
  400|  15.1k|}
_ZN5Botan7load_leIjEEvPT_PKhm:
  310|    700|inline constexpr void load_le(T out[], const uint8_t in[], size_t count) {
  311|    700|   if(count > 0) {
  ------------------
  |  Branch (311:7): [True: 700, False: 0]
  ------------------
  312|    700|#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  313|    700|      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|    700|   }
  325|    700|}
_ZN5Botan8store_beImEEvT_Ph:
  408|  75.5k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|  75.5k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|  75.5k|}
_ZN5Botan8store_beImNSt3__14spanIhLm8EEEEEvT_OT0_:
  358|  75.5k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|  75.5k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|  75.5k|   std::span out{out_range};
  361|  75.5k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|  75.5k|      out[0] = static_cast<uint8_t>(in);
  363|  75.5k|   } 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|  75.5k|      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|  75.5k|   }
  375|  75.5k|}
_ZN5Botan15copy_out_vec_beIjNS_16secure_allocatorIjEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  521|  23.2k|void copy_out_vec_be(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  522|  23.2k|   copy_out_be(out, out_bytes, in.data());
  523|  23.2k|}
_ZN5Botan11copy_out_beIjEEvPhmPKT_:
  507|  23.2k|void copy_out_be(uint8_t out[], size_t out_bytes, const T in[]) {
  508|   181k|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (508:10): [True: 158k, False: 23.2k]
  ------------------
  509|   158k|      store_be(in[0], out);
  510|   158k|      out += sizeof(T);
  511|   158k|      out_bytes -= sizeof(T);
  512|   158k|      in += 1;
  513|   158k|   }
  514|       |
  515|  23.2k|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (515:22): [True: 0, False: 23.2k]
  ------------------
  516|      0|      out[i] = get_byte_var(i % 8, in[0]);
  517|      0|   }
  518|  23.2k|}
_ZN5Botan8store_beIjEEvT_Ph:
  408|   161k|inline constexpr void store_be(T in, uint8_t out[sizeof(T)]) {
  409|   161k|   store_be(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  410|   161k|}
_ZN5Botan8store_beIjNSt3__14spanIhLm4EEEEEvT_OT0_:
  358|   161k|inline constexpr void store_be(T in, OutR&& out_range) {
  359|   161k|   ranges::assert_exact_byte_length<sizeof(T)>(out_range);
  360|   161k|   std::span out{out_range};
  361|   161k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (361:17): [Folded - Ignored]
  ------------------
  362|   161k|      out[0] = static_cast<uint8_t>(in);
  363|   161k|   } 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|   161k|      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|   161k|   }
  375|   161k|}
_ZN5Botan7load_beIjEET_PKhm:
  226|   952k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|   952k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|   952k|}
_ZN5Botan7load_beIjNSt3__14spanIKhLm4EEEEET_OT0_:
   92|   952k|inline constexpr T load_be(InR&& in_range) {
   93|   952k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|   952k|   std::span in{in_range};
   95|   952k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|   952k|      return static_cast<T>(in[0]);
   97|   952k|   } 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|   952k|      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|   952k|   }
  109|   952k|}
_ZN5Botan7load_beImEET_PKhm:
  226|   140k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|   140k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|   140k|}
_ZN5Botan7load_beImNSt3__14spanIKhLm8EEEEET_OT0_:
   92|   140k|inline constexpr T load_be(InR&& in_range) {
   93|   140k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|   140k|   std::span in{in_range};
   95|   140k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|   140k|      return static_cast<T>(in[0]);
   97|   140k|   } 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|   140k|      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|   140k|   }
  109|   140k|}
_ZN5Botan15copy_out_vec_beImNS_16secure_allocatorImEEEEvPhmRKNSt3__16vectorIT_T0_EE:
  521|    663|void copy_out_vec_be(uint8_t out[], size_t out_bytes, const std::vector<T, Alloc>& in) {
  522|    663|   copy_out_be(out, out_bytes, in.data());
  523|    663|}
_ZN5Botan11copy_out_beImEEvPhmPKT_:
  507|    663|void copy_out_be(uint8_t out[], size_t out_bytes, const T in[]) {
  508|  3.72k|   while(out_bytes >= sizeof(T)) {
  ------------------
  |  Branch (508:10): [True: 3.06k, False: 663]
  ------------------
  509|  3.06k|      store_be(in[0], out);
  510|  3.06k|      out += sizeof(T);
  511|  3.06k|      out_bytes -= sizeof(T);
  512|  3.06k|      in += 1;
  513|  3.06k|   }
  514|       |
  515|    663|   for(size_t i = 0; i != out_bytes; ++i) {
  ------------------
  |  Branch (515:22): [True: 0, False: 663]
  ------------------
  516|      0|      out[i] = get_byte_var(i % 8, in[0]);
  517|      0|   }
  518|    663|}
_ZN5Botan7load_beImEEvPT_PKhm:
  334|  3.69k|inline constexpr void load_be(T out[], const uint8_t in[], size_t count) {
  335|  3.69k|   if(count > 0) {
  ------------------
  |  Branch (335:7): [True: 3.69k, False: 0]
  ------------------
  336|       |#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
  337|       |      typecast_copy(out, in, count);
  338|       |
  339|       |#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
  340|  3.69k|      typecast_copy(out, in, count);
  341|       |
  342|  18.4k|      for(size_t i = 0; i != count; ++i) {
  ------------------
  |  Branch (342:25): [True: 14.7k, False: 3.69k]
  ------------------
  343|  14.7k|         out[i] = reverse_bytes(out[i]);
  344|  14.7k|      }
  345|       |#else
  346|       |      for(size_t i = 0; i != count; ++i)
  347|       |         out[i] = load_be<T>(in, i);
  348|       |#endif
  349|  3.69k|   }
  350|  3.69k|}
_ZN5Botan7load_beItEET_PKhm:
  226|  4.16k|inline constexpr T load_be(const uint8_t in[], size_t off) {
  227|       |   // asserts that *in points to the correct amount of memory
  228|  4.16k|   return load_be<T>(std::span<const uint8_t, sizeof(T)>(in + off * sizeof(T), sizeof(T)));
  229|  4.16k|}
_ZN5Botan7load_beItNSt3__14spanIKhLm2EEEEET_OT0_:
   92|  4.16k|inline constexpr T load_be(InR&& in_range) {
   93|  4.16k|   ranges::assert_exact_byte_length<sizeof(T)>(in_range);
   94|  4.16k|   std::span in{in_range};
   95|  4.16k|   if constexpr(sizeof(T) == 1) {
  ------------------
  |  Branch (95:17): [Folded - Ignored]
  ------------------
   96|  4.16k|      return static_cast<T>(in[0]);
   97|  4.16k|   } 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|  4.16k|      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|  4.16k|   }
  109|  4.16k|}
_ZN5Botan8get_byteILm0EjEEhT0_:
   39|   236k|{
   40|   236k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|   236k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|   236k|}
_ZN5Botan8get_byteILm3EjEEhT0_:
   39|   236k|{
   40|   236k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|   236k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|   236k|}
_ZN5Botan8get_byteILm2EjEEhT0_:
   39|   236k|{
   40|   236k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|   236k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|   236k|}
_ZN5Botan8get_byteILm1EjEEhT0_:
   39|   236k|{
   40|   236k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|   236k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|   236k|}
_ZN5Botan8get_byteILm0EtEEhT0_:
   39|  59.0k|{
   40|  59.0k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  59.0k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  59.0k|}
_ZN5Botan8get_byteILm1EtEEhT0_:
   39|  59.0k|{
   40|  59.0k|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   41|  59.0k|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   42|  59.0k|}
_ZN5Botan8store_leIJjjEEEvPhDpT_:
  476|  7.38k|inline constexpr void store_le(uint8_t out[], Ts... ins) {
  477|  7.38k|   constexpr auto bytes = (sizeof(ins) + ...);
  478|       |   // asserts that *out points to the correct amount of memory
  479|  7.38k|   store_le(std::span<uint8_t, bytes>(out, bytes), ins...);
  480|  7.38k|}
_ZN5Botan8store_leINSt3__14spanIhLm8EEEJjjEEEvOT_DpT0_:
  446|  7.38k|inline constexpr void store_le(OutR&& out, Ts... ins) {
  447|  7.38k|   ranges::assert_exact_byte_length<(sizeof(Ts) + ...)>(out);
  448|  7.38k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  449|  7.38k|      store_le<T>(i, o.subspan(off).template first<sizeof(T)>());
  450|  7.38k|      off += sizeof(T);
  451|  7.38k|   };
  452|       |
  453|  7.38k|   (store_one(std::span{out}, ins), ...);
  454|  7.38k|}
_ZZN5Botan8store_leINSt3__14spanIhLm8EEEJjjEEEvOT_DpT0_ENUlTyT0_S4_E_clIjS3_EEDaS8_S4_:
  448|  14.7k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  449|  14.7k|      store_le<T>(i, o.subspan(off).template first<sizeof(T)>());
  450|  14.7k|      off += sizeof(T);
  451|  14.7k|   };

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

_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EEC2Ev:
   42|  8.94k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE5clearEv:
   70|  17.8k|      void clear() {
   71|  17.8k|         MD::init(m_digest);
   72|  17.8k|         m_buffer.clear();
   73|  17.8k|         m_count = 0;
   74|  17.8k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EEC2Ev:
   42|     87|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE5clearEv:
   70|    174|      void clear() {
   71|    174|         MD::init(m_digest);
   72|    174|         m_buffer.clear();
   73|    174|         m_count = 0;
   74|    174|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EEC2Ev:
   42|  9.47k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5clearEv:
   70|  23.6k|      void clear() {
   71|  23.6k|         MD::init(m_digest);
   72|  23.6k|         m_buffer.clear();
   73|  23.6k|         m_count = 0;
   74|  23.6k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EEC2Ev:
   42|     59|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE5clearEv:
   70|    118|      void clear() {
   71|    118|         MD::init(m_digest);
   72|    118|         m_buffer.clear();
   73|    118|         m_count = 0;
   74|    118|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EEC2Ev:
   42|     74|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE5clearEv:
   70|    148|      void clear() {
   71|    148|         MD::init(m_digest);
   72|    148|         m_buffer.clear();
   73|    148|         m_count = 0;
   74|    148|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EEC2Ev:
   42|    530|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE5clearEv:
   70|  1.06k|      void clear() {
   71|  1.06k|         MD::init(m_digest);
   72|  1.06k|         m_buffer.clear();
   73|  1.06k|         m_count = 0;
   74|  1.06k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EEC2Ev:
   42|     92|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5clearEv:
   70|    184|      void clear() {
   71|    184|         MD::init(m_digest);
   72|    184|         m_buffer.clear();
   73|    184|         m_count = 0;
   74|    184|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     92|      void update(std::span<const uint8_t> input) {
   45|     92|         BufferSlicer in(input);
   46|       |
   47|    274|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 182, False: 92]
  ------------------
   48|    182|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 182]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|    182|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 92, False: 90]
  ------------------
   53|     92|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     92|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 92, False: 0]
  ------------------
   55|     92|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     92|               }
   57|     92|            }
   58|    182|         }
   59|       |
   60|     92|         m_count += input.size();
   61|     92|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     92|      void final(std::span<uint8_t> output) {
   64|     92|         append_padding_bit();
   65|     92|         append_counter_and_finalize();
   66|     92|         copy_output(output);
   67|     92|         clear();
   68|     92|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE18append_padding_bitEv:
   77|     92|      void append_padding_bit() {
   78|     92|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     92|   do {                                                                     \
  |  |   61|     92|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 92]
  |  |  ------------------
  |  |   62|     92|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     92|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     92|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     92|            const uint8_t final_byte = 0x80;
   81|     92|            m_buffer.append({&final_byte, 1});
   82|     92|         } else {
   83|     92|            const uint8_t final_byte = 0x01;
   84|     92|            m_buffer.append({&final_byte, 1});
   85|     92|         }
   86|     92|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE27append_counter_and_finalizeEv:
   88|     92|      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|     92|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 23, False: 69]
  ------------------
   92|     23|            m_buffer.fill_up_with_zeros();
   93|     23|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|     23|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     92|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     92|   do {                                                                     \
  |  |   61|     92|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 92]
  |  |  ------------------
  |  |   62|     92|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     92|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     92|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     92|         const uint64_t bit_count = m_count * 8;
  102|     92|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     92|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     92|            store_be(bit_count, last_bytes.data());
  105|     92|         } else {
  106|     92|            store_le(bit_count, last_bytes.data());
  107|     92|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     92|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     92|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     92|      void copy_output(std::span<uint8_t> output) {
  114|     92|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     92|   do {                                                                     \
  |  |   61|     92|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 92]
  |  |  ------------------
  |  |   62|     92|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     92|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     92|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     92|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     92|         } else {
  119|     92|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     92|         }
  121|     92|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  8.94k|      void update(std::span<const uint8_t> input) {
   45|  8.94k|         BufferSlicer in(input);
   46|       |
   47|  26.0k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 17.1k, False: 8.94k]
  ------------------
   48|  17.1k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 17.1k]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|  17.1k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 8.34k, False: 8.77k]
  ------------------
   53|  8.34k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  8.34k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 8.34k, False: 0]
  ------------------
   55|  8.34k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  8.34k|               }
   57|  8.34k|            }
   58|  17.1k|         }
   59|       |
   60|  8.94k|         m_count += input.size();
   61|  8.94k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  8.94k|      void final(std::span<uint8_t> output) {
   64|  8.94k|         append_padding_bit();
   65|  8.94k|         append_counter_and_finalize();
   66|  8.94k|         copy_output(output);
   67|  8.94k|         clear();
   68|  8.94k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE18append_padding_bitEv:
   77|  8.94k|      void append_padding_bit() {
   78|  8.94k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  8.94k|   do {                                                                     \
  |  |   61|  8.94k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 8.94k]
  |  |  ------------------
  |  |   62|  8.94k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  8.94k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|  8.94k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|  8.94k|            const uint8_t final_byte = 0x80;
   81|  8.94k|            m_buffer.append({&final_byte, 1});
   82|  8.94k|         } else {
   83|  8.94k|            const uint8_t final_byte = 0x01;
   84|  8.94k|            m_buffer.append({&final_byte, 1});
   85|  8.94k|         }
   86|  8.94k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE27append_counter_and_finalizeEv:
   88|  8.94k|      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|  8.94k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 351, False: 8.59k]
  ------------------
   92|    351|            m_buffer.fill_up_with_zeros();
   93|    351|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|    351|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  8.94k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  8.94k|   do {                                                                     \
  |  |   61|  8.94k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 8.94k]
  |  |  ------------------
  |  |   62|  8.94k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  8.94k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  8.94k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  8.94k|         const uint64_t bit_count = m_count * 8;
  102|  8.94k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  8.94k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|  8.94k|            store_be(bit_count, last_bytes.data());
  105|  8.94k|         } else {
  106|  8.94k|            store_le(bit_count, last_bytes.data());
  107|  8.94k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  8.94k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  8.94k|      }
_ZN5Botan18MerkleDamgard_HashINS_5SHA_1EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  8.94k|      void copy_output(std::span<uint8_t> output) {
  114|  8.94k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  8.94k|   do {                                                                     \
  |  |   61|  8.94k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 8.94k]
  |  |  ------------------
  |  |   62|  8.94k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  8.94k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  8.94k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|  8.94k|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|  8.94k|         } else {
  119|  8.94k|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|  8.94k|         }
  121|  8.94k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     87|      void update(std::span<const uint8_t> input) {
   45|     87|         BufferSlicer in(input);
   46|       |
   47|    260|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 173, False: 87]
  ------------------
   48|    173|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 173]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|    173|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 87, False: 86]
  ------------------
   53|     87|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     87|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 87, False: 0]
  ------------------
   55|     87|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     87|               }
   57|     87|            }
   58|    173|         }
   59|       |
   60|     87|         m_count += input.size();
   61|     87|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     87|      void final(std::span<uint8_t> output) {
   64|     87|         append_padding_bit();
   65|     87|         append_counter_and_finalize();
   66|     87|         copy_output(output);
   67|     87|         clear();
   68|     87|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE18append_padding_bitEv:
   77|     87|      void append_padding_bit() {
   78|     87|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     87|   do {                                                                     \
  |  |   61|     87|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 87]
  |  |  ------------------
  |  |   62|     87|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     87|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     87|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     87|            const uint8_t final_byte = 0x80;
   81|     87|            m_buffer.append({&final_byte, 1});
   82|     87|         } else {
   83|     87|            const uint8_t final_byte = 0x01;
   84|     87|            m_buffer.append({&final_byte, 1});
   85|     87|         }
   86|     87|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE27append_counter_and_finalizeEv:
   88|     87|      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|     87|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 73, False: 14]
  ------------------
   92|     73|            m_buffer.fill_up_with_zeros();
   93|     73|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|     73|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     87|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     87|   do {                                                                     \
  |  |   61|     87|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 87]
  |  |  ------------------
  |  |   62|     87|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     87|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     87|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     87|         const uint64_t bit_count = m_count * 8;
  102|     87|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     87|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     87|            store_be(bit_count, last_bytes.data());
  105|     87|         } else {
  106|     87|            store_le(bit_count, last_bytes.data());
  107|     87|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     87|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     87|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_224EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     87|      void copy_output(std::span<uint8_t> output) {
  114|     87|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     87|   do {                                                                     \
  |  |   61|     87|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 87]
  |  |  ------------------
  |  |   62|     87|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     87|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     87|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     87|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     87|         } else {
  119|     87|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     87|         }
  121|     87|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  14.4k|      void update(std::span<const uint8_t> input) {
   45|  14.4k|         BufferSlicer in(input);
   46|       |
   47|  36.1k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 21.6k, False: 14.4k]
  ------------------
   48|  21.6k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 6, False: 21.6k]
  ------------------
   49|      6|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      6|            }
   51|       |
   52|  21.6k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 7.19k, False: 14.4k]
  ------------------
   53|  7.19k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  7.19k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 7.19k, False: 0]
  ------------------
   55|  7.19k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  7.19k|               }
   57|  7.19k|            }
   58|  21.6k|         }
   59|       |
   60|  14.4k|         m_count += input.size();
   61|  14.4k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  14.1k|      void final(std::span<uint8_t> output) {
   64|  14.1k|         append_padding_bit();
   65|  14.1k|         append_counter_and_finalize();
   66|  14.1k|         copy_output(output);
   67|  14.1k|         clear();
   68|  14.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE18append_padding_bitEv:
   77|  14.1k|      void append_padding_bit() {
   78|  14.1k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  14.1k|   do {                                                                     \
  |  |   61|  14.1k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 14.1k]
  |  |  ------------------
  |  |   62|  14.1k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  14.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|  14.1k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|  14.1k|            const uint8_t final_byte = 0x80;
   81|  14.1k|            m_buffer.append({&final_byte, 1});
   82|  14.1k|         } else {
   83|  14.1k|            const uint8_t final_byte = 0x01;
   84|  14.1k|            m_buffer.append({&final_byte, 1});
   85|  14.1k|         }
   86|  14.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE27append_counter_and_finalizeEv:
   88|  14.1k|      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|  14.1k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 430, False: 13.7k]
  ------------------
   92|    430|            m_buffer.fill_up_with_zeros();
   93|    430|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|    430|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  14.1k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  14.1k|   do {                                                                     \
  |  |   61|  14.1k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 14.1k]
  |  |  ------------------
  |  |   62|  14.1k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  14.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  14.1k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  14.1k|         const uint64_t bit_count = m_count * 8;
  102|  14.1k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  14.1k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|  14.1k|            store_be(bit_count, last_bytes.data());
  105|  14.1k|         } else {
  106|  14.1k|            store_le(bit_count, last_bytes.data());
  107|  14.1k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  14.1k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  14.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  14.1k|      void copy_output(std::span<uint8_t> output) {
  114|  14.1k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  14.1k|   do {                                                                     \
  |  |   61|  14.1k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 14.1k]
  |  |  ------------------
  |  |   62|  14.1k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  14.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  14.1k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|  14.1k|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|  14.1k|         } else {
  119|  14.1k|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|  14.1k|         }
  121|  14.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     59|      void update(std::span<const uint8_t> input) {
   45|     59|         BufferSlicer in(input);
   46|       |
   47|    176|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 117, False: 59]
  ------------------
   48|    117|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 117]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|    117|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 59, False: 58]
  ------------------
   53|     59|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     59|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 59, False: 0]
  ------------------
   55|     59|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     59|               }
   57|     59|            }
   58|    117|         }
   59|       |
   60|     59|         m_count += input.size();
   61|     59|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|     74|      void update(std::span<const uint8_t> input) {
   45|     74|         BufferSlicer in(input);
   46|       |
   47|    221|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 147, False: 74]
  ------------------
   48|    147|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 147]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|    147|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 74, False: 73]
  ------------------
   53|     74|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|     74|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 74, False: 0]
  ------------------
   55|     74|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|     74|               }
   57|     74|            }
   58|    147|         }
   59|       |
   60|     74|         m_count += input.size();
   61|     74|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|    530|      void update(std::span<const uint8_t> input) {
   45|    530|         BufferSlicer in(input);
   46|       |
   47|  1.58k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 1.05k, False: 530]
  ------------------
   48|  1.05k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 0, False: 1.05k]
  ------------------
   49|      0|               MD::compress_n(m_digest, one_block.value(), 1);
   50|      0|            }
   51|       |
   52|  1.05k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 530, False: 522]
  ------------------
   53|    530|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|    530|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 530, False: 0]
  ------------------
   55|    530|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|    530|               }
   57|    530|            }
   58|  1.05k|         }
   59|       |
   60|    530|         m_count += input.size();
   61|    530|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     59|      void final(std::span<uint8_t> output) {
   64|     59|         append_padding_bit();
   65|     59|         append_counter_and_finalize();
   66|     59|         copy_output(output);
   67|     59|         clear();
   68|     59|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE18append_padding_bitEv:
   77|     59|      void append_padding_bit() {
   78|     59|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     59|   do {                                                                     \
  |  |   61|     59|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 59]
  |  |  ------------------
  |  |   62|     59|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     59|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     59|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     59|            const uint8_t final_byte = 0x80;
   81|     59|            m_buffer.append({&final_byte, 1});
   82|     59|         } else {
   83|     59|            const uint8_t final_byte = 0x01;
   84|     59|            m_buffer.append({&final_byte, 1});
   85|     59|         }
   86|     59|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE27append_counter_and_finalizeEv:
   88|     59|      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|     59|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 6, False: 53]
  ------------------
   92|      6|            m_buffer.fill_up_with_zeros();
   93|      6|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      6|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     59|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     59|   do {                                                                     \
  |  |   61|     59|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 59]
  |  |  ------------------
  |  |   62|     59|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     59|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     59|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     59|         const uint64_t bit_count = m_count * 8;
  102|     59|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     59|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     59|            store_be(bit_count, last_bytes.data());
  105|     59|         } else {
  106|     59|            store_le(bit_count, last_bytes.data());
  107|     59|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     59|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     59|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_384EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     59|      void copy_output(std::span<uint8_t> output) {
  114|     59|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     59|   do {                                                                     \
  |  |   61|     59|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 59]
  |  |  ------------------
  |  |   62|     59|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     59|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     59|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     59|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     59|         } else {
  119|     59|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     59|         }
  121|     59|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|     74|      void final(std::span<uint8_t> output) {
   64|     74|         append_padding_bit();
   65|     74|         append_counter_and_finalize();
   66|     74|         copy_output(output);
   67|     74|         clear();
   68|     74|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE18append_padding_bitEv:
   77|     74|      void append_padding_bit() {
   78|     74|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|     74|   do {                                                                     \
  |  |   61|     74|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 74]
  |  |  ------------------
  |  |   62|     74|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     74|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|     74|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|     74|            const uint8_t final_byte = 0x80;
   81|     74|            m_buffer.append({&final_byte, 1});
   82|     74|         } else {
   83|     74|            const uint8_t final_byte = 0x01;
   84|     74|            m_buffer.append({&final_byte, 1});
   85|     74|         }
   86|     74|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE27append_counter_and_finalizeEv:
   88|     74|      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|     74|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 4, False: 70]
  ------------------
   92|      4|            m_buffer.fill_up_with_zeros();
   93|      4|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|      4|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|     74|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|     74|   do {                                                                     \
  |  |   61|     74|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 74]
  |  |  ------------------
  |  |   62|     74|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     74|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|     74|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|     74|         const uint64_t bit_count = m_count * 8;
  102|     74|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|     74|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|     74|            store_be(bit_count, last_bytes.data());
  105|     74|         } else {
  106|     74|            store_le(bit_count, last_bytes.data());
  107|     74|         }
  108|       |
  109|       |         // Compress the very last block.
  110|     74|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|     74|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_512EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|     74|      void copy_output(std::span<uint8_t> output) {
  114|     74|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|     74|   do {                                                                     \
  |  |   61|     74|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 74]
  |  |  ------------------
  |  |   62|     74|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|     74|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|     74|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|     74|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|     74|         } else {
  119|     74|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|     74|         }
  121|     74|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|    530|      void final(std::span<uint8_t> output) {
   64|    530|         append_padding_bit();
   65|    530|         append_counter_and_finalize();
   66|    530|         copy_output(output);
   67|    530|         clear();
   68|    530|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE18append_padding_bitEv:
   77|    530|      void append_padding_bit() {
   78|    530|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|    530|   do {                                                                     \
  |  |   61|    530|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 530]
  |  |  ------------------
  |  |   62|    530|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    530|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   79|    530|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (79:23): [Folded - Ignored]
  ------------------
   80|    530|            const uint8_t final_byte = 0x80;
   81|    530|            m_buffer.append({&final_byte, 1});
   82|    530|         } else {
   83|    530|            const uint8_t final_byte = 0x01;
   84|    530|            m_buffer.append({&final_byte, 1});
   85|    530|         }
   86|    530|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE27append_counter_and_finalizeEv:
   88|    530|      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|    530|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 26, False: 504]
  ------------------
   92|     26|            m_buffer.fill_up_with_zeros();
   93|     26|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|     26|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|    530|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|    530|   do {                                                                     \
  |  |   61|    530|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 530]
  |  |  ------------------
  |  |   62|    530|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    530|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|    530|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|    530|         const uint64_t bit_count = m_count * 8;
  102|    530|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|    530|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (103:23): [Folded - Ignored]
  ------------------
  104|    530|            store_be(bit_count, last_bytes.data());
  105|    530|         } else {
  106|    530|            store_le(bit_count, last_bytes.data());
  107|    530|         }
  108|       |
  109|       |         // Compress the very last block.
  110|    530|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|    530|      }
_ZN5Botan18MerkleDamgard_HashINS_11SHA_512_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|    530|      void copy_output(std::span<uint8_t> output) {
  114|    530|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|    530|   do {                                                                     \
  |  |   61|    530|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 530]
  |  |  ------------------
  |  |   62|    530|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    530|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|    530|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  ------------------
  |  Branch (116:23): [Folded - Ignored]
  ------------------
  117|    530|            copy_out_vec_be(output.data(), MD::output_bytes, m_digest);
  118|    530|         } else {
  119|    530|            copy_out_vec_le(output.data(), MD::output_bytes, m_digest);
  120|    530|         }
  121|    530|      }

_ZNK5Botan14Montgomery_Int17const_time_poisonEv:
  122|    886|      void const_time_poison() const { m_v.const_time_poison(); }
_ZNK5Botan14Montgomery_Int19const_time_unpoisonEv:
  124|  1.75k|      void const_time_unpoison() const { return m_v.const_time_unpoison(); }
_ZNK5Botan17Montgomery_Params1pEv:
  148|  3.63k|      const BigInt& p() const { return m_p; }
_ZNK5Botan17Montgomery_Params2R1Ev:
  150|  1.81k|      const BigInt& R1() const { return m_r1; }
_ZNK5Botan17Montgomery_Params2R2Ev:
  152|  1.81k|      const BigInt& R2() const { return m_r2; }
_ZNK5Botan17Montgomery_Params7p_wordsEv:
  158|  11.3k|      size_t p_words() const { return m_p_words; }

_ZN5Botan17monty_exp_vartimeERKNSt3__110shared_ptrIKNS_17Montgomery_ParamsEEERKNS_6BigIntES9_:
   51|    496|                                const BigInt& k) {
   52|    496|   auto precomputed = monty_precompute(params_p, g, 4, false);
   53|    496|   return monty_execute_vartime(*precomputed, k);
   54|    496|}

_ZN5Botan10word8_sub3EPmPKmS2_m:
  413|  6.12M|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|  6.12M|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
  422|  6.12M|       : [carry] "=r"(carry)
  423|  6.12M|       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  424|  6.12M|       : "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|  6.12M|   return carry;
  438|  6.12M|}
_ZN5Botan8word_subEmmPm:
  326|   181M|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|   181M|   asm(ADD_OR_SUBTRACT(ASM("sbbq %[y],%[x]"))
  336|   181M|       : [x] "=r"(x), [carry] "=r"(*carry)
  337|   181M|       : "0"(x), [y] "rm"(y), "1"(*carry)
  338|   181M|       : "cc");
  339|   181M|   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|   181M|}
_ZN5Botan10word8_add3EPmPKmS2_m:
  296|   117k|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|   117k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcq"))
  305|   117k|       : [carry] "=r"(carry)
  306|   117k|       : [x] "r"(x), [y] "r"(y), [z] "r"(z), "0"(carry)
  307|   117k|       : "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|   117k|   return carry;
  321|   117k|}
_ZN5Botan8word_addEmmPm:
  237|  39.8M|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|  39.8M|   asm(ADD_OR_SUBTRACT(ASM("adcq %[y],%[x]"))
  248|  39.8M|       : [x] "=r"(x), [carry] "=r"(*carry)
  249|  39.8M|       : "0"(x), [y] "rm"(y), "1"(*carry)
  250|  39.8M|       : "cc");
  251|  39.8M|   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|  39.8M|}
_ZN5Botan10word_madd2EmmPm:
   44|  2.45M|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|  2.45M|   asm(R"(
   59|  2.45M|      mulq %[b]
   60|  2.45M|      addq %[c],%[a]
   61|  2.45M|      adcq $0,%[carry]
   62|  2.45M|      )"
   63|  2.45M|       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*c)
   64|  2.45M|       : "0"(a), "1"(b), [c] "g"(*c)
   65|  2.45M|       : "cc");
   66|       |
   67|  2.45M|   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|  2.45M|}
_ZN5Botan10word_madd3EmmmPm:
   91|  4.52M|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|  4.52M|   asm(R"(
  110|  4.52M|      mulq %[b]
  111|  4.52M|
  112|  4.52M|      addq %[c],%[a]
  113|  4.52M|      adcq $0,%[carry]
  114|  4.52M|
  115|  4.52M|      addq %[d],%[a]
  116|  4.52M|      adcq $0,%[carry]
  117|  4.52M|      )"
  118|  4.52M|       : [a] "=a"(a), [b] "=rm"(b), [carry] "=&d"(*d)
  119|  4.52M|       : "0"(a), "1"(b), [c] "g"(c), [d] "g"(*d)
  120|  4.52M|       : "cc");
  121|       |
  122|  4.52M|   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|  4.52M|}
_ZN5Botan10word8_add2EPmPKmm:
  265|  81.6k|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|  81.6k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcq"))
  275|  81.6k|       : [carry] "=r"(carry)
  276|  81.6k|       : [x] "r"(x), [y] "r"(y), "0"(carry)
  277|  81.6k|       : "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|  81.6k|   return carry;
  291|  81.6k|}
_ZN5Botan10word8_sub2EPmPKmm:
  353|  85.1k|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|  85.1k|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbq"))
  362|  85.1k|       : [carry] "=r"(carry)
  363|  85.1k|       : [x] "r"(x), [y] "r"(y), "0"(carry)
  364|  85.1k|       : "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|  85.1k|   return carry;
  378|  85.1k|}
_ZN5Botan14word8_sub2_revEPmPKmm:
  383|    499|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|    499|   asm(ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
  392|    499|       : [carry] "=r"(carry)
  393|    499|       : [x] "r"(y), [y] "r"(x), [z] "r"(x), "0"(carry)
  394|    499|       : "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|    499|   return carry;
  408|    499|}
_ZN5Botan13word8_linmul2EPmmm:
  443|  10.6M|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|  10.6M|   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|  10.6M|   return carry;
  462|  10.6M|}
_ZN5Botan13word8_linmul3EPmPKmmm:
  467|  28.8k|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|  28.8k|   asm(DO_8_TIMES(LINMUL_OP, "z")
  476|  28.8k|       : [carry] "=r"(carry)
  477|  28.8k|       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  478|  28.8k|       : "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|  28.8k|   return carry;
  492|  28.8k|}
_ZN5Botan11word8_madd3EPmPKmmm:
  497|  1.07M|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|  1.07M|   asm(DO_8_TIMES(MULADD_OP, "")
  506|  1.07M|       : [carry] "=r"(carry)
  507|  1.07M|       : [z] "r"(z), [x] "r"(x), [y] "rm"(y), "0"(carry)
  508|  1.07M|       : "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|  1.07M|   return carry;
  522|  1.07M|}
_ZN5Botan12word3_muladdEPmS0_S0_mm:
  528|   497M|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|   497M|   word z0 = 0, z1 = 0;
  545|       |
  546|   497M|   asm("mulq %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  547|       |
  548|   497M|   asm(R"(
  549|   497M|       addq %[z0],%[w0]
  550|   497M|       adcq %[z1],%[w1]
  551|   497M|       adcq $0,%[w2]
  552|   497M|       )"
  553|   497M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  554|   497M|       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  555|   497M|       : "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|   497M|}
_ZN5Botan9word3_addEPmS0_S0_m:
  569|   113M|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|   113M|   asm(R"(
  582|   113M|      addq %[x],%[w0]
  583|   113M|      adcq $0,%[w1]
  584|   113M|      adcq $0,%[w2]
  585|   113M|      )"
  586|   113M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  587|   113M|       : [x] "r"(x), "0"(*w0), "1"(*w1), "2"(*w2)
  588|   113M|       : "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|   113M|}
_ZN5Botan14word3_muladd_2EPmS0_S0_mm:
  603|  32.9M|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|  32.9M|   word z0 = 0, z1 = 0;
  624|       |
  625|  32.9M|   asm("mulq %[y]" : "=a"(z0), "=d"(z1) : "a"(x), [y] "rm"(y) : "cc");
  626|       |
  627|  32.9M|   asm(R"(
  628|  32.9M|      addq %[z0],%[w0]
  629|  32.9M|      adcq %[z1],%[w1]
  630|  32.9M|      adcq $0,%[w2]
  631|  32.9M|
  632|  32.9M|      addq %[z0],%[w0]
  633|  32.9M|      adcq %[z1],%[w1]
  634|  32.9M|      adcq $0,%[w2]
  635|  32.9M|      )"
  636|  32.9M|       : [w0] "=r"(*w0), [w1] "=r"(*w1), [w2] "=r"(*w2)
  637|  32.9M|       : [z0] "r"(z0), [z1] "r"(z1), "0"(*w0), "1"(*w1), "2"(*w2)
  638|  32.9M|       : "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|  32.9M|}

_ZN5Botan10bigint_cmpEPKmmS1_m:
  490|   111k|inline int32_t bigint_cmp(const word x[], size_t x_size, const word y[], size_t y_size) {
  491|   111k|   static_assert(sizeof(word) >= sizeof(uint32_t), "Size assumption");
  492|       |
  493|   111k|   const word LT = static_cast<word>(-1);
  494|   111k|   const word EQ = 0;
  495|   111k|   const word GT = 1;
  496|       |
  497|   111k|   const size_t common_elems = std::min(x_size, y_size);
  498|       |
  499|   111k|   word result = EQ;  // until found otherwise
  500|       |
  501|   752k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (501:22): [True: 641k, False: 111k]
  ------------------
  502|   641k|      const auto is_eq = CT::Mask<word>::is_equal(x[i], y[i]);
  503|   641k|      const auto is_lt = CT::Mask<word>::is_lt(x[i], y[i]);
  504|       |
  505|   641k|      result = is_eq.select(result, is_lt.select(LT, GT));
  506|   641k|   }
  507|       |
  508|   111k|   if(x_size < y_size) {
  ------------------
  |  Branch (508:7): [True: 19.1k, False: 92.0k]
  ------------------
  509|  19.1k|      word mask = 0;
  510|   110k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (510:30): [True: 91.3k, False: 19.1k]
  ------------------
  511|  91.3k|         mask |= y[i];
  512|  91.3k|      }
  513|       |
  514|       |      // If any bits were set in high part of y, then x < y
  515|  19.1k|      result = CT::Mask<word>::is_zero(mask).select(result, LT);
  516|  92.0k|   } else if(y_size < x_size) {
  ------------------
  |  Branch (516:14): [True: 2.37k, False: 89.7k]
  ------------------
  517|  2.37k|      word mask = 0;
  518|  30.9k|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (518:30): [True: 28.6k, False: 2.37k]
  ------------------
  519|  28.6k|         mask |= x[i];
  520|  28.6k|      }
  521|       |
  522|       |      // If any bits were set in high part of x, then x > y
  523|  2.37k|      result = CT::Mask<word>::is_zero(mask).select(result, GT);
  524|  2.37k|   }
  525|       |
  526|   111k|   CT::unpoison(result);
  527|   111k|   BOTAN_DEBUG_ASSERT(result == LT || result == GT || result == EQ);
  ------------------
  |  |   99|   111k|      do {                          \
  |  |  100|   111k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  528|   111k|   return static_cast<int32_t>(result);
  529|   111k|}
_ZN5Botan15bigint_ct_is_eqEPKmmS1_m:
  568|  10.9k|inline CT::Mask<word> bigint_ct_is_eq(const word x[], size_t x_size, const word y[], size_t y_size) {
  569|  10.9k|   const size_t common_elems = std::min(x_size, y_size);
  570|       |
  571|  10.9k|   word diff = 0;
  572|       |
  573|  46.4k|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (573:22): [True: 35.4k, False: 10.9k]
  ------------------
  574|  35.4k|      diff |= (x[i] ^ y[i]);
  575|  35.4k|   }
  576|       |
  577|       |   // If any bits were set in high part of x/y, then they are not equal
  578|  10.9k|   if(x_size < y_size) {
  ------------------
  |  Branch (578:7): [True: 1.77k, False: 9.16k]
  ------------------
  579|  8.07k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (579:30): [True: 6.29k, False: 1.77k]
  ------------------
  580|  6.29k|         diff |= y[i];
  581|  6.29k|      }
  582|  9.16k|   } else if(y_size < x_size) {
  ------------------
  |  Branch (582:14): [True: 1.13k, False: 8.02k]
  ------------------
  583|  2.87k|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (583:30): [True: 1.73k, False: 1.13k]
  ------------------
  584|  1.73k|         diff |= x[i];
  585|  1.73k|      }
  586|  1.13k|   }
  587|       |
  588|  10.9k|   return CT::Mask<word>::is_zero(diff);
  589|  10.9k|}
_ZN5Botan15bigint_ct_is_ltEPKmmS1_mb:
  537|  5.46M|   const word x[], size_t x_size, const word y[], size_t y_size, bool lt_or_equal = false) {
  538|  5.46M|   const size_t common_elems = std::min(x_size, y_size);
  539|       |
  540|  5.46M|   auto is_lt = CT::Mask<word>::expand(lt_or_equal);
  541|       |
  542|  27.1M|   for(size_t i = 0; i != common_elems; i++) {
  ------------------
  |  Branch (542:22): [True: 21.6M, False: 5.46M]
  ------------------
  543|  21.6M|      const auto eq = CT::Mask<word>::is_equal(x[i], y[i]);
  544|  21.6M|      const auto lt = CT::Mask<word>::is_lt(x[i], y[i]);
  545|  21.6M|      is_lt = eq.select_mask(is_lt, lt);
  546|  21.6M|   }
  547|       |
  548|  5.46M|   if(x_size < y_size) {
  ------------------
  |  Branch (548:7): [True: 3.23k, False: 5.46M]
  ------------------
  549|  3.23k|      word mask = 0;
  550|  27.9k|      for(size_t i = x_size; i != y_size; i++) {
  ------------------
  |  Branch (550:30): [True: 24.6k, False: 3.23k]
  ------------------
  551|  24.6k|         mask |= y[i];
  552|  24.6k|      }
  553|       |      // If any bits were set in high part of y, then is_lt should be forced true
  554|  3.23k|      is_lt |= CT::Mask<word>::expand(mask);
  555|  5.46M|   } else if(y_size < x_size) {
  ------------------
  |  Branch (555:14): [True: 3.04k, False: 5.46M]
  ------------------
  556|  3.04k|      word mask = 0;
  557|  19.8k|      for(size_t i = y_size; i != x_size; i++) {
  ------------------
  |  Branch (557:30): [True: 16.7k, False: 3.04k]
  ------------------
  558|  16.7k|         mask |= x[i];
  559|  16.7k|      }
  560|       |
  561|       |      // If any bits were set in high part of x, then is_lt should be false
  562|  3.04k|      is_lt &= CT::Mask<word>::is_zero(mask);
  563|  3.04k|   }
  564|       |
  565|  5.46M|   return is_lt;
  566|  5.46M|}
_ZN5Botan11bigint_sub3EPmPKmmS2_m:
  321|  29.5M|inline word bigint_sub3(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  322|  29.5M|   word borrow = 0;
  323|       |
  324|  29.5M|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  29.5M|   do {                                                                                 \
  |  |   52|  29.5M|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 29.5M]
  |  |  ------------------
  |  |   53|  29.5M|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  29.5M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  325|       |
  326|  29.5M|   const size_t blocks = y_size - (y_size % 8);
  327|       |
  328|  35.5M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (328:22): [True: 5.99M, False: 29.5M]
  ------------------
  329|  5.99M|      borrow = word8_sub3(z + i, x + i, y + i, borrow);
  330|  5.99M|   }
  331|       |
  332|   143M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (332:27): [True: 114M, False: 29.5M]
  ------------------
  333|   114M|      z[i] = word_sub(x[i], y[i], &borrow);
  334|   114M|   }
  335|       |
  336|  66.3M|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (336:27): [True: 36.8M, False: 29.5M]
  ------------------
  337|  36.8M|      z[i] = word_sub(x[i], 0, &borrow);
  338|  36.8M|   }
  339|       |
  340|  29.5M|   return borrow;
  341|  29.5M|}
_ZN5Botan14bigint_cnd_addEmPmmPKmm:
   40|  2.97M|inline word bigint_cnd_add(word cnd, word x[], word x_size, const word y[], size_t y_size) {
   41|  2.97M|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  2.97M|   do {                                                                                 \
  |  |   52|  2.97M|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 2.97M]
  |  |  ------------------
  |  |   53|  2.97M|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  2.97M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   42|       |
   43|  2.97M|   const auto mask = CT::Mask<word>::expand(cnd);
   44|       |
   45|  2.97M|   word carry = 0;
   46|       |
   47|  2.97M|   const size_t blocks = y_size - (y_size % 8);
   48|  2.97M|   word z[8] = {0};
   49|       |
   50|  2.97M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (50:22): [True: 3.07k, False: 2.97M]
  ------------------
   51|  3.07k|      carry = word8_add3(z, x + i, y + i, carry);
   52|  3.07k|      mask.select_n(x + i, z, x + i, 8);
   53|  3.07k|   }
   54|       |
   55|  14.7M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (55:27): [True: 11.7M, False: 2.97M]
  ------------------
   56|  11.7M|      z[0] = word_add(x[i], y[i], &carry);
   57|  11.7M|      x[i] = mask.select(z[0], x[i]);
   58|  11.7M|   }
   59|       |
   60|  3.29M|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (60:27): [True: 318k, False: 2.97M]
  ------------------
   61|   318k|      z[0] = word_add(x[i], 0, &carry);
   62|   318k|      x[i] = mask.select(z[0], x[i]);
   63|   318k|   }
   64|       |
   65|  2.97M|   return mask.if_set_return(carry);
   66|  2.97M|}
_ZN5Botan11bigint_shl2EPmPKmmmm:
  417|  33.5k|inline void bigint_shl2(word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift) {
  418|  33.5k|   copy_mem(y + word_shift, x, x_size);
  419|       |
  420|  33.5k|   const auto carry_mask = CT::Mask<word>::expand(bit_shift);
  421|  33.5k|   const word carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);
  ------------------
  |  |   50|  33.5k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  422|       |
  423|  33.5k|   word carry = 0;
  424|   166k|   for(size_t i = word_shift; i != x_size + word_shift + 1; ++i) {
  ------------------
  |  Branch (424:31): [True: 132k, False: 33.5k]
  ------------------
  425|   132k|      const word w = y[i];
  426|   132k|      y[i] = (w << bit_shift) | carry;
  427|   132k|      carry = carry_mask.if_set_return(w >> carry_shift);
  428|   132k|   }
  429|  33.5k|}
_ZN5Botan15bigint_cnd_swapEmPmS0_m:
   29|  4.15M|inline void bigint_cnd_swap(word cnd, word x[], word y[], size_t size) {
   30|  4.15M|   const auto mask = CT::Mask<word>::expand(cnd);
   31|       |
   32|  80.1M|   for(size_t i = 0; i != size; ++i) {
  ------------------
  |  Branch (32:22): [True: 76.0M, False: 4.15M]
  ------------------
   33|  76.0M|      const word a = x[i];
   34|  76.0M|      const word b = y[i];
   35|  76.0M|      x[i] = mask.select(b, a);
   36|  76.0M|      y[i] = mask.select(a, b);
   37|  76.0M|   }
   38|  4.15M|}
_ZN5Botan14bigint_cnd_addEmPmPKmm:
   72|  2.65M|inline word bigint_cnd_add(word cnd, word x[], const word y[], size_t size) {
   73|  2.65M|   return bigint_cnd_add(cnd, x, size, y, size);
   74|  2.65M|}
_ZN5Botan14bigint_cnd_subEmPmmPKmm:
   80|  1.76M|inline word bigint_cnd_sub(word cnd, word x[], size_t x_size, const word y[], size_t y_size) {
   81|  1.76M|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|  1.76M|   do {                                                                                 \
  |  |   52|  1.76M|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 1.76M]
  |  |  ------------------
  |  |   53|  1.76M|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  1.76M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   82|       |
   83|  1.76M|   const auto mask = CT::Mask<word>::expand(cnd);
   84|       |
   85|  1.76M|   word carry = 0;
   86|       |
   87|  1.76M|   const size_t blocks = y_size - (y_size % 8);
   88|  1.76M|   word z[8] = {0};
   89|       |
   90|  1.77M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (90:22): [True: 2.04k, False: 1.76M]
  ------------------
   91|  2.04k|      carry = word8_sub3(z, x + i, y + i, carry);
   92|  2.04k|      mask.select_n(x + i, z, x + i, 8);
   93|  2.04k|   }
   94|       |
   95|  8.79M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (95:27): [True: 7.03M, False: 1.76M]
  ------------------
   96|  7.03M|      z[0] = word_sub(x[i], y[i], &carry);
   97|  7.03M|      x[i] = mask.select(z[0], x[i]);
   98|  7.03M|   }
   99|       |
  100|  1.76M|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (100:27): [True: 0, False: 1.76M]
  ------------------
  101|      0|      z[0] = word_sub(x[i], 0, &carry);
  102|      0|      x[i] = mask.select(z[0], x[i]);
  103|      0|   }
  104|       |
  105|  1.76M|   return mask.if_set_return(carry);
  106|  1.76M|}
_ZN5Botan14bigint_cnd_subEmPmPKmm:
  112|  1.76M|inline word bigint_cnd_sub(word cnd, word x[], const word y[], size_t size) {
  113|  1.76M|   return bigint_cnd_sub(cnd, x, size, y, size);
  114|  1.76M|}
_ZN5Botan21bigint_cnd_add_or_subENS_2CT4MaskImEEPmPKmm:
  123|  4.39k|inline void bigint_cnd_add_or_sub(CT::Mask<word> mask, word x[], const word y[], size_t size) {
  124|  4.39k|   const size_t blocks = size - (size % 8);
  125|       |
  126|  4.39k|   word carry = 0;
  127|  4.39k|   word borrow = 0;
  128|       |
  129|  4.39k|   word t0[8] = {0};
  130|  4.39k|   word t1[8] = {0};
  131|       |
  132|  31.9k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (132:22): [True: 27.5k, False: 4.39k]
  ------------------
  133|  27.5k|      carry = word8_add3(t0, x + i, y + i, carry);
  134|  27.5k|      borrow = word8_sub3(t1, x + i, y + i, borrow);
  135|       |
  136|   248k|      for(size_t j = 0; j != 8; ++j) {
  ------------------
  |  Branch (136:25): [True: 220k, False: 27.5k]
  ------------------
  137|   220k|         x[i + j] = mask.select(t0[j], t1[j]);
  138|   220k|      }
  139|  27.5k|   }
  140|       |
  141|  5.68k|   for(size_t i = blocks; i != size; ++i) {
  ------------------
  |  Branch (141:27): [True: 1.28k, False: 4.39k]
  ------------------
  142|  1.28k|      const word a = word_add(x[i], y[i], &carry);
  143|  1.28k|      const word s = word_sub(x[i], y[i], &borrow);
  144|       |
  145|  1.28k|      x[i] = mask.select(a, s);
  146|  1.28k|   }
  147|  4.39k|}
_ZN5Botan17bigint_cnd_addsubENS_2CT4MaskImEEPmPKmS5_m:
  158|  5.27M|inline word bigint_cnd_addsub(CT::Mask<word> mask, word x[], const word y[], const word z[], size_t size) {
  159|  5.27M|   const size_t blocks = size - (size % 8);
  160|       |
  161|  5.27M|   word carry = 0;
  162|  5.27M|   word borrow = 0;
  163|       |
  164|  5.27M|   word t0[8] = {0};
  165|  5.27M|   word t1[8] = {0};
  166|       |
  167|  5.28M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (167:22): [True: 11.0k, False: 5.27M]
  ------------------
  168|  11.0k|      carry = word8_add3(t0, x + i, y + i, carry);
  169|  11.0k|      borrow = word8_sub3(t1, x + i, z + i, borrow);
  170|       |
  171|  99.4k|      for(size_t j = 0; j != 8; ++j) {
  ------------------
  |  Branch (171:25): [True: 88.4k, False: 11.0k]
  ------------------
  172|  88.4k|         x[i + j] = mask.select(t0[j], t1[j]);
  173|  88.4k|      }
  174|  11.0k|   }
  175|       |
  176|  26.3M|   for(size_t i = blocks; i != size; ++i) {
  ------------------
  |  Branch (176:27): [True: 21.0M, False: 5.27M]
  ------------------
  177|  21.0M|      t0[0] = word_add(x[i], y[i], &carry);
  178|  21.0M|      t1[0] = word_sub(x[i], z[i], &borrow);
  179|  21.0M|      x[i] = mask.select(t0[0], t1[0]);
  180|  21.0M|   }
  181|       |
  182|  5.27M|   return mask.select(carry, borrow);
  183|  5.27M|}
_ZN5Botan14bigint_cnd_absEmPmm:
  190|   884k|inline void bigint_cnd_abs(word cnd, word x[], size_t size) {
  191|   884k|   const auto mask = CT::Mask<word>::expand(cnd);
  192|       |
  193|   884k|   word carry = mask.if_set_return(1);
  194|  4.40M|   for(size_t i = 0; i != size; ++i) {
  ------------------
  |  Branch (194:22): [True: 3.52M, False: 884k]
  ------------------
  195|  3.52M|      const word z = word_add(~x[i], 0, &carry);
  196|  3.52M|      x[i] = mask.select(z, x[i]);
  197|  3.52M|   }
  198|   884k|}
_ZN5Botan14bigint_add2_ncEPmmPKmm:
  203|   117k|inline word bigint_add2_nc(word x[], size_t x_size, const word y[], size_t y_size) {
  204|   117k|   word carry = 0;
  205|       |
  206|   117k|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|   117k|   do {                                                                                 \
  |  |   52|   117k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 117k]
  |  |  ------------------
  |  |   53|   117k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|   117k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  207|       |
  208|   117k|   const size_t blocks = y_size - (y_size % 8);
  209|       |
  210|   199k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (210:22): [True: 81.6k, False: 117k]
  ------------------
  211|  81.6k|      carry = word8_add2(x + i, y + i, carry);
  212|  81.6k|   }
  213|       |
  214|   222k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (214:27): [True: 105k, False: 117k]
  ------------------
  215|   105k|      x[i] = word_add(x[i], y[i], &carry);
  216|   105k|   }
  217|       |
  218|  1.60M|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (218:27): [True: 1.49M, False: 117k]
  ------------------
  219|  1.49M|      x[i] = word_add(x[i], 0, &carry);
  220|  1.49M|   }
  221|       |
  222|   117k|   return carry;
  223|   117k|}
_ZN5Botan14bigint_add3_ncEPmPKmmS2_m:
  228|   426k|inline word bigint_add3_nc(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  229|   426k|   if(x_size < y_size) {
  ------------------
  |  Branch (229:7): [True: 690, False: 425k]
  ------------------
  230|    690|      return bigint_add3_nc(z, y, y_size, x, x_size);
  231|    690|   }
  232|       |
  233|   425k|   word carry = 0;
  234|       |
  235|   425k|   const size_t blocks = y_size - (y_size % 8);
  236|       |
  237|   500k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (237:22): [True: 75.5k, False: 425k]
  ------------------
  238|  75.5k|      carry = word8_add3(z + i, x + i, y + i, carry);
  239|  75.5k|   }
  240|       |
  241|  2.04M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (241:27): [True: 1.61M, False: 425k]
  ------------------
  242|  1.61M|      z[i] = word_add(x[i], y[i], &carry);
  243|  1.61M|   }
  244|       |
  245|   438k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (245:27): [True: 12.7k, False: 425k]
  ------------------
  246|  12.7k|      z[i] = word_add(x[i], 0, &carry);
  247|  12.7k|   }
  248|       |
  249|   425k|   return carry;
  250|   426k|}
_ZN5Botan11bigint_add2EPmmPKmm:
  259|  60.6k|inline void bigint_add2(word x[], size_t x_size, const word y[], size_t y_size) {
  260|  60.6k|   x[x_size] += bigint_add2_nc(x, x_size, y, y_size);
  261|  60.6k|}
_ZN5Botan11bigint_add3EPmPKmmS2_m:
  266|  7.17k|inline void bigint_add3(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  267|  7.17k|   z[x_size > y_size ? x_size : y_size] += bigint_add3_nc(z, x, x_size, y, y_size);
  ------------------
  |  Branch (267:6): [True: 3.76k, False: 3.41k]
  ------------------
  268|  7.17k|}
_ZN5Botan11bigint_sub2EPmmPKmm:
  273|   379k|inline word bigint_sub2(word x[], size_t x_size, const word y[], size_t y_size) {
  274|   379k|   word borrow = 0;
  275|       |
  276|   379k|   BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
  ------------------
  |  |   51|   379k|   do {                                                                                 \
  |  |   52|   379k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 379k]
  |  |  ------------------
  |  |   53|   379k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|   379k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  277|       |
  278|   379k|   const size_t blocks = y_size - (y_size % 8);
  279|       |
  280|   464k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (280:22): [True: 85.1k, False: 379k]
  ------------------
  281|  85.1k|      borrow = word8_sub2(x + i, y + i, borrow);
  282|  85.1k|   }
  283|       |
  284|  1.77M|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (284:27): [True: 1.39M, False: 379k]
  ------------------
  285|  1.39M|      x[i] = word_sub(x[i], y[i], &borrow);
  286|  1.39M|   }
  287|       |
  288|   947k|   for(size_t i = y_size; i != x_size; ++i) {
  ------------------
  |  Branch (288:27): [True: 567k, False: 379k]
  ------------------
  289|   567k|      x[i] = word_sub(x[i], 0, &borrow);
  290|   567k|   }
  291|       |
  292|   379k|   return borrow;
  293|   379k|}
_ZN5Botan15bigint_sub2_revEPmPKmm:
  298|    241|inline void bigint_sub2_rev(word x[], const word y[], size_t y_size) {
  299|    241|   word borrow = 0;
  300|       |
  301|    241|   const size_t blocks = y_size - (y_size % 8);
  302|       |
  303|    740|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (303:22): [True: 499, False: 241]
  ------------------
  304|    499|      borrow = word8_sub2_rev(x + i, y + i, borrow);
  305|    499|   }
  306|       |
  307|  1.03k|   for(size_t i = blocks; i != y_size; ++i) {
  ------------------
  |  Branch (307:27): [True: 795, False: 241]
  ------------------
  308|    795|      x[i] = word_sub(y[i], x[i], &borrow);
  309|    795|   }
  310|       |
  311|    241|   BOTAN_ASSERT(borrow == 0, "y must be greater than x");
  ------------------
  |  |   51|    241|   do {                                                                                 \
  |  |   52|    241|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 241]
  |  |  ------------------
  |  |   53|    241|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|    241|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  312|    241|}
_ZN5Botan14bigint_sub_absEPmPKmS2_mS0_:
  355|  22.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|  22.7k|   word* ws0 = ws;
  359|  22.7k|   word* ws1 = ws + N;
  360|       |
  361|  22.7k|   word borrow0 = 0;
  362|  22.7k|   word borrow1 = 0;
  363|       |
  364|  22.7k|   const size_t blocks = N - (N % 8);
  365|       |
  366|  69.1k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (366:22): [True: 46.4k, False: 22.7k]
  ------------------
  367|  46.4k|      borrow0 = word8_sub3(ws0 + i, x + i, y + i, borrow0);
  368|  46.4k|      borrow1 = word8_sub3(ws1 + i, y + i, x + i, borrow1);
  369|  46.4k|   }
  370|       |
  371|  26.9k|   for(size_t i = blocks; i != N; ++i) {
  ------------------
  |  Branch (371:27): [True: 4.17k, False: 22.7k]
  ------------------
  372|  4.17k|      ws0[i] = word_sub(x[i], y[i], &borrow0);
  373|  4.17k|      ws1[i] = word_sub(y[i], x[i], &borrow1);
  374|  4.17k|   }
  375|       |
  376|  22.7k|   return CT::conditional_copy_mem(borrow0, z, ws1, ws0, N);
  377|  22.7k|}
_ZN5Botan11bigint_shl1EPmmmmm:
  382|  67.1k|inline void bigint_shl1(word x[], size_t x_size, size_t x_words, size_t word_shift, size_t bit_shift) {
  383|  67.1k|   copy_mem(x + word_shift, x, x_words);
  384|  67.1k|   clear_mem(x, word_shift);
  385|       |
  386|  67.1k|   const auto carry_mask = CT::Mask<word>::expand(bit_shift);
  387|  67.1k|   const word carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);
  ------------------
  |  |   50|  67.1k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  388|       |
  389|  67.1k|   word carry = 0;
  390|   313k|   for(size_t i = word_shift; i != x_size; ++i) {
  ------------------
  |  Branch (390:31): [True: 246k, False: 67.1k]
  ------------------
  391|   246k|      const word w = x[i];
  392|   246k|      x[i] = (w << bit_shift) | carry;
  393|   246k|      carry = carry_mask.if_set_return(w >> carry_shift);
  394|   246k|   }
  395|  67.1k|}
_ZN5Botan11bigint_shr1EPmmmm:
  397|  1.92M|inline void bigint_shr1(word x[], size_t x_size, size_t word_shift, size_t bit_shift) {
  398|  1.92M|   const size_t top = x_size >= word_shift ? (x_size - word_shift) : 0;
  ------------------
  |  Branch (398:23): [True: 1.91M, False: 2.34k]
  ------------------
  399|       |
  400|  1.92M|   if(top > 0) {
  ------------------
  |  Branch (400:7): [True: 1.91M, False: 2.35k]
  ------------------
  401|  1.91M|      copy_mem(x, x + word_shift, top);
  402|  1.91M|   }
  403|  1.92M|   clear_mem(x + top, std::min(word_shift, x_size));
  404|       |
  405|  1.92M|   const auto carry_mask = CT::Mask<word>::expand(bit_shift);
  406|  1.92M|   const word carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);
  ------------------
  |  |   50|  1.92M|#define BOTAN_MP_WORD_BITS 64
  ------------------
  407|       |
  408|  1.92M|   word carry = 0;
  409|       |
  410|  10.7M|   for(size_t i = 0; i != top; ++i) {
  ------------------
  |  Branch (410:22): [True: 8.84M, False: 1.92M]
  ------------------
  411|  8.84M|      const word w = x[top - i - 1];
  412|  8.84M|      x[top - i - 1] = (w >> bit_shift) | carry;
  413|  8.84M|      carry = carry_mask.if_set_return(w << carry_shift);
  414|  8.84M|   }
  415|  1.92M|}
_ZN5Botan11bigint_shr2EPmPKmmmm:
  431|    496|inline void bigint_shr2(word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift) {
  432|    496|   const size_t new_size = x_size < word_shift ? 0 : (x_size - word_shift);
  ------------------
  |  Branch (432:28): [True: 0, False: 496]
  ------------------
  433|       |
  434|    496|   if(new_size > 0) {
  ------------------
  |  Branch (434:7): [True: 496, False: 0]
  ------------------
  435|    496|      copy_mem(y, x + word_shift, new_size);
  436|    496|   }
  437|       |
  438|    496|   const auto carry_mask = CT::Mask<word>::expand(bit_shift);
  439|    496|   const word carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);
  ------------------
  |  |   50|    496|#define BOTAN_MP_WORD_BITS 64
  ------------------
  440|       |
  441|    496|   word carry = 0;
  442|  2.42k|   for(size_t i = new_size; i > 0; --i) {
  ------------------
  |  Branch (442:29): [True: 1.93k, False: 496]
  ------------------
  443|  1.93k|      word w = y[i - 1];
  444|  1.93k|      y[i - 1] = (w >> bit_shift) | carry;
  445|  1.93k|      carry = carry_mask.if_set_return(w << carry_shift);
  446|  1.93k|   }
  447|    496|}
_ZN5Botan14bigint_linmul2EPmmm:
  452|  4.86M|[[nodiscard]] inline word bigint_linmul2(word x[], size_t x_size, word y) {
  453|  4.86M|   const size_t blocks = x_size - (x_size % 8);
  454|       |
  455|  4.86M|   word carry = 0;
  456|       |
  457|  15.5M|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (457:22): [True: 10.6M, False: 4.86M]
  ------------------
  458|  10.6M|      carry = word8_linmul2(x + i, y, carry);
  459|  10.6M|   }
  460|       |
  461|  6.91M|   for(size_t i = blocks; i != x_size; ++i) {
  ------------------
  |  Branch (461:27): [True: 2.05M, False: 4.86M]
  ------------------
  462|  2.05M|      x[i] = word_madd2(x[i], y, &carry);
  463|  2.05M|   }
  464|       |
  465|  4.86M|   return carry;
  466|  4.86M|}
_ZN5Botan14bigint_linmul3EPmPKmmm:
  468|  98.4k|inline void bigint_linmul3(word z[], const word x[], size_t x_size, word y) {
  469|  98.4k|   const size_t blocks = x_size - (x_size % 8);
  470|       |
  471|  98.4k|   word carry = 0;
  472|       |
  473|   127k|   for(size_t i = 0; i != blocks; i += 8) {
  ------------------
  |  Branch (473:22): [True: 28.8k, False: 98.4k]
  ------------------
  474|  28.8k|      carry = word8_linmul3(z + i, x + i, y, carry);
  475|  28.8k|   }
  476|       |
  477|   310k|   for(size_t i = blocks; i != x_size; ++i) {
  ------------------
  |  Branch (477:27): [True: 211k, False: 98.4k]
  ------------------
  478|   211k|      z[i] = word_madd2(x[i], y, &carry);
  479|   211k|   }
  480|       |
  481|  98.4k|   z[x_size] = carry;
  482|  98.4k|}
_ZN5Botan14bigint_sub_absEPmPKmmS2_m:
  604|  44.5k|inline int32_t bigint_sub_abs(word z[], const word x[], size_t x_size, const word y[], size_t y_size) {
  605|  44.5k|   const int32_t relative_size = bigint_cmp(x, x_size, y, y_size);
  606|       |
  607|       |   // Swap if relative_size == -1
  608|  44.5k|   const bool need_swap = relative_size < 0;
  609|  44.5k|   CT::conditional_swap_ptr(need_swap, x, y);
  610|  44.5k|   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|  44.5k|   y_size = std::min(x_size, y_size);
  618|       |
  619|  44.5k|   bigint_sub3(z, x, x_size, y, y_size);
  620|       |
  621|  44.5k|   return relative_size;
  622|  44.5k|}
_ZN5Botan14bigint_mod_subEPmPKmS2_mS0_:
  633|  27.6k|inline void bigint_mod_sub(word t[], const word s[], const word mod[], size_t mod_sw, word ws[]) {
  634|       |   // is t < s or not?
  635|  27.6k|   const auto is_lt = bigint_ct_is_lt(t, mod_sw, s, mod_sw);
  636|       |
  637|       |   // ws = p - s
  638|  27.6k|   const word borrow = bigint_sub3(ws, mod, mod_sw, s, mod_sw);
  639|       |
  640|       |   // Compute either (t - s) or (t + (p - s)) depending on mask
  641|  27.6k|   const word carry = bigint_cnd_addsub(is_lt, t, ws, s, mod_sw);
  642|       |
  643|  27.6k|   BOTAN_DEBUG_ASSERT(borrow == 0 && carry == 0);
  ------------------
  |  |   99|  27.6k|      do {                          \
  |  |  100|  27.6k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  644|  27.6k|   BOTAN_UNUSED(carry, borrow);
  ------------------
  |  |  118|  27.6k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  645|  27.6k|}
_ZN5Botan20bigint_divop_vartimeEmmm:
  665|  47.2k|inline word bigint_divop_vartime(word n1, word n0, word d) {
  666|  47.2k|   if(d == 0) {
  ------------------
  |  Branch (666:7): [True: 0, False: 47.2k]
  ------------------
  667|      0|      throw Invalid_Argument("bigint_divop_vartime divide by zero");
  668|      0|   }
  669|       |
  670|  47.2k|#if defined(BOTAN_MP_DWORD)
  671|  47.2k|   return static_cast<word>(((static_cast<BOTAN_MP_DWORD>(n1) << BOTAN_MP_WORD_BITS) | n0) / d);
  ------------------
  |  |   50|  47.2k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  672|       |#else
  673|       |
  674|       |   word high = n1 % d;
  675|       |   word quotient = 0;
  676|       |
  677|       |   for(size_t i = 0; i != BOTAN_MP_WORD_BITS; ++i) {
  678|       |      const word high_top_bit = high >> (BOTAN_MP_WORD_BITS - 1);
  679|       |
  680|       |      high <<= 1;
  681|       |      high |= (n0 >> (BOTAN_MP_WORD_BITS - 1 - i)) & 1;
  682|       |      quotient <<= 1;
  683|       |
  684|       |      if(high_top_bit || high >= d) {
  685|       |         high -= d;
  686|       |         quotient |= 1;
  687|       |      }
  688|       |   }
  689|       |
  690|       |   return quotient;
  691|       |#endif
  692|  47.2k|}
_ZN5Botan20bigint_modop_vartimeEmmm:
  697|  12.6k|inline word bigint_modop_vartime(word n1, word n0, word d) {
  698|  12.6k|   if(d == 0) {
  ------------------
  |  Branch (698:7): [True: 0, False: 12.6k]
  ------------------
  699|      0|      throw Invalid_Argument("bigint_modop_vartime divide by zero");
  700|      0|   }
  701|       |
  702|  12.6k|#if defined(BOTAN_MP_DWORD)
  703|  12.6k|   return ((static_cast<BOTAN_MP_DWORD>(n1) << BOTAN_MP_WORD_BITS) | n0) % d;
  ------------------
  |  |   50|  12.6k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  704|       |#else
  705|       |   word z = bigint_divop_vartime(n1, n0, d);
  706|       |   word dummy = 0;
  707|       |   z = word_madd2(z, d, &dummy);
  708|       |   return (n0 - z);
  709|       |#endif
  710|  12.6k|}
_ZN5Botan17bigint_monty_redcEPmPKmmmS0_m:
  757|  15.9M|inline void bigint_monty_redc(word z[], const word p[], size_t p_size, word p_dash, word ws[], size_t ws_size) {
  758|  15.9M|   const size_t z_size = 2 * p_size;
  759|       |
  760|  15.9M|   BOTAN_ARG_CHECK(ws_size >= p_size + 1, "Montgomery workspace too small");
  ------------------
  |  |   30|  15.9M|   do {                                                          \
  |  |   31|  15.9M|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 15.9M]
  |  |  ------------------
  |  |   32|  15.9M|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  15.9M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  761|       |
  762|  15.9M|   if(p_size == 4) {
  ------------------
  |  Branch (762:7): [True: 15.6M, False: 264k]
  ------------------
  763|  15.6M|      bigint_monty_redc_4(z, p, p_dash, ws);
  764|  15.6M|   } else if(p_size == 6) {
  ------------------
  |  Branch (764:14): [True: 5.10k, False: 259k]
  ------------------
  765|  5.10k|      bigint_monty_redc_6(z, p, p_dash, ws);
  766|   259k|   } else if(p_size == 8) {
  ------------------
  |  Branch (766:14): [True: 39.3k, False: 220k]
  ------------------
  767|  39.3k|      bigint_monty_redc_8(z, p, p_dash, ws);
  768|   220k|   } else if(p_size == 16) {
  ------------------
  |  Branch (768:14): [True: 5.05k, False: 215k]
  ------------------
  769|  5.05k|      bigint_monty_redc_16(z, p, p_dash, ws);
  770|   215k|   } else if(p_size == 24) {
  ------------------
  |  Branch (770:14): [True: 4.16k, False: 211k]
  ------------------
  771|  4.16k|      bigint_monty_redc_24(z, p, p_dash, ws);
  772|   211k|   } else if(p_size == 32) {
  ------------------
  |  Branch (772:14): [True: 16.5k, False: 194k]
  ------------------
  773|  16.5k|      bigint_monty_redc_32(z, p, p_dash, ws);
  774|   194k|   } else {
  775|   194k|      bigint_monty_redc_generic(z, z_size, p, p_size, p_dash, ws);
  776|   194k|   }
  777|  15.9M|}
_ZN5Botan16bigint_mod_sub_nILm4EEEvPmPKmS3_S1_:
  648|  5.24M|inline void bigint_mod_sub_n(word t[], const word s[], const word mod[], word ws[]) {
  649|       |   // is t < s or not?
  650|  5.24M|   const auto is_lt = bigint_ct_is_lt(t, N, s, N);
  651|       |
  652|       |   // ws = p - s
  653|  5.24M|   const word borrow = bigint_sub3(ws, mod, N, s, N);
  654|       |
  655|       |   // Compute either (t - s) or (t + (p - s)) depending on mask
  656|  5.24M|   const word carry = bigint_cnd_addsub(is_lt, t, ws, s, N);
  657|       |
  658|  5.24M|   BOTAN_DEBUG_ASSERT(borrow == 0 && carry == 0);
  ------------------
  |  |   99|  5.24M|      do {                          \
  |  |  100|  5.24M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  659|  5.24M|   BOTAN_UNUSED(carry, borrow);
  ------------------
  |  |  118|  5.24M|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  660|  5.24M|}

_ZNK5Botan6PK_Ops22Verification_with_Hash13hash_functionEv:
   57|      8|      std::string hash_function() const final { return m_hash->name(); }
_ZN5Botan6PK_Ops22Verification_with_HashD2Ev:
   52|    438|      ~Verification_with_Hash() override = default;

_ZNK5Botan10PSS_Params10hash_algidEv:
   27|    117|      const AlgorithmIdentifier& hash_algid() const { return m_hash; }
_ZNK5Botan10PSS_Params9mgf_algidEv:
   29|     58|      const AlgorithmIdentifier& mgf_algid() const { return m_mgf; }
_ZNK5Botan10PSS_Params14mgf_hash_algidEv:
   31|     57|      const AlgorithmIdentifier& mgf_hash_algid() const { return m_mgf_hash; }
_ZNK5Botan10PSS_Params11salt_lengthEv:
   33|     56|      size_t salt_length() const { return m_salt_len; }
_ZNK5Botan10PSS_Params13trailer_fieldEv:
   35|     56|      size_t trailer_field() const { return m_trailer_field; }
_ZNK5Botan10PSS_Params13hash_functionEv:
   37|     60|      std::string hash_function() const { return hash_algid().oid().to_formatted_string(); }
_ZNK5Botan10PSS_Params12mgf_functionEv:
   39|     58|      std::string mgf_function() const { return mgf_algid().oid().to_formatted_string(); }
_ZN5Botan10PSS_ParamsC2INSt3__19allocatorIhEEEERKNS2_6vectorIhT_EE:
   25|     71|      PSS_Params(const std::vector<uint8_t, Alloc>& vec) : PSS_Params(vec.data(), vec.size()) {}

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

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

_ZN5Botan11checked_mulEmm:
   47|  6.55M|inline std::optional<size_t> checked_mul(size_t x, size_t y) {
   48|  6.55M|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   49|  6.55M|   size_t z;
   50|  6.55M|   if(__builtin_mul_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (50:7): [True: 0, False: 6.55M]
  ------------------
   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|  6.55M|   return z;
   62|  6.55M|}
_ZN5Botan11checked_addEmmPKci:
   30|   195k|inline size_t checked_add(size_t x, size_t y, const char* file, int line) {
   31|   195k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   32|   195k|   size_t z;
   33|   195k|   if(__builtin_add_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (33:7): [True: 0, False: 195k]
  ------------------
   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|   195k|   return z;
   45|   195k|}

_ZNK5Botan9SCAN_Name9algo_nameEv:
   44|  8.85k|      const std::string& algo_name() const { return m_alg_name; }
_ZNK5Botan9SCAN_Name9arg_countEv:
   49|  5.28k|      size_t arg_count() const { return m_args.size(); }
_ZNK5Botan9SCAN_Name17arg_count_betweenEmm:
   56|     56|      bool arg_count_between(size_t lower, size_t upper) const {
   57|     56|         return ((arg_count() >= lower) && (arg_count() <= upper));
  ------------------
  |  Branch (57:18): [True: 56, False: 0]
  |  Branch (57:44): [True: 56, False: 0]
  ------------------
   58|     56|      }

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

_ZNK5Botan7SHA_2244nameEv:
   33|     87|      std::string name() const override { return "SHA-224"; }
_ZNK5Botan7SHA_22413output_lengthEv:
   35|    174|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan7SHA_2564nameEv:
   73|    353|      std::string name() const override { return "SHA-256"; }
_ZNK5Botan7SHA_25613output_lengthEv:
   75|  14.5k|      size_t output_length() const override { return output_bytes; }

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

_ZNK5Botan7SHA_3844nameEv:
   32|     59|      std::string name() const override { return "SHA-384"; }
_ZNK5Botan7SHA_38413output_lengthEv:
   34|    113|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan7SHA_5124nameEv:
   72|     74|      std::string name() const override { return "SHA-512"; }
_ZNK5Botan7SHA_51213output_lengthEv:
   74|    147|      size_t output_length() const override { return output_bytes; }
_ZNK5Botan11SHA_512_2564nameEv:
  123|    530|      std::string name() const override { return "SHA-512-256"; }
_ZNK5Botan11SHA_512_25613output_lengthEv:
  125|  1.05k|      size_t output_length() const override { return output_bytes; }

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

_ZN5Botan9SIMD_4x325splatEj:
  129|  70.5k|      static SIMD_4x32 splat(uint32_t B) noexcept {
  130|  70.5k|#if defined(BOTAN_SIMD_USE_SSE2)
  131|  70.5k|         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|  70.5k|      }
_ZN5Botan9SIMD_4x32C2EDv2_x:
  597|  5.44M|      explicit SIMD_4x32(native_simd_type x) noexcept : m_simd(x) {}
_ZN5Botan9SIMD_4x327load_beEPKv:
  172|   206k|      static SIMD_4x32 load_be(const void* in) noexcept {
  173|   206k|#if defined(BOTAN_SIMD_USE_SSE2)
  174|   206k|         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|   206k|      }
_ZN5Botan9SIMD_4x327load_leEPKv:
  156|   206k|      static SIMD_4x32 load_le(const void* in) noexcept {
  157|   206k|#if defined(BOTAN_SIMD_USE_SSE2)
  158|   206k|         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|   206k|      }
_ZNK5Botan9SIMD_4x325bswapEv:
  474|   206k|      SIMD_4x32 bswap() const noexcept {
  475|   206k|#if defined(BOTAN_SIMD_USE_SSE2)
  476|       |
  477|   206k|         __m128i T = m_simd;
  478|   206k|         T = _mm_shufflehi_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
  479|   206k|         T = _mm_shufflelo_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
  480|   206k|         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|   206k|      }
_ZNK5Botan9SIMD_4x32plERKS0_:
  321|  1.03M|      SIMD_4x32 operator+(const SIMD_4x32& other) const noexcept {
  322|  1.03M|         SIMD_4x32 retval(*this);
  323|  1.03M|         retval += other;
  324|  1.03M|         return retval;
  325|  1.03M|      }
_ZN5Botan9SIMD_4x32pLERKS0_:
  363|  1.03M|      void operator+=(const SIMD_4x32& other) noexcept {
  364|  1.03M|#if defined(BOTAN_SIMD_USE_SSE2)
  365|  1.03M|         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.03M|      }
_ZNK5Botan9SIMD_4x328store_leEPj:
  187|  1.03M|      void store_le(uint32_t out[4]) const noexcept { this->store_le(reinterpret_cast<uint8_t*>(out)); }
_ZNK5Botan9SIMD_4x328store_leEPh:
  196|  1.03M|      void store_le(uint8_t out[]) const noexcept {
  197|  1.03M|#if defined(BOTAN_SIMD_USE_SSE2)
  198|       |
  199|  1.03M|         _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.03M|      }
_ZNK5Botan9SIMD_4x323rawEv:
  595|  5.17M|      native_simd_type raw() const noexcept { return m_simd; }
_ZNK5Botan9SIMD_4x3217shift_elems_rightILm1EEES0_v:
  514|   827k|      {
  515|   827k|#if defined(BOTAN_SIMD_USE_SSE2)
  516|   827k|         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|   827k|      }
_ZN5Botan9SIMD_4x32eOERKS0_:
  383|  3.31M|      void operator^=(const SIMD_4x32& other) noexcept {
  384|  3.31M|#if defined(BOTAN_SIMD_USE_SSE2)
  385|  3.31M|         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|  3.31M|      }
_ZNK5Botan9SIMD_4x3216shift_elems_leftILm3EEES0_v:
  493|   827k|      {
  494|   827k|#if defined(BOTAN_SIMD_USE_SSE2)
  495|   827k|         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|   827k|      }
_ZNK5Botan9SIMD_4x324rotlILm1EEES0_v:
  281|   827k|      {
  282|   827k|#if defined(BOTAN_SIMD_USE_SSE2)
  283|       |
  284|   827k|         return SIMD_4x32(_mm_or_si128(_mm_slli_epi32(m_simd, static_cast<int>(ROT)),
  285|   827k|                                       _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|   827k|      }
_ZNK5Botan9SIMD_4x324rotlILm2EEES0_v:
  281|   827k|      {
  282|   827k|#if defined(BOTAN_SIMD_USE_SSE2)
  283|       |
  284|   827k|         return SIMD_4x32(_mm_or_si128(_mm_slli_epi32(m_simd, static_cast<int>(ROT)),
  285|   827k|                                       _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|   827k|      }
_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|  22.4k|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|  22.4k|   multimap.insert(std::make_pair(key, value));
  111|  22.4k|}
_ZN5Botan15multimap_insertINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEvRNS1_8multimapIT_T0_NS1_4lessIS9_EENS5_INS1_4pairIKS9_SA_EEEEEERSE_RKSA_:
  109|    172|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|    172|   multimap.insert(std::make_pair(key, value));
  111|    172|}
_ZN5Botan12BufferSlicerC2ENSt3__14spanIKhLm18446744073709551615EEE:
  143|  65.8k|      BufferSlicer(std::span<const uint8_t> buffer) : m_remaining(buffer) {}
_ZN5Botan12BufferSlicer4takeEm:
  155|   156k|      std::span<const uint8_t> take(const size_t count) {
  156|   156k|         BOTAN_STATE_CHECK(remaining() >= count);
  ------------------
  |  |   42|   156k|   do {                                                         \
  |  |   43|   156k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 156k]
  |  |  ------------------
  |  |   44|   156k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|   156k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|   156k|         auto result = m_remaining.first(count);
  158|   156k|         m_remaining = m_remaining.subspan(count);
  159|   156k|         return result;
  160|   156k|      }
_ZNK5Botan12BufferSlicer9remainingEv:
  184|   239k|      size_t remaining() const { return m_remaining.size(); }
_ZNK5Botan12BufferSlicer5emptyEv:
  186|  65.5k|      bool empty() const { return m_remaining.empty(); }
_ZN5Botan13BufferStufferC2ENSt3__14spanIhLm18446744073709551615EEE:
  201|    390|      BufferStuffer(std::span<uint8_t> buffer) : m_buffer(buffer) {}
_ZN5Botan13BufferStuffer4nextEm:
  207|  1.90k|      std::span<uint8_t> next(size_t bytes) {
  208|  1.90k|         BOTAN_STATE_CHECK(m_buffer.size() >= bytes);
  ------------------
  |  |   42|  1.90k|   do {                                                         \
  |  |   43|  1.90k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 1.90k]
  |  |  ------------------
  |  |   44|  1.90k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|  1.90k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  209|       |
  210|  1.90k|         auto result = m_buffer.first(bytes);
  211|  1.90k|         m_buffer = m_buffer.subspan(bytes);
  212|  1.90k|         return result;
  213|  1.90k|      }
_ZN5Botan13BufferStuffer6appendENSt3__14spanIKhLm18446744073709551615EEE:
  234|    765|      void append(std::span<const uint8_t> buffer) {
  235|    765|         auto sink = next(buffer.size());
  236|    765|         std::copy(buffer.begin(), buffer.end(), sink.begin());
  237|    765|      }
_ZN5Botan13BufferStuffer6appendEhm:
  239|  1.14k|      void append(uint8_t b, size_t repeat = 1) {
  240|  1.14k|         auto sink = next(repeat);
  241|  1.14k|         std::fill(sink.begin(), sink.end(), b);
  242|  1.14k|      }
_ZNK5Botan13BufferStuffer4fullEv:
  244|    375|      bool full() const { return m_buffer.empty(); }
_ZNK5Botan13BufferStuffer18remaining_capacityEv:
  246|    390|      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|    607|void multimap_insert(std::multimap<K, V>& multimap, const K& key, const V& value) {
  110|    607|   multimap.insert(std::make_pair(key, value));
  111|    607|}

_ZNK5Botan8Streebog13output_lengthEv:
   23|    453|      size_t output_length() const override { return m_output_bits / 8; }

_ZN5Botan21Allocator_InitializerC2Ev:
   40|      1|      Allocator_Initializer() { initialize_allocator(); }

_ZN5Botan11ASN1_ObjectD2Ev:
  120|   614k|      virtual ~ASN1_Object() = default;
_ZN5Botan10BER_ObjectC2Ev:
  128|   525k|      BER_Object() : m_type_tag(ASN1_Type::NoObject), m_class_tag(ASN1_Class::Universal) {}
_ZNK5Botan10BER_Object6is_setEv:
  138|   746k|      bool is_set() const { return m_type_tag != ASN1_Type::NoObject; }
_ZNK5Botan10BER_Object7taggingEv:
  140|   377k|      uint32_t tagging() const { return type_tag() | class_tag(); }
_ZNK5Botan10BER_Object8type_tagEv:
  142|   377k|      ASN1_Type type_tag() const { return m_type_tag; }
_ZNK5Botan10BER_Object9class_tagEv:
  144|   377k|      ASN1_Class class_tag() const { return m_class_tag; }
_ZNK5Botan10BER_Object4typeEv:
  146|  59.7k|      ASN1_Type type() const { return m_type_tag; }
_ZNK5Botan10BER_Object9get_classEv:
  148|    711|      ASN1_Class get_class() const { return m_class_tag; }
_ZNK5Botan10BER_Object4bitsEv:
  150|  5.12M|      const uint8_t* bits() const { return m_value.data(); }
_ZNK5Botan10BER_Object6lengthEv:
  152|  10.8M|      size_t length() const { return m_value.size(); }
_ZN5Botan10BER_Object12mutable_bitsEm:
  169|   317k|      uint8_t* mutable_bits(size_t length) {
  170|   317k|         m_value.resize(length);
  171|   317k|         return m_value.data();
  172|   317k|      }
_ZN5Botan3OIDC2ESt16initializer_listIjE:
  229|  14.8k|      explicit OID(std::initializer_list<uint32_t> init) : m_id(init) {
  230|  14.8k|         BOTAN_ARG_CHECK(m_id.size() > 2 && m_id[0] <= 2 && (m_id[0] != 2 || m_id[1] <= 39), "Invalid OID");
  ------------------
  |  |   30|  14.8k|   do {                                                          \
  |  |   31|  74.5k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 14.8k, False: 0]
  |  |  |  Branch (31:12): [True: 14.8k, False: 0]
  |  |  |  Branch (31:12): [True: 14.7k, False: 103]
  |  |  |  Branch (31:12): [True: 103, False: 0]
  |  |  ------------------
  |  |   32|  14.8k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  14.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  231|  14.8k|      }
_ZNK5Botan3OID5emptyEv:
  265|   341k|      bool empty() const { return m_id.empty(); }
_ZNK5Botan3OID9has_valueEv:
  271|    669|      bool has_value() const { return (m_id.empty() == false); }
_ZNK5Botan3OID14get_componentsEv:
  277|   250k|      const std::vector<uint32_t>& get_components() const { return m_id; }
_ZNK5Botan3OIDeqERKS0_:
  309|   606k|      bool operator==(const OID& other) const { return m_id == other.m_id; }
_ZNK5Botan11ASN1_String5valueEv:
  415|  24.9k|      const std::string& value() const { return m_utf8_str; }
_ZNK5Botan11ASN1_String4sizeEv:
  417|    634|      size_t size() const { return value().size(); }
_ZNK5Botan11ASN1_String5emptyEv:
  419|  23.0k|      bool empty() const { return m_utf8_str.empty(); }
_ZNK5Botan19AlgorithmIdentifier3oidEv:
  455|  21.3k|      const OID& oid() const { return m_oid; }
_ZNK5Botan19AlgorithmIdentifier10parametersEv:
  457|  6.93k|      const std::vector<uint8_t>& parameters() const { return m_parameters; }
_ZNK5Botan19AlgorithmIdentifier20parameters_are_emptyEv:
  469|  10.6k|      bool parameters_are_empty() const { return m_parameters.empty(); }
_ZNK5Botan19AlgorithmIdentifier28parameters_are_null_or_emptyEv:
  471|  10.2k|      bool parameters_are_null_or_empty() const { return parameters_are_empty() || parameters_are_null(); }
  ------------------
  |  Branch (471:58): [True: 3.36k, False: 6.86k]
  |  Branch (471:84): [True: 6.48k, False: 372]
  ------------------
_ZN5BotanorENS_10ASN1_ClassES0_:
   78|   184k|inline ASN1_Class operator|(ASN1_Class x, ASN1_Class y) {
   79|   184k|   return static_cast<ASN1_Class>(static_cast<uint32_t>(x) | static_cast<uint32_t>(y));
   80|   184k|}
_ZN5BotanorENS_9ASN1_TypeENS_10ASN1_ClassE:
   82|   377k|inline uint32_t operator|(ASN1_Type x, ASN1_Class y) {
   83|   377k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   84|   377k|}
_ZN5BotanorENS_10ASN1_ClassENS_9ASN1_TypeE:
   86|  59.5k|inline uint32_t operator|(ASN1_Class x, ASN1_Type y) {
   87|  59.5k|   return static_cast<uint32_t>(x) | static_cast<uint32_t>(y);
   88|  59.5k|}
_ZN5BotanneERKNS_3OIDES2_:
  326|  14.3k|inline bool operator!=(const OID& a, const OID& b) {
  327|  14.3k|   return !(a == b);
  328|  14.3k|}
_ZN5Botan11ASN1_ObjectC2ERKS0_:
  118|   264k|      ASN1_Object(const ASN1_Object&) = default;
_ZN5Botan11ASN1_ObjectaSERKS0_:
  119|    278|      ASN1_Object& operator=(const ASN1_Object&) = default;
_ZN5Botan11ASN1_ObjectC2Ev:
  117|   349k|      ASN1_Object() = default;
_ZN5Botan19AlgorithmIdentifierC2Ev:
  447|  26.5k|      AlgorithmIdentifier() = default;
_ZN5Botan3OIDC2Ev:
  218|  65.5k|      explicit OID() = default;
_ZN5Botan9ASN1_TimeC2Ev:
  362|  12.3k|      ASN1_Time() = default;
_ZN5Botan10BER_ObjectaSEOS0_:
  136|  77.5k|      BER_Object& operator=(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectC2EOS0_:
  134|   148k|      BER_Object(BER_Object&& other) = default;
_ZN5Botan10BER_ObjectaSERKS0_:
  132|    565|      BER_Object& operator=(const BER_Object& other) = default;

_ZN5Botan12ignore_paramIRmEEvOT_:
  111|  11.5M|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRhEEEvDpOT_:
  114|  23.4k|void ignore_params(T&&... args) {
  115|  23.4k|   (ignore_param(args), ...);
  116|  23.4k|}
_ZN5Botan12ignore_paramIRhEEvOT_:
  111|  23.4k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRmEEEvDpOT_:
  114|  11.5M|void ignore_params(T&&... args) {
  115|  11.5M|   (ignore_param(args), ...);
  116|  11.5M|}
_ZN5Botan13ignore_paramsIJRKmEEEvDpOT_:
  114|   177k|void ignore_params(T&&... args) {
  115|   177k|   (ignore_param(args), ...);
  116|   177k|}
_ZN5Botan12ignore_paramIRKmEEvOT_:
  111|  10.7M|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRKmS2_EEEvDpOT_:
  114|  5.27M|void ignore_params(T&&... args) {
  115|  5.27M|   (ignore_param(args), ...);
  116|  5.27M|}
_ZN5Botan13ignore_paramsIJRPKmRmEEEvDpOT_:
  114|  3.48k|void ignore_params(T&&... args) {
  115|  3.48k|   (ignore_param(args), ...);
  116|  3.48k|}
_ZN5Botan12ignore_paramIRPKmEEvOT_:
  111|  3.48k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRNSt3__16vectorImNS_16secure_allocatorImEEEEEEEvDpOT_:
  114|   318k|void ignore_params(T&&... args) {
  115|   318k|   (ignore_param(args), ...);
  116|   318k|}
_ZN5Botan12ignore_paramIRNSt3__16vectorImNS_16secure_allocatorImEEEEEEvOT_:
  111|   318k|void ignore_param(T&&) {}
_ZN5Botan13ignore_paramsIJRlEEEvDpOT_:
  114|   262k|void ignore_params(T&&... args) {
  115|   262k|   (ignore_param(args), ...);
  116|   262k|}
_ZN5Botan12ignore_paramIRlEEvOT_:
  111|   262k|void ignore_param(T&&) {}

_ZN5Botan11BER_Decoder15decode_optionalImEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  7.12k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  7.12k|   BER_Object obj = get_next_object();
  319|       |
  320|  7.12k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 3.87k, False: 3.25k]
  ------------------
  321|  3.87k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 3.65k, False: 218]
  ------------------
  322|  3.65k|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|  3.65k|      } else {
  324|    218|         push_back(std::move(obj));
  325|    218|         decode(out, type_tag, class_tag);
  326|    218|      }
  327|  3.87k|   } else {
  328|  3.25k|      out = default_value;
  329|  3.25k|      push_back(std::move(obj));
  330|  3.25k|   }
  331|       |
  332|  7.12k|   return (*this);
  333|  7.12k|}
_ZN5Botan11BER_Decoder6decodeERm:
  181|  3.78k|      BER_Decoder& decode(size_t& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectE:
   57|  3.78k|      BER_Decoder(BER_Object&& obj) : BER_Decoder(std::move(obj), nullptr) {}
_ZN5Botan11BER_DecoderC2ENSt3__14spanIKhLm18446744073709551615EEE:
   32|  2.26k|      BER_Decoder(std::span<const uint8_t> buf) : BER_Decoder(buf.data(), buf.size()) {}
_ZN5Botan11BER_DecoderC2ERKNS_10BER_ObjectE:
   52|  5.19k|      BER_Decoder(const BER_Object& obj) : BER_Decoder(obj.bits(), obj.length()) {}
_ZN5Botan11BER_Decoder8get_nextERNS_10BER_ObjectE:
   69|  10.5k|      BER_Decoder& get_next(BER_Object& ber) {
   70|  10.5k|         ber = get_next_object();
   71|  10.5k|         return (*this);
   72|  10.5k|      }
_ZN5Botan11BER_Decoder14start_sequenceEv:
  113|   102k|      BER_Decoder start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder9start_setEv:
  115|  23.2k|      BER_Decoder start_set() { return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder22start_context_specificEj:
  117|    487|      BER_Decoder start_context_specific(uint32_t tag) {
  118|    487|         return start_cons(ASN1_Type(tag), ASN1_Class::ContextSpecific);
  119|    487|      }
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntE:
  186|  10.2k|      BER_Decoder& decode(BigInt& out) { return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }
_ZN5Botan11BER_Decoder6decodeINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeE:
  198|  27.4k|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  199|  27.4k|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  200|  27.4k|      }
_ZN5Botan11BER_Decoder9raw_bytesINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EE:
  162|  39.8k|      BER_Decoder& raw_bytes(std::vector<uint8_t, Alloc>& out) {
  163|  39.8k|         out.clear();
  164|  39.8k|         uint8_t buf;
  165|  4.20M|         while(m_source->read_byte(buf)) {
  ------------------
  |  Branch (165:16): [True: 4.16M, False: 39.8k]
  ------------------
  166|  4.16M|            out.push_back(buf);
  167|  4.16M|         }
  168|  39.8k|         return (*this);
  169|  39.8k|      }
_ZN5Botan11BER_Decoder15decode_optionalIbEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS3_:
  317|  11.9k|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|  11.9k|   BER_Object obj = get_next_object();
  319|       |
  320|  11.9k|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 2.12k, False: 9.81k]
  ------------------
  321|  2.12k|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 0, False: 2.12k]
  ------------------
  322|      0|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|  2.12k|      } else {
  324|  2.12k|         push_back(std::move(obj));
  325|  2.12k|         decode(out, type_tag, class_tag);
  326|  2.12k|      }
  327|  9.81k|   } else {
  328|  9.81k|      out = default_value;
  329|  9.81k|      push_back(std::move(obj));
  330|  9.81k|   }
  331|       |
  332|  11.9k|   return (*this);
  333|  11.9k|}
_ZN5Botan11BER_Decoder22decode_optional_stringINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeEjNS_10ASN1_ClassE:
  275|  10.9k|                                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  276|  10.9k|         BER_Object obj = get_next_object();
  277|       |
  278|  10.9k|         ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
  279|       |
  280|  10.9k|         if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (280:13): [True: 276, False: 10.6k]
  ------------------
  281|    276|            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (281:16): [True: 0, False: 276]
  ------------------
  282|      0|               BER_Decoder(std::move(obj)).decode(out, real_type).verify_end();
  283|    276|            } else {
  284|    276|               push_back(std::move(obj));
  285|    276|               decode(out, real_type, type_tag, class_tag);
  286|    276|            }
  287|  10.6k|         } else {
  288|  10.6k|            out.clear();
  289|  10.6k|            push_back(std::move(obj));
  290|  10.6k|         }
  291|       |
  292|  10.9k|         return (*this);
  293|  10.9k|      }
_ZN5Botan11BER_Decoder11decode_listINS_3OIDEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    385|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    385|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|  1.00k|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 618, False: 385]
  ------------------
  368|    618|      T value;
  369|    618|      list.decode(value);
  370|    618|      vec.push_back(std::move(value));
  371|    618|   }
  372|       |
  373|    385|   list.end_cons();
  374|       |
  375|    385|   return (*this);
  376|    385|}
_ZN5Botan11BER_Decoder11decode_listINS_14GeneralSubtreeEEERS0_RNSt3__16vectorIT_NS4_9allocatorIS6_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    335|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    335|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|    873|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 538, False: 335]
  ------------------
  368|    538|      T value;
  369|    538|      list.decode(value);
  370|    538|      vec.push_back(std::move(value));
  371|    538|   }
  372|       |
  373|    335|   list.end_cons();
  374|       |
  375|    335|   return (*this);
  376|    335|}
x509_ext.cpp:_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension12_GLOBAL__N_118Policy_InformationEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    329|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    329|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|    701|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 372, False: 329]
  ------------------
  368|    372|      T value;
  369|    372|      list.decode(value);
  370|    372|      vec.push_back(std::move(value));
  371|    372|   }
  372|       |
  373|    329|   list.end_cons();
  374|       |
  375|    329|   return (*this);
  376|    329|}
_ZN5Botan11BER_Decoder11decode_listINS_14Cert_Extension23CRL_Distribution_Points18Distribution_PointEEERS0_RNSt3__16vectorIT_NS6_9allocatorIS8_EEEENS_9ASN1_TypeENS_10ASN1_ClassE:
  364|    513|BER_Decoder& BER_Decoder::decode_list(std::vector<T>& vec, ASN1_Type type_tag, ASN1_Class class_tag) {
  365|    513|   BER_Decoder list = start_cons(type_tag, class_tag);
  366|       |
  367|    967|   while(list.more_items()) {
  ------------------
  |  Branch (367:10): [True: 454, False: 513]
  ------------------
  368|    454|      T value;
  369|    454|      list.decode(value);
  370|    454|      vec.push_back(std::move(value));
  371|    454|   }
  372|       |
  373|    513|   list.end_cons();
  374|       |
  375|    513|   return (*this);
  376|    513|}
_ZN5Botan11BER_Decoder24decode_optional_implicitINS_15AlternativeNameEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassES6_S7_RKS4_:
  344|    398|                                                   const T& default_value) {
  345|    398|   BER_Object obj = get_next_object();
  346|       |
  347|    398|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (347:7): [True: 308, False: 90]
  ------------------
  348|    308|      obj.set_tagging(real_type, real_class);
  349|    308|      push_back(std::move(obj));
  350|    308|      decode(out, real_type, real_class);
  351|    308|   } else {
  352|       |      // Not what we wanted, push it back on the stream
  353|     90|      out = default_value;
  354|     90|      push_back(std::move(obj));
  355|     90|   }
  356|       |
  357|    398|   return (*this);
  358|    398|}
_ZN5Botan11BER_Decoder6decodeINS_16secure_allocatorIhEEEERS0_RNSt3__16vectorIhT_EENS_9ASN1_TypeE:
  198|    534|      BER_Decoder& decode(std::vector<uint8_t, Alloc>& out, ASN1_Type real_type) {
  199|    534|         return decode(out, real_type, real_type, ASN1_Class::Universal);
  200|    534|      }
_ZN5Botan11BER_Decoder16decode_and_checkINS_3OIDEEERS0_RKT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  257|     32|      BER_Decoder& decode_and_check(const T& expected, std::string_view error_msg) {
  258|     32|         T actual;
  259|     32|         decode(actual);
  260|       |
  261|     32|         if(actual != expected) {
  ------------------
  |  Branch (261:13): [True: 13, False: 19]
  ------------------
  262|     13|            throw Decoding_Error(error_msg);
  263|     13|         }
  264|       |
  265|     19|         return (*this);
  266|     32|      }
_ZN5Botan11BER_Decoder16decode_and_checkImEERS0_RKT_NSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  257|     54|      BER_Decoder& decode_and_check(const T& expected, std::string_view error_msg) {
  258|     54|         T actual;
  259|     54|         decode(actual);
  260|       |
  261|     54|         if(actual != expected) {
  ------------------
  |  Branch (261:13): [True: 22, False: 32]
  ------------------
  262|     22|            throw Decoding_Error(error_msg);
  263|     22|         }
  264|       |
  265|     32|         return (*this);
  266|     54|      }
_ZN5Botan11BER_Decoder15decode_optionalINS_19AlgorithmIdentifierEEERS0_RT_NS_9ASN1_TypeENS_10ASN1_ClassERKS4_:
  317|    131|BER_Decoder& BER_Decoder::decode_optional(T& out, ASN1_Type type_tag, ASN1_Class class_tag, const T& default_value) {
  318|    131|   BER_Object obj = get_next_object();
  319|       |
  320|    131|   if(obj.is_a(type_tag, class_tag)) {
  ------------------
  |  Branch (320:7): [True: 128, False: 3]
  ------------------
  321|    128|      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
  ------------------
  |  Branch (321:10): [True: 128, False: 0]
  ------------------
  322|    128|         BER_Decoder(std::move(obj)).decode(out).verify_end();
  323|    128|      } else {
  324|      0|         push_back(std::move(obj));
  325|      0|         decode(out, type_tag, class_tag);
  326|      0|      }
  327|    128|   } else {
  328|      3|      out = default_value;
  329|      3|      push_back(std::move(obj));
  330|      3|   }
  331|       |
  332|    131|   return (*this);
  333|    131|}
_ZN5Botan11BER_Decoder22decode_optional_stringINSt3__19allocatorIhEEEERS0_RNS2_6vectorIhT_EENS_9ASN1_TypeESA_NS_10ASN1_ClassE:
  299|     11|                                          ASN1_Class class_tag = ASN1_Class::ContextSpecific) {
  300|     11|         return decode_optional_string(out, real_type, static_cast<uint32_t>(expected_tag), class_tag);
  301|     11|      }

_ZN5Botan6BigIntD2Ev:
  148|  7.29M|      ~BigInt() { const_time_unpoison(); }
_ZNK5Botan6BigInt19const_time_unpoisonEv:
  726|  7.29M|      void const_time_unpoison() const {}
_ZN5Botan6BigInt4zeroEv:
   45|  33.5k|      static BigInt zero() { return BigInt(); }
_ZN5Botan6BigIntC2EOS0_:
  146|  91.2k|      BigInt(BigInt&& other) { this->swap(other); }
_ZN5Botan6BigIntaSEOS0_:
  153|  2.45M|      BigInt& operator=(BigInt&& other) {
  154|  2.45M|         if(this != &other) {
  ------------------
  |  Branch (154:13): [True: 2.45M, False: 0]
  ------------------
  155|  2.45M|            this->swap(other);
  156|  2.45M|         }
  157|       |
  158|  2.45M|         return (*this);
  159|  2.45M|      }
_ZN5Botan6BigInt4swapERS0_:
  170|  5.79M|      void swap(BigInt& other) {
  171|  5.79M|         m_data.swap(other.m_data);
  172|  5.79M|         std::swap(m_signedness, other.m_signedness);
  173|  5.79M|      }
_ZN5Botan6BigInt8swap_regERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  177|  2.61M|      void swap_reg(secure_vector<word>& reg) {
  178|  2.61M|         m_data.swap(reg);
  179|       |         // sign left unchanged
  180|  2.61M|      }
_ZN5Botan6BigIntpLERKS0_:
  186|  48.5k|      BigInt& operator+=(const BigInt& y) { return add(y.data(), y.sig_words(), y.sign()); }
_ZN5Botan6BigIntpLEm:
  192|    820|      BigInt& operator+=(word y) { return add(&y, 1, Positive); }
_ZN5Botan6BigIntmIERKS0_:
  198|  47.2k|      BigInt& operator-=(const BigInt& y) { return sub(y.data(), y.sig_words(), y.sign()); }
_ZN5Botan6BigInt3subEPKmmNS0_4SignE:
  292|  47.2k|      BigInt& sub(const word y[], size_t y_words, Sign sign) {
  293|  47.2k|         return add(y, y_words, sign == Positive ? Negative : Positive);
  ------------------
  |  Branch (293:33): [True: 47.2k, False: 0]
  ------------------
  294|  47.2k|      }
_ZN5Botan6BigInt5clearEv:
  370|  29.2k|      void clear() {
  371|  29.2k|         m_data.set_to_zero();
  372|  29.2k|         m_signedness = Positive;
  373|  29.2k|      }
_ZNK5Botan6BigInt7is_evenEv:
  410|  8.10k|      bool is_even() const { return (get_bit(0) == 0); }
_ZNK5Botan6BigInt6is_oddEv:
  416|  2.40k|      bool is_odd() const { return (get_bit(0) == 1); }
_ZNK5Botan6BigInt10is_nonzeroEv:
  422|  11.3k|      bool is_nonzero() const { return (!is_zero()); }
_ZNK5Botan6BigInt7is_zeroEv:
  428|  2.68M|      bool is_zero() const { return (sig_words() == 0); }
_ZN5Botan6BigInt7set_bitEm:
  434|  6.73k|      void set_bit(size_t n) { conditionally_set_bit(n, true); }
_ZN5Botan6BigInt21conditionally_set_bitEmb:
  444|  12.2M|      void conditionally_set_bit(size_t n, bool set_it) {
  445|  12.2M|         const size_t which = n / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  12.2M|#define BOTAN_MP_WORD_BITS 64
  ------------------
  446|  12.2M|         const word mask = static_cast<word>(set_it) << (n % BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|  12.2M|#define BOTAN_MP_WORD_BITS 64
  ------------------
  447|  12.2M|         m_data.set_word_at(which, word_at(which) | mask);
  448|  12.2M|      }
_ZN5Botan6BigInt9mask_bitsEm:
  460|   329k|      void mask_bits(size_t n) { m_data.mask_bits(n); }
_ZNK5Botan6BigInt7get_bitEm:
  467|  8.98M|      bool get_bit(size_t n) const { return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1); }
  ------------------
  |  |   50|  8.98M|#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|  8.98M|#define BOTAN_MP_WORD_BITS 64
  ------------------
_ZNK5Botan6BigInt7word_atEm:
  518|  22.5M|      word word_at(size_t n) const { return m_data.get_word_at(n); }
_ZN5Botan6BigInt11set_word_atEmm:
  520|  4.87M|      void set_word_at(size_t i, word w) { m_data.set_word_at(i, w); }
_ZN5Botan6BigInt9set_wordsEPKmm:
  522|   400k|      void set_words(const word w[], size_t len) { m_data.set_words(w, len); }
_ZNK5Botan6BigInt11is_negativeEv:
  528|  22.7M|      bool is_negative() const { return (sign() == Negative); }
_ZNK5Botan6BigInt11is_positiveEv:
  534|   197k|      bool is_positive() const { return (sign() == Positive); }
_ZNK5Botan6BigInt4signEv:
  540|  23.6M|      Sign sign() const { return (m_signedness); }
_ZNK5Botan6BigInt12reverse_signEv:
  545|  22.8k|      Sign reverse_sign() const {
  546|  22.8k|         if(sign() == Positive) {
  ------------------
  |  Branch (546:13): [True: 22.8k, False: 0]
  ------------------
  547|  22.8k|            return Negative;
  548|  22.8k|         }
  549|      0|         return Positive;
  550|  22.8k|      }
_ZN5Botan6BigInt9flip_signEv:
  555|  1.90k|      void flip_sign() { set_sign(reverse_sign()); }
_ZN5Botan6BigInt8set_signENS0_4SignE:
  561|   294k|      void set_sign(Sign sign) {
  562|   294k|         if(sign == Negative && is_zero()) {
  ------------------
  |  Branch (562:13): [True: 2.33k, False: 292k]
  |  Branch (562:33): [True: 0, False: 2.33k]
  ------------------
  563|      0|            sign = Positive;
  564|      0|         }
  565|       |
  566|   294k|         m_signedness = sign;
  567|   294k|      }
_ZNK5Botan6BigInt4sizeEv:
  578|   100M|      size_t size() const { return m_data.size(); }
_ZNK5Botan6BigInt9sig_wordsEv:
  584|  12.7M|      size_t sig_words() const { return m_data.sig_words(); }
_ZN5Botan6BigInt12mutable_dataEv:
  609|  52.9M|      word* mutable_data() { return m_data.mutable_data(); }
_ZNK5Botan6BigInt4dataEv:
  615|  73.5M|      const word* data() const { return m_data.const_data(); }
_ZN5Botan6BigInt15get_word_vectorEv:
  620|  1.75M|      secure_vector<word>& get_word_vector() { return m_data.mutable_vector(); }
_ZNK5Botan6BigInt7grow_toEm:
  631|  22.0M|      void grow_to(size_t n) const { m_data.grow_to(n); }
_ZNK5Botan6BigInt17const_time_poisonEv:
  724|    886|      void const_time_poison() const {}
_ZN5Botan6BigInt10power_of_2Em:
  742|  2.09k|      static BigInt power_of_2(size_t n) {
  743|  2.09k|         BigInt b;
  744|  2.09k|         b.set_bit(n);
  745|  2.09k|         return b;
  746|  2.09k|      }
_ZN5Botan6BigInt6encodeERKS0_:
  753|  6.44k|      static std::vector<uint8_t> encode(const BigInt& n) {
  754|  6.44k|         std::vector<uint8_t> output(n.bytes());
  755|  6.44k|         n.binary_encode(output.data());
  756|  6.44k|         return output;
  757|  6.44k|      }
_ZN5Botan6BigInt6decodeEPKhm:
  776|    928|      static BigInt decode(const uint8_t buf[], size_t length) { return BigInt(buf, length); }
_ZN5Botan6BigInt4Data12mutable_dataEv:
  834|  53.1M|            word* mutable_data() {
  835|  53.1M|               invalidate_sig_words();
  836|  53.1M|               return m_reg.data();
  837|  53.1M|            }
_ZNK5Botan6BigInt4Data10const_dataEv:
  839|  73.5M|            const word* const_data() const { return m_reg.data(); }
_ZN5Botan6BigInt4Data14mutable_vectorEv:
  841|  1.75M|            secure_vector<word>& mutable_vector() {
  842|  1.75M|               invalidate_sig_words();
  843|  1.75M|               return m_reg;
  844|  1.75M|            }
_ZNK5Botan6BigInt4Data11get_word_atEm:
  848|  22.5M|            word get_word_at(size_t n) const {
  849|  22.5M|               if(n < m_reg.size()) {
  ------------------
  |  Branch (849:19): [True: 22.5M, False: 8.00k]
  ------------------
  850|  22.5M|                  return m_reg[n];
  851|  22.5M|               }
  852|  8.00k|               return 0;
  853|  22.5M|            }
_ZN5Botan6BigInt4Data11set_word_atEmm:
  855|  17.1M|            void set_word_at(size_t i, word w) {
  856|  17.1M|               invalidate_sig_words();
  857|  17.1M|               if(i >= m_reg.size()) {
  ------------------
  |  Branch (857:19): [True: 4.88M, False: 12.2M]
  ------------------
  858|  4.88M|                  if(w == 0) {
  ------------------
  |  Branch (858:22): [True: 4.86M, False: 19.6k]
  ------------------
  859|  4.86M|                     return;
  860|  4.86M|                  }
  861|  19.6k|                  grow_to(i + 1);
  862|  19.6k|               }
  863|  12.2M|               m_reg[i] = w;
  864|  12.2M|            }
_ZN5Botan6BigInt4Data9set_wordsEPKmm:
  866|   400k|            void set_words(const word w[], size_t len) {
  867|   400k|               invalidate_sig_words();
  868|   400k|               m_reg.assign(w, w + len);
  869|   400k|            }
_ZN5Botan6BigInt4Data11set_to_zeroEv:
  871|  29.2k|            void set_to_zero() {
  872|  29.2k|               m_reg.resize(m_reg.capacity());
  873|  29.2k|               clear_mem(m_reg.data(), m_reg.size());
  874|  29.2k|               m_sig_words = 0;
  875|  29.2k|            }
_ZN5Botan6BigInt4Data9mask_bitsEm:
  883|   329k|            void mask_bits(size_t n) {
  884|   329k|               if(n == 0) {
  ------------------
  |  Branch (884:19): [True: 0, False: 329k]
  ------------------
  885|      0|                  return set_to_zero();
  886|      0|               }
  887|       |
  888|   329k|               const size_t top_word = n / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|   329k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  889|       |
  890|       |               // if(top_word < sig_words()) ?
  891|   329k|               if(top_word < size()) {
  ------------------
  |  Branch (891:19): [True: 328k, False: 1.18k]
  ------------------
  892|   328k|                  const word mask = (static_cast<word>(1) << (n % BOTAN_MP_WORD_BITS)) - 1;
  ------------------
  |  |   50|   328k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  893|   328k|                  const size_t len = size() - (top_word + 1);
  894|   328k|                  if(len > 0) {
  ------------------
  |  Branch (894:22): [True: 328k, False: 0]
  ------------------
  895|   328k|                     clear_mem(&m_reg[top_word + 1], len);
  896|   328k|                  }
  897|   328k|                  m_reg[top_word] &= mask;
  898|   328k|                  invalidate_sig_words();
  899|   328k|               }
  900|   329k|            }
_ZNK5Botan6BigInt4Data7grow_toEm:
  902|  22.1M|            void grow_to(size_t n) const {
  903|  22.1M|               if(n > size()) {
  ------------------
  |  Branch (903:19): [True: 3.73M, False: 18.3M]
  ------------------
  904|  3.73M|                  if(n <= m_reg.capacity()) {
  ------------------
  |  Branch (904:22): [True: 412k, False: 3.32M]
  ------------------
  905|   412k|                     m_reg.resize(n);
  906|  3.32M|                  } else {
  907|  3.32M|                     m_reg.resize(n + (8 - (n % 8)));
  908|  3.32M|                  }
  909|  3.73M|               }
  910|  22.1M|            }
_ZNK5Botan6BigInt4Data4sizeEv:
  912|   123M|            size_t size() const { return m_reg.size(); }
_ZN5Botan6BigInt4Data4swapERS1_:
  921|  5.79M|            void swap(Data& other) {
  922|  5.79M|               m_reg.swap(other.m_reg);
  923|  5.79M|               std::swap(m_sig_words, other.m_sig_words);
  924|  5.79M|            }
_ZN5Botan6BigInt4Data4swapERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  926|  2.64M|            void swap(secure_vector<word>& reg) {
  927|  2.64M|               m_reg.swap(reg);
  928|  2.64M|               invalidate_sig_words();
  929|  2.64M|            }
_ZNK5Botan6BigInt4Data20invalidate_sig_wordsEv:
  931|  75.3M|            void invalidate_sig_words() const { m_sig_words = sig_words_npos; }
_ZNK5Botan6BigInt4Data9sig_wordsEv:
  933|  12.7M|            size_t sig_words() const {
  934|  12.7M|               if(m_sig_words == sig_words_npos) {
  ------------------
  |  Branch (934:19): [True: 4.58M, False: 8.20M]
  ------------------
  935|  4.58M|                  m_sig_words = calc_sig_words();
  936|  8.20M|               } else {
  937|  8.20M|                  BOTAN_DEBUG_ASSERT(m_sig_words == calc_sig_words());
  ------------------
  |  |   99|  8.20M|      do {                          \
  |  |  100|  8.20M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  938|  8.20M|               }
  939|  12.7M|               return m_sig_words;
  940|  12.7M|            }
_ZN5BotanplERKNS_6BigIntES2_:
  958|  5.85k|inline BigInt operator+(const BigInt& x, const BigInt& y) {
  959|  5.85k|   return BigInt::add2(x, y.data(), y.sig_words(), y.sign());
  960|  5.85k|}
_ZN5BotanplERKNS_6BigIntEm:
  962|  1.31k|inline BigInt operator+(const BigInt& x, word y) {
  963|  1.31k|   return BigInt::add2(x, &y, 1, BigInt::Positive);
  964|  1.31k|}
_ZN5BotanmiERKNS_6BigIntES2_:
  970|  20.9k|inline BigInt operator-(const BigInt& x, const BigInt& y) {
  971|  20.9k|   return BigInt::add2(x, y.data(), y.sig_words(), y.reverse_sign());
  972|  20.9k|}
_ZN5BotanmiERKNS_6BigIntEm:
  974|    827|inline BigInt operator-(const BigInt& x, word y) {
  975|    827|   return BigInt::add2(x, &y, 1, BigInt::Negative);
  976|    827|}
_ZN5BotanmlEmRKNS_6BigIntE:
  981|  94.5k|inline BigInt operator*(word x, const BigInt& y) {
  982|  94.5k|   return y * x;
  983|  94.5k|}
_ZN5BotaneqERKNS_6BigIntES2_:
  995|  7.90k|inline bool operator==(const BigInt& a, const BigInt& b) {
  996|  7.90k|   return a.is_equal(b);
  997|  7.90k|}
_ZN5BotanneERKNS_6BigIntES2_:
  999|  3.03k|inline bool operator!=(const BigInt& a, const BigInt& b) {
 1000|  3.03k|   return !a.is_equal(b);
 1001|  3.03k|}
_ZN5BotangeERKNS_6BigIntES2_:
 1007|  5.13k|inline bool operator>=(const BigInt& a, const BigInt& b) {
 1008|  5.13k|   return (a.cmp(b) >= 0);
 1009|  5.13k|}
_ZN5BotanltERKNS_6BigIntES2_:
 1011|  52.8k|inline bool operator<(const BigInt& a, const BigInt& b) {
 1012|  52.8k|   return a.is_less_than(b);
 1013|  52.8k|}
_ZN5BotangtERKNS_6BigIntES2_:
 1015|  45.4k|inline bool operator>(const BigInt& a, const BigInt& b) {
 1016|  45.4k|   return b.is_less_than(a);
 1017|  45.4k|}
_ZN5BotaneqERKNS_6BigIntEm:
 1019|    858|inline bool operator==(const BigInt& a, word b) {
 1020|    858|   return (a.cmp_word(b) == 0);
 1021|    858|}
_ZN5BotanleERKNS_6BigIntEm:
 1027|  1.19k|inline bool operator<=(const BigInt& a, word b) {
 1028|  1.19k|   return (a.cmp_word(b) <= 0);
 1029|  1.19k|}
_ZN5BotangeERKNS_6BigIntEm:
 1031|    663|inline bool operator>=(const BigInt& a, word b) {
 1032|    663|   return (a.cmp_word(b) >= 0);
 1033|    663|}
_ZN5BotanltERKNS_6BigIntEm:
 1035|  10.6k|inline bool operator<(const BigInt& a, word b) {
 1036|  10.6k|   return (a.cmp_word(b) < 0);
 1037|  10.6k|}
_ZN5BotangtERKNS_6BigIntEm:
 1039|  50.6k|inline bool operator>(const BigInt& a, word b) {
 1040|  50.6k|   return (a.cmp_word(b) > 0);
 1041|  50.6k|}
_ZN5Botan6BigIntC2Ev:
   40|  5.77M|      BigInt() = default;
_ZN5Botan6BigIntC2ERKS0_:
   80|  1.40M|      BigInt(const BigInt& other) = default;
_ZN5Botan6BigIntaSERKS0_:
  164|  2.58M|      BigInt& operator=(const BigInt&) = default;

_ZNK5Botan11BlockCipher7encryptEPKhPh:
   75|  7.38k|      void encrypt(const uint8_t in[], uint8_t out[]) const { encrypt_n(in, out, 1); }
_ZNK5Botan25Block_Cipher_Fixed_ParamsILm8ELm32ELm0ELm1ENS_11BlockCipherEE8key_specEv:
  214|  7.38k|      Key_Length_Specification key_spec() const final { return Key_Length_Specification(KMIN, KMAX, KMOD); }

_ZN5Botan20Buffered_Computation6updateEPKhm:
   35|  10.9k|      void update(const uint8_t in[], size_t length) { add_data({in, length}); }
_ZN5Botan20Buffered_Computation6updateENSt3__14spanIKhLm18446744073709551615EEE:
   41|  13.3k|      void update(std::span<const uint8_t> in) { add_data(in); }
_ZN5Botan20Buffered_Computation5finalEPh:
   70|    275|      void final(uint8_t out[]) { final_result({out, output_length()}); }
_ZN5Botan20Buffered_Computation12final_stdvecEv:
   84|  14.6k|      std::vector<uint8_t> final_stdvec() { return final<std::vector<uint8_t>>(); }
_ZN5Botan20Buffered_Computation5finalINSt3__16vectorIhNS2_9allocatorIhEEEEEET_v:
   78|  14.6k|      T final() {
   79|  14.6k|         T output(output_length());
   80|  14.6k|         final_result(output);
   81|  14.6k|         return output;
   82|  14.6k|      }
_ZN5Botan20Buffered_ComputationD2Ev:
  134|  19.5k|      virtual ~Buffered_Computation() = default;
_ZN5Botan20Buffered_Computation7processINSt3__16vectorIhNS_16secure_allocatorIhEEEEEET_PKhm:
  105|  8.90k|      T process(const uint8_t in[], size_t length) {
  106|  8.90k|         update(in, length);
  107|  8.90k|         return final<T>();
  108|  8.90k|      }
_ZN5Botan20Buffered_Computation5finalINSt3__16vectorIhNS_16secure_allocatorIhEEEEEET_v:
   78|  9.31k|      T final() {
   79|  9.31k|         T output(output_length());
   80|  9.31k|         final_result(output);
   81|  9.31k|         return output;
   82|  9.31k|      }

_ZN5Botan27Certificate_Store_In_MemoryC2Ev:
   97|  1.39k|      Certificate_Store_In_Memory() = default;

_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm18446744073709551615EEEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_:
  107|  2.12k|{
  108|  2.12k|   const std::span s0{r0};
  109|       |
  110|  2.12k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  2.12k|      constexpr size_t expected_size = s0.size_bytes();
  112|  2.12k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  2.12k|   } else {
  114|  2.12k|      const size_t expected_size = s0.size_bytes();
  115|  2.12k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  2.12k|   do {                                                          \
  |  |   31|  2.12k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 2.12k]
  |  |  ------------------
  |  |   32|  2.12k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  2.12k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  2.12k|                      "memory regions don't have equal lengths");
  117|  2.12k|   }
  118|  2.12k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm32ERNSt3__14spanIhLm32EEEEEvOT0_:
   86|  2.10k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  2.10k|   const std::span s{r};
   88|  2.10k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  2.10k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  2.10k|   } else {
   91|  2.10k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  2.10k|   }
   93|  2.10k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__15arrayImLm4EEEJRNS2_4spanIhLm32EEEEEEvOT_DpOT0_:
  107|  2.10k|{
  108|  2.10k|   const std::span s0{r0};
  109|       |
  110|  2.10k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  2.10k|      constexpr size_t expected_size = s0.size_bytes();
  112|  2.10k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  2.10k|   } else {
  114|  2.10k|      const size_t expected_size = s0.size_bytes();
  115|  2.10k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  2.10k|                      "memory regions don't have equal lengths");
  117|  2.10k|   }
  118|  2.10k|}
_ZN5Botan6ranges10size_bytesIRNSt3__15arrayImLm4EEEEEmOT_:
   73|  7.90k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  7.90k|   return std::span{r}.size_bytes();
   75|  7.90k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm32ERNSt3__14spanIKhLm32EEEEEvOT0_:
   86|  5.79k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  5.79k|   const std::span s{r};
   88|  5.79k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  5.79k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  5.79k|   } else {
   91|  5.79k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  5.79k|   }
   93|  5.79k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__15arrayImLm4EEEJRNS2_4spanIKhLm32EEEEEEvOT_DpOT0_:
  107|  5.79k|{
  108|  5.79k|   const std::span s0{r0};
  109|       |
  110|  5.79k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  5.79k|      constexpr size_t expected_size = s0.size_bytes();
  112|  5.79k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  5.79k|   } else {
  114|  5.79k|      const size_t expected_size = s0.size_bytes();
  115|  5.79k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  5.79k|                      "memory regions don't have equal lengths");
  117|  5.79k|   }
  118|  5.79k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm32ERNSt3__15arrayImLm4EEEEEvOT0_:
   86|  3.95k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  3.95k|   const std::span s{r};
   88|  3.95k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  3.95k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  3.95k|   } else {
   91|  3.95k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  3.95k|   }
   93|  3.95k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm32EEEJRNS2_5arrayImLm4EEEEEEvOT_DpOT0_:
  107|  3.95k|{
  108|  3.95k|   const std::span s0{r0};
  109|       |
  110|  3.95k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  3.95k|      constexpr size_t expected_size = s0.size_bytes();
  112|  3.95k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  3.95k|   } else {
  114|  3.95k|      const size_t expected_size = s0.size_bytes();
  115|  3.95k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  3.95k|                      "memory regions don't have equal lengths");
  117|  3.95k|   }
  118|  3.95k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIhLm32EEEEEmOT_:
   73|  3.95k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  3.95k|   return std::span{r}.size_bytes();
   75|  3.95k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm18446744073709551615EEEJRNS3_IKhLm18446744073709551615EEES8_EEEvOT_DpOT0_:
  107|  1.84k|{
  108|  1.84k|   const std::span s0{r0};
  109|       |
  110|  1.84k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  1.84k|      constexpr size_t expected_size = s0.size_bytes();
  112|  1.84k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  1.84k|   } else {
  114|  1.84k|      const size_t expected_size = s0.size_bytes();
  115|  1.84k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  1.84k|   do {                                                          \
  |  |   31|  3.69k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 1.84k]
  |  |  |  Branch (31:12): [True: 1.84k, False: 0]
  |  |  |  Branch (31:12): [True: 1.84k, False: 0]
  |  |  ------------------
  |  |   32|  1.84k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.84k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  1.84k|                      "memory regions don't have equal lengths");
  117|  1.84k|   }
  118|  1.84k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIKhLm4EEEEEvOT0_:
   86|  2.05M|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  2.05M|   const std::span s{r};
   88|  2.05M|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  2.05M|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  2.05M|   } else {
   91|  2.05M|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  2.05M|   }
   93|  2.05M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIjLm1EEEJRNS3_IKhLm4EEEEEEvOT_DpOT0_:
  107|  1.02M|{
  108|  1.02M|   const std::span s0{r0};
  109|       |
  110|  1.02M|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  1.02M|      constexpr size_t expected_size = s0.size_bytes();
  112|  1.02M|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  1.02M|   } else {
  114|  1.02M|      const size_t expected_size = s0.size_bytes();
  115|  1.02M|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  1.02M|                      "memory regions don't have equal lengths");
  117|  1.02M|   }
  118|  1.02M|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIjLm1EEEEEmOT_:
   73|  1.02M|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  1.02M|   return std::span{r}.size_bytes();
   75|  1.02M|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIhLm8EEEEEvOT0_:
   86|  83.2k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  83.2k|   const std::span s{r};
   88|  83.2k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  83.2k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  83.2k|   } else {
   91|  83.2k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  83.2k|   }
   93|  83.2k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm8EEEJRNS3_IKmLm1EEEEEEvOT_DpOT0_:
  107|  75.9k|{
  108|  75.9k|   const std::span s0{r0};
  109|       |
  110|  75.9k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  75.9k|      constexpr size_t expected_size = s0.size_bytes();
  112|  75.9k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  75.9k|   } else {
  114|  75.9k|      const size_t expected_size = s0.size_bytes();
  115|  75.9k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  75.9k|                      "memory regions don't have equal lengths");
  117|  75.9k|   }
  118|  75.9k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIKmLm1EEEEEvOT0_:
   86|  75.9k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  75.9k|   const std::span s{r};
   88|  75.9k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  75.9k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  75.9k|   } else {
   91|  75.9k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  75.9k|   }
   93|  75.9k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIhLm8EEEEEmOT_:
   73|  75.9k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  75.9k|   return std::span{r}.size_bytes();
   75|  75.9k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIhLm4EEEEEvOT0_:
   86|   176k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   176k|   const std::span s{r};
   88|   176k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   176k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   176k|   } else {
   91|   176k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   176k|   }
   93|   176k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIhLm4EEEJRNS3_IKjLm1EEEEEEvOT_DpOT0_:
  107|   176k|{
  108|   176k|   const std::span s0{r0};
  109|       |
  110|   176k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|   176k|      constexpr size_t expected_size = s0.size_bytes();
  112|   176k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|   176k|   } else {
  114|   176k|      const size_t expected_size = s0.size_bytes();
  115|   176k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|   176k|                      "memory regions don't have equal lengths");
  117|   176k|   }
  118|   176k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ERNSt3__14spanIKjLm1EEEEEvOT0_:
   86|   176k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   176k|   const std::span s{r};
   88|   176k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   176k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   176k|   } else {
   91|   176k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   176k|   }
   93|   176k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIhLm4EEEEEmOT_:
   73|   176k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|   176k|   return std::span{r}.size_bytes();
   75|   176k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanIjLm18446744073709551615EEEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_:
  107|    700|{
  108|    700|   const std::span s0{r0};
  109|       |
  110|    700|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|    700|      constexpr size_t expected_size = s0.size_bytes();
  112|    700|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|    700|   } else {
  114|    700|      const size_t expected_size = s0.size_bytes();
  115|    700|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|    700|   do {                                                          \
  |  |   31|    700|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 700]
  |  |  ------------------
  |  |   32|    700|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    700|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|    700|                      "memory regions don't have equal lengths");
  117|    700|   }
  118|    700|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanIjLm18446744073709551615EEEEEmOT_:
   73|    700|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|    700|   return std::span{r}.size_bytes();
   75|    700|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ERNSt3__14spanIKhLm8EEEEEvOT0_:
   86|   280k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|   280k|   const std::span s{r};
   88|   280k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|   280k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|   280k|   } else {
   91|   280k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|   280k|   }
   93|   280k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanImLm1EEEJRNS3_IKhLm8EEEEEEvOT_DpOT0_:
  107|   140k|{
  108|   140k|   const std::span s0{r0};
  109|       |
  110|   140k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|   140k|      constexpr size_t expected_size = s0.size_bytes();
  112|   140k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|   140k|   } else {
  114|   140k|      const size_t expected_size = s0.size_bytes();
  115|   140k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|   140k|                      "memory regions don't have equal lengths");
  117|   140k|   }
  118|   140k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanImLm1EEEEEmOT_:
   73|   140k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|   140k|   return std::span{r}.size_bytes();
   75|   140k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanImLm18446744073709551615EEEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_:
  107|  3.69k|{
  108|  3.69k|   const std::span s0{r0};
  109|       |
  110|  3.69k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  3.69k|      constexpr size_t expected_size = s0.size_bytes();
  112|  3.69k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  3.69k|   } else {
  114|  3.69k|      const size_t expected_size = s0.size_bytes();
  115|  3.69k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  3.69k|   do {                                                          \
  |  |   31|  3.69k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 3.69k]
  |  |  ------------------
  |  |   32|  3.69k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  3.69k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  3.69k|                      "memory regions don't have equal lengths");
  117|  3.69k|   }
  118|  3.69k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanImLm18446744073709551615EEEEEmOT_:
   73|  3.69k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  3.69k|   return std::span{r}.size_bytes();
   75|  3.69k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm2ERNSt3__14spanIKhLm2EEEEEvOT0_:
   86|  8.33k|inline constexpr void assert_exact_byte_length(R&& r) {
   87|  8.33k|   const std::span s{r};
   88|  8.33k|   if constexpr(decltype(s)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (88:17): [Folded - Ignored]
  ------------------
   89|  8.33k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   90|  8.33k|   } else {
   91|  8.33k|      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   92|  8.33k|   }
   93|  8.33k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsIRNSt3__14spanItLm1EEEJRNS3_IKhLm2EEEEEEvOT_DpOT0_:
  107|  4.16k|{
  108|  4.16k|   const std::span s0{r0};
  109|       |
  110|  4.16k|   if constexpr(decltype(s0)::extent != std::dynamic_extent) {
  ------------------
  |  Branch (110:17): [Folded - Ignored]
  ------------------
  111|  4.16k|      constexpr size_t expected_size = s0.size_bytes();
  112|  4.16k|      (assert_exact_byte_length<expected_size>(rs), ...);
  113|  4.16k|   } else {
  114|  4.16k|      const size_t expected_size = s0.size_bytes();
  115|  4.16k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  116|  4.16k|                      "memory regions don't have equal lengths");
  117|  4.16k|   }
  118|  4.16k|}
_ZN5Botan6ranges10size_bytesIRNSt3__14spanItLm1EEEEEmOT_:
   73|  4.16k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   74|  4.16k|   return std::span{r}.size_bytes();
   75|  4.16k|}

_ZNK5Botan13CurveGFp_Repr9curve_mulERNS_6BigIntERKS1_S4_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   60|  9.80M|      void curve_mul(BigInt& z, const BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
   61|  9.80M|         BOTAN_DEBUG_ASSERT(x.sig_words() <= get_p_words());
  ------------------
  |  |   99|  9.80M|      do {                          \
  |  |  100|  9.80M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   62|  9.80M|         curve_mul_words(z, x.data(), x.size(), y, ws);
   63|  9.80M|      }
_ZNK5Botan13CurveGFp_Repr9curve_sqrERNS_6BigIntERKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   68|  3.80M|      void curve_sqr(BigInt& z, const BigInt& x, secure_vector<word>& ws) const {
   69|  3.80M|         BOTAN_DEBUG_ASSERT(x.sig_words() <= get_p_words());
  ------------------
  |  |   99|  3.80M|      do {                          \
  |  |  100|  3.80M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   70|  3.80M|         curve_sqr_words(z, x.data(), x.size(), ws);
   71|  3.80M|      }
_ZN5Botan8CurveGFpC2ERKNS_6BigIntES3_S3_:
   98|    827|      CurveGFp(const BigInt& p, const BigInt& a, const BigInt& b) : m_repr(choose_repr(p, a, b)) {}
_ZNK5Botan8CurveGFp5get_aEv:
  107|    690|      const BigInt& get_a() const { return m_repr->get_a(); }
_ZNK5Botan8CurveGFp5get_bEv:
  112|    690|      const BigInt& get_b() const { return m_repr->get_b(); }
_ZNK5Botan8CurveGFp5get_pEv:
  118|   873k|      const BigInt& get_p() const { return m_repr->get_p(); }
_ZNK5Botan8CurveGFp11get_p_wordsEv:
  120|   468k|      size_t get_p_words() const { return m_repr->get_p_words(); }
_ZNK5Botan8CurveGFp11get_ws_sizeEv:
  122|   870k|      size_t get_ws_size() const { return m_repr->get_ws_size(); }
_ZNK5Botan8CurveGFp9get_a_repEv:
  124|  1.56k|      const BigInt& get_a_rep() const { return m_repr->get_a_rep(); }
_ZNK5Botan8CurveGFp9get_b_repEv:
  126|  2.92k|      const BigInt& get_b_rep() const { return m_repr->get_b_rep(); }
_ZNK5Botan8CurveGFp9get_1_repEv:
  128|  3.58k|      const BigInt& get_1_rep() const { return m_repr->get_1_rep(); }
_ZNK5Botan8CurveGFp12a_is_minus_3Ev:
  130|   399k|      bool a_is_minus_3() const { return m_repr->a_is_minus_3(); }
_ZNK5Botan8CurveGFp9a_is_zeroEv:
  132|   399k|      bool a_is_zero() const { return m_repr->a_is_zero(); }
_ZNK5Botan8CurveGFp6is_oneERKNS_6BigIntE:
  134|    312|      bool is_one(const BigInt& x) const { return m_repr->is_one(x); }
_ZNK5Botan8CurveGFp14invert_elementERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  136|  1.57k|      BigInt invert_element(const BigInt& x, secure_vector<word>& ws) const { return m_repr->invert_element(x, ws); }
_ZNK5Botan8CurveGFp6to_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  138|  3.03k|      void to_rep(BigInt& x, secure_vector<word>& ws) const { m_repr->to_curve_rep(x, ws); }
_ZNK5Botan8CurveGFp8from_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  140|    312|      void from_rep(BigInt& x, secure_vector<word>& ws) const { m_repr->from_curve_rep(x, ws); }
_ZNK5Botan8CurveGFp15from_rep_to_tmpERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  142|  4.49k|      BigInt from_rep_to_tmp(const BigInt& x, secure_vector<word>& ws) const {
  143|  4.49k|         BigInt xt(x);
  144|  4.49k|         m_repr->from_curve_rep(xt, ws);
  145|  4.49k|         return xt;
  146|  4.49k|      }
_ZNK5Botan8CurveGFp3mulERNS_6BigIntERKS1_S4_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  150|  7.53M|      void mul(BigInt& z, const BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  151|  7.53M|         m_repr->curve_mul(z, x, y, ws);
  152|  7.53M|      }
_ZNK5Botan8CurveGFp3mulERNS_6BigIntEPKmmRKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  154|  1.79M|      void mul(BigInt& z, const word x_w[], size_t x_size, const BigInt& y, secure_vector<word>& ws) const {
  155|  1.79M|         m_repr->curve_mul_words(z, x_w, x_size, y, ws);
  156|  1.79M|      }
_ZNK5Botan8CurveGFp3sqrERNS_6BigIntERKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  158|  3.75M|      void sqr(BigInt& z, const BigInt& x, secure_vector<word>& ws) const { m_repr->curve_sqr(z, x, ws); }
_ZNK5Botan8CurveGFp3sqrERNS_6BigIntEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
  160|   431k|      void sqr(BigInt& z, const word x_w[], size_t x_size, secure_vector<word>& ws) const {
  161|   431k|         m_repr->curve_sqr_words(z, x_w, x_size, ws);
  162|   431k|      }
_ZNK5Botan8CurveGFp10mul_to_tmpERKNS_6BigIntES3_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  168|  2.26M|      BigInt mul_to_tmp(const BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  169|  2.26M|         BigInt z;
  170|  2.26M|         m_repr->curve_mul(z, x, y, ws);
  171|  2.26M|         return z;
  172|  2.26M|      }
_ZNK5Botan8CurveGFp10sqr_to_tmpERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  174|  7.73k|      BigInt sqr_to_tmp(const BigInt& x, secure_vector<word>& ws) const {
  175|  7.73k|         BigInt z;
  176|  7.73k|         m_repr->curve_sqr(z, x, ws);
  177|  7.73k|         return z;
  178|  7.73k|      }
_ZN5Botan8CurveGFp4swapERS0_:
  180|   645k|      void swap(CurveGFp& other) { std::swap(m_repr, other.m_repr); }
_ZNK5Botan8CurveGFpeqERKS0_:
  189|   468k|      inline bool operator==(const CurveGFp& other) const {
  190|   468k|         if(m_repr.get() == other.m_repr.get()) {
  ------------------
  |  Branch (190:13): [True: 468k, False: 0]
  ------------------
  191|   468k|            return true;
  192|   468k|         }
  193|       |
  194|      0|         return (get_p() == other.get_p()) && (get_a() == other.get_a()) && (get_b() == other.get_b());
  ------------------
  |  Branch (194:17): [True: 0, False: 0]
  |  Branch (194:47): [True: 0, False: 0]
  |  Branch (194:77): [True: 0, False: 0]
  ------------------
  195|   468k|      }
_ZN5Botan8CurveGFpC2Ev:
   90|   753k|      CurveGFp() = default;
_ZN5Botan8CurveGFpC2ERKS0_:
  100|   437k|      CurveGFp(const CurveGFp&) = default;
_ZN5Botan8CurveGFpaSERKS0_:
  102|   426k|      CurveGFp& operator=(const CurveGFp&) = default;
_ZN5Botan13CurveGFp_ReprD2Ev:
   23|    827|      virtual ~CurveGFp_Repr() = default;

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

_ZN5Botan11DER_Encoder14start_sequenceEv:
   65|  30.7k|      DER_Encoder& start_sequence() { return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }
_ZN5Botan11DER_Encoder9raw_bytesINSt3__19allocatorIhEEEERS0_RKNS2_6vectorIhT_EE:
   88|  8.97k|      DER_Encoder& raw_bytes(const std::vector<uint8_t, Alloc>& val) {
   89|  8.97k|         return raw_bytes(val.data(), val.size());
   90|  8.97k|      }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  163|  4.52k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const std::vector<uint8_t>& rep) {
  164|  4.52k|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  165|  4.52k|      }
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassERKNSt3__16vectorIhNS_16secure_allocatorIhEEEE:
  167|  4.58k|      DER_Encoder& add_object(ASN1_Type type_tag, ASN1_Class class_tag, const secure_vector<uint8_t>& rep) {
  168|  4.58k|         return add_object(type_tag, class_tag, rep.data(), rep.size());
  169|  4.58k|      }
_ZN5Botan11DER_Encoder12DER_SequenceC2EOS1_:
  192|  66.0k|                  m_set_contents(std::move(seq.m_set_contents)) {}
_ZN5Botan11DER_Encoder6encodeINSt3__19allocatorIhEEEERS0_RKNS2_6vectorIhT_EENS_9ASN1_TypeE:
   99|  4.45k|      DER_Encoder& encode(const std::vector<uint8_t, Alloc>& vec, ASN1_Type real_type) {
  100|  4.45k|         return encode(vec.data(), vec.size(), real_type);
  101|  4.45k|      }
_ZN5Botan11DER_Encoder11encode_listINS_6BigIntEEERS0_RKNSt3__16vectorIT_NS4_9allocatorIS6_EEEE:
  132|     71|      DER_Encoder& encode_list(const std::vector<T>& values) {
  133|    213|         for(size_t i = 0; i != values.size(); ++i) {
  ------------------
  |  Branch (133:28): [True: 142, False: 71]
  ------------------
  134|    142|            encode(values[i]);
  135|    142|         }
  136|     71|         return (*this);
  137|     71|      }

_ZN5Botan8DL_GroupC2INSt3__19allocatorIhEEEERKNS2_6vectorIhT_EENS_15DL_Group_FormatE:
  124|     92|            DL_Group(ber.data(), ber.size(), format) {}

_ZNK5Botan8EC_Group6OS2ECPENSt3__14spanIKhLm18446744073709551615EEE:
  337|    704|      EC_Point OS2ECP(std::span<const uint8_t> encoded_point) const {
  338|    704|         return this->OS2ECP(encoded_point.data(), encoded_point.size());
  339|    704|      }
_ZN5Botan8EC_GroupC2ERKS0_:
  105|    438|      EC_Group(const EC_Group&) = default;
_ZN5Botan8EC_GroupaSEOS0_:
  109|    498|      EC_Group& operator=(EC_Group&&) = default;
_ZN5Botan8EC_GroupC2INSt3__19allocatorIhEEEERKNS2_6vectorIhT_EE:
   78|    806|      EC_Group(const std::vector<uint8_t, Alloc>& ber) : EC_Group(ber.data(), ber.size()) {}

_ZN5Botan8EC_PointC2EOS0_:
   58|  4.46k|      EC_Point(EC_Point&& other) { this->swap(other); }
_ZN5Botan8EC_PointaSEOS0_:
   68|   533k|      EC_Point& operator=(EC_Point&& other) {
   69|   533k|         if(this != &other) {
  ------------------
  |  Branch (69:13): [True: 533k, False: 0]
  ------------------
   70|   533k|            this->swap(other);
   71|   533k|         }
   72|   533k|         return (*this);
   73|   533k|      }
_ZNK5Botan8EC_Point5get_xEv:
  139|   746k|      const BigInt& get_x() const { return m_coord_x; }
_ZNK5Botan8EC_Point5get_yEv:
  146|   746k|      const BigInt& get_y() const { return m_coord_y; }
_ZNK5Botan8EC_Point7is_zeroEv:
  177|  1.63M|      bool is_zero() const { return m_coord_z.is_zero(); }
_ZN5Botan8EC_Point3addERKS0_RNSt3__16vectorINS_6BigIntENS3_9allocatorIS5_EEEE:
  216|   431k|      void add(const EC_Point& other, std::vector<BigInt>& workspace) {
  217|   431k|         BOTAN_ARG_CHECK(m_curve == other.m_curve, "cannot add points on different curves");
  ------------------
  |  |   30|   431k|   do {                                                          \
  |  |   31|   431k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 431k]
  |  |  ------------------
  |  |   32|   431k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|   431k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  218|       |
  219|   431k|         const size_t p_words = m_curve.get_p_words();
  220|       |
  221|   431k|         add(other.m_coord_x.data(),
  222|   431k|             std::min(p_words, other.m_coord_x.size()),
  223|   431k|             other.m_coord_y.data(),
  224|   431k|             std::min(p_words, other.m_coord_y.size()),
  225|   431k|             other.m_coord_z.data(),
  226|   431k|             std::min(p_words, other.m_coord_z.size()),
  227|   431k|             workspace);
  228|   431k|      }
_ZN5Botan8EC_Point10add_affineERKS0_RNSt3__16vectorINS_6BigIntENS3_9allocatorIS5_EEEE:
  254|  36.9k|      void add_affine(const EC_Point& other, std::vector<BigInt>& workspace) {
  255|  36.9k|         BOTAN_ASSERT_NOMSG(m_curve == other.m_curve);
  ------------------
  |  |   60|  36.9k|   do {                                                                     \
  |  |   61|  36.9k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 36.9k]
  |  |  ------------------
  |  |   62|  36.9k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  36.9k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  256|  36.9k|         BOTAN_DEBUG_ASSERT(other.is_affine());
  ------------------
  |  |   99|  36.9k|      do {                          \
  |  |  100|  36.9k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  257|       |
  258|  36.9k|         const size_t p_words = m_curve.get_p_words();
  259|  36.9k|         add_affine(other.m_coord_x.data(),
  260|  36.9k|                    std::min(p_words, other.m_coord_x.size()),
  261|  36.9k|                    other.m_coord_y.data(),
  262|  36.9k|                    std::min(p_words, other.m_coord_y.size()),
  263|  36.9k|                    workspace);
  264|  36.9k|      }
_ZNK5Botan8EC_Point4plusERKS0_RNSt3__16vectorINS_6BigIntENS3_9allocatorIS5_EEEE:
  297|   431k|      EC_Point plus(const EC_Point& other, std::vector<BigInt>& workspace) const {
  298|   431k|         EC_Point x = (*this);
  299|   431k|         x.add(other, workspace);
  300|   431k|         return x;
  301|   431k|      }
_ZNK5Botan8EC_Point4zeroEv:
  317|    312|      EC_Point zero() const { return EC_Point(m_curve); }
_ZNK5Botan8EC_Point9get_curveEv:
  325|  1.65k|      const CurveGFp& get_curve() const { return m_curve; }
_ZN5Botan8EC_PointC2Ev:
   42|   749k|      EC_Point() = default;
_ZN5Botan8EC_PointC2ERKS0_:
   53|   435k|      EC_Point(const EC_Point&) = default;
_ZN5Botan8EC_PointaSERKS0_:
   63|   426k|      EC_Point& operator=(const EC_Point&) = default;

_ZNK5Botan12EC_PublicKey12public_pointEv:
   40|    438|      const EC_Point& public_point() const { return m_public_key; }
_ZNK5Botan12EC_PublicKey6domainEv:
   54|  2.11k|      const EC_Group& domain() const { return m_domain_params; }
_ZN5Botan12EC_PublicKeyC2Ev:
  106|    571|      EC_PublicKey() : m_domain_params{}, m_public_key{}, m_domain_encoding(EC_Group_Encoding::Explicit) {}
_ZN5Botan12EC_PublicKeyD2Ev:
   32|    782|      ~EC_PublicKey() override = default;

_ZN5Botan15ECDSA_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   35|    806|            EC_PublicKey(alg_id, key_bits) {}
_ZNK5Botan15ECDSA_PublicKey13message_partsEv:
   55|    328|      size_t message_parts() const override { return 2; }
_ZNK5Botan15ECDSA_PublicKey17message_part_sizeEv:
   57|    164|      size_t message_part_size() const override { return domain().get_order().bytes(); }

_ZNK5Botan9Exception4whatEv:
   93|  4.34k|      const char* what() const noexcept override { return m_msg.c_str(); }
_ZN5Botan13Invalid_StateC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  208|     14|      explicit Invalid_State(std::string_view err) : Exception(err) {}
_ZN5Botan12Lookup_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  237|    194|      explicit Lookup_Error(std::string_view err) : Exception(err) {}

_ZNK5Botan19GOST_3410_PublicKey13message_partsEv:
   47|    274|      size_t message_parts() const override { return 2; }
_ZNK5Botan19GOST_3410_PublicKey17message_part_sizeEv:
   49|    274|      size_t message_part_size() const override { return domain().get_order().bytes(); }
_ZNK5Botan19GOST_3410_PublicKey29default_x509_signature_formatEv:
   51|    274|      Signature_Format default_x509_signature_format() const override { return Signature_Format::Standard; }

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

_ZN5Botan13typecast_copyIRNSt3__15arrayImLm4EEERNS1_4spanIhLm32EEEEEvOT_OT0_:
  176|  2.10k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  2.10k|   ranges::assert_equal_byte_lengths(out, in);
  178|  2.10k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  2.10k|}
_ZN5Botan13typecast_copyINSt3__15arrayImLm4EEENS1_4spanIhLm32EEEEET_OT0_:
  209|  2.10k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  2.10k|   ToT dst;
  211|  2.10k|   typecast_copy(dst, src);
  212|  2.10k|   return dst;
  213|  2.10k|}
_ZN5Botan13typecast_copyIRNSt3__15arrayImLm4EEERNS1_4spanIKhLm32EEEEEvOT_OT0_:
  176|  5.79k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  5.79k|   ranges::assert_equal_byte_lengths(out, in);
  178|  5.79k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  5.79k|}
_ZN5Botan13typecast_copyINSt3__15arrayImLm4EEENS1_4spanIKhLm32EEEEET_OT0_:
  209|  5.79k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  5.79k|   ToT dst;
  211|  5.79k|   typecast_copy(dst, src);
  212|  5.79k|   return dst;
  213|  5.79k|}
_ZN5Botan13typecast_copyINSt3__14spanIhLm32EEERNS1_5arrayImLm4EEEEEvOT_OT0_:
  176|  3.95k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  3.95k|   ranges::assert_equal_byte_lengths(out, in);
  178|  3.95k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  3.95k|}
_ZN5Botan7xor_bufINSt3__14spanIhLm18446744073709551615EEENS2_IKhLm18446744073709551615EEEEEvOT_OT0_:
  341|  2.12k|                              ranges::contiguous_range<uint8_t> auto&& in) {
  342|  2.12k|   ranges::assert_equal_byte_lengths(out, in);
  343|       |
  344|  2.12k|   std::span o{out};
  345|  2.12k|   std::span i{in};
  346|       |
  347|  4.22k|   for(; o.size_bytes() >= 32; o = o.subspan(32), i = i.subspan(32)) {
  ------------------
  |  Branch (347:10): [True: 2.10k, False: 2.12k]
  ------------------
  348|  2.10k|      auto x = typecast_copy<std::array<uint64_t, 4>>(o.template first<32>());
  349|  2.10k|      const auto y = typecast_copy<std::array<uint64_t, 4>>(i.template first<32>());
  350|       |
  351|  2.10k|      x[0] ^= y[0];
  352|  2.10k|      x[1] ^= y[1];
  353|  2.10k|      x[2] ^= y[2];
  354|  2.10k|      x[3] ^= y[3];
  355|       |
  356|  2.10k|      typecast_copy(o.template first<32>(), x);
  357|  2.10k|   }
  358|       |
  359|  2.52k|   for(size_t off = 0; off != o.size_bytes(); ++off) {
  ------------------
  |  Branch (359:24): [True: 402, False: 2.12k]
  ------------------
  360|    402|      o[off] ^= i[off];
  361|    402|   }
  362|  2.12k|}
_ZN5Botan7xor_bufINSt3__14spanIhLm18446744073709551615EEENS2_IKhLm18446744073709551615EEES5_EEvOT_OT0_OT1_:
  372|  1.84k|                              ranges::contiguous_range<uint8_t> auto&& in2) {
  373|  1.84k|   ranges::assert_equal_byte_lengths(out, in1, in2);
  374|       |
  375|  1.84k|   std::span o{out};
  376|  1.84k|   std::span i1{in1};
  377|  1.84k|   std::span i2{in2};
  378|       |
  379|  3.69k|   for(; o.size_bytes() >= 32; o = o.subspan(32), i1 = i1.subspan(32), i2 = i2.subspan(32)) {
  ------------------
  |  Branch (379:10): [True: 1.84k, False: 1.84k]
  ------------------
  380|  1.84k|      auto x = typecast_copy<std::array<uint64_t, 4>>(i1.template first<32>());
  381|  1.84k|      const auto y = typecast_copy<std::array<uint64_t, 4>>(i2.template first<32>());
  382|       |
  383|  1.84k|      x[0] ^= y[0];
  384|  1.84k|      x[1] ^= y[1];
  385|  1.84k|      x[2] ^= y[2];
  386|  1.84k|      x[3] ^= y[3];
  387|       |
  388|  1.84k|      typecast_copy(o.template first<32>(), x);
  389|  1.84k|   }
  390|       |
  391|  1.84k|   for(size_t off = 0; off != o.size_bytes(); ++off) {
  ------------------
  |  Branch (391:24): [True: 0, False: 1.84k]
  ------------------
  392|      0|      o[off] = i1[off] ^ i2[off];
  393|      0|   }
  394|  1.84k|}
_ZN5Botan11clear_bytesEPvm:
  103|  38.0M|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  38.0M|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 36.0M, False: 1.94M]
  ------------------
  105|  36.0M|      std::memset(ptr, 0, bytes);
  106|  36.0M|   }
  107|  38.0M|}
_ZN5Botan22cast_char_ptr_to_uint8EPKc:
  272|  4.96k|inline const uint8_t* cast_char_ptr_to_uint8(const char* s) {
  273|  4.96k|   return reinterpret_cast<const uint8_t*>(s);
  274|  4.96k|}
_ZN5Botan22cast_uint8_ptr_to_charEPKh:
  276|  41.8k|inline const char* cast_uint8_ptr_to_char(const uint8_t* b) {
  277|  41.8k|   return reinterpret_cast<const char*>(b);
  278|  41.8k|}
_ZN5Botan7xor_bufEPhPKhm:
  402|  2.12k|inline void xor_buf(uint8_t out[], const uint8_t in[], size_t length) {
  403|       |   // simply assumes that *out and *in point to "length" allocated bytes at least
  404|  2.12k|   xor_buf(std::span{out, length}, std::span{in, length});
  405|  2.12k|}
_ZN5Botan7xor_bufEPhPKhS2_m:
  414|  1.84k|inline void xor_buf(uint8_t out[], const uint8_t in[], const uint8_t in2[], size_t length) {
  415|       |   // simply assumes that *out, *in, and *in2 point to "length" allocated bytes at least
  416|  1.84k|   xor_buf(std::span{out, length}, std::span{in, length}, std::span{in2, length});
  417|  1.84k|}
_ZN5Botan9clear_memImEEvPT_m:
  120|  37.9M|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  37.9M|   clear_bytes(ptr, sizeof(T) * n);
  122|  37.9M|}
_ZN5Botan8copy_memIhEEvPT_PKS1_m:
  146|  6.25M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  6.25M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  6.25M|   do {                                                                                          \
  |  |   79|  12.3M|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 6.17M, False: 82.1k]
  |  |  |  Branch (79:23): [True: 6.17M, False: 0]
  |  |  |  Branch (79:23): [True: 6.17M, False: 0]
  |  |  ------------------
  |  |   80|  6.25M|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  6.25M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  6.25M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 6.25M, False: 3.18k]
  |  Branch (149:24): [True: 6.23M, False: 18.8k]
  |  Branch (149:42): [True: 6.17M, False: 60.1k]
  ------------------
  150|  6.17M|      std::memmove(out, in, sizeof(T) * n);
  151|  6.17M|   }
  152|  6.25M|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|  73.6k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  73.6k|   clear_bytes(ptr, sizeof(T) * n);
  122|  73.6k|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEET_OT0_:
  209|  1.02M|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  1.02M|   ToT dst;
  211|  1.02M|   typecast_copy(dst, src);
  212|  1.02M|   return dst;
  213|  1.02M|}
_ZN5Botan13typecast_copyIjRNSt3__14spanIKhLm4EEEEEvRT_OT0_:
  188|  1.02M|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  1.02M|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  1.02M|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm1EEERNS2_IKhLm4EEEEEvOT_OT0_:
  176|  1.02M|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  1.02M|   ranges::assert_equal_byte_lengths(out, in);
  178|  1.02M|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  1.02M|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEEmEEvOT_RKT0_:
  199|  75.9k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|  75.9k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|  75.9k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm8EEENS2_IKmLm1EEEEEvOT_OT0_:
  176|  75.9k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  75.9k|   ranges::assert_equal_byte_lengths(out, in);
  178|  75.9k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  75.9k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEEjEEvOT_RKT0_:
  199|   176k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  200|   176k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  201|   176k|}
_ZN5Botan13typecast_copyIRNSt3__14spanIhLm4EEENS2_IKjLm1EEEEEvOT_OT0_:
  176|   176k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|   176k|   ranges::assert_equal_byte_lengths(out, in);
  178|   176k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|   176k|}
_ZN5Botan13typecast_copyIjEEvPT_PKhm:
  228|    700|{
  229|       |   // asserts that *in and *out point to the correct amount of memory
  230|    700|   typecast_copy(std::span<T>(out, N), std::span<const uint8_t>(in, N * sizeof(T)));
  231|    700|}
_ZN5Botan13typecast_copyINSt3__14spanIjLm18446744073709551615EEENS2_IKhLm18446744073709551615EEEEEvOT_OT0_:
  176|    700|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|    700|   ranges::assert_equal_byte_lengths(out, in);
  178|    700|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|    700|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEET_OT0_:
  209|   140k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|   140k|   ToT dst;
  211|   140k|   typecast_copy(dst, src);
  212|   140k|   return dst;
  213|   140k|}
_ZN5Botan13typecast_copyImRNSt3__14spanIKhLm8EEEEEvRT_OT0_:
  188|   140k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|   140k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|   140k|}
_ZN5Botan13typecast_copyINSt3__14spanImLm1EEERNS2_IKhLm8EEEEEvOT_OT0_:
  176|   140k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|   140k|   ranges::assert_equal_byte_lengths(out, in);
  178|   140k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|   140k|}
_ZN5Botan13typecast_copyImEEvPT_PKhm:
  228|  3.69k|{
  229|       |   // asserts that *in and *out point to the correct amount of memory
  230|  3.69k|   typecast_copy(std::span<T>(out, N), std::span<const uint8_t>(in, N * sizeof(T)));
  231|  3.69k|}
_ZN5Botan13typecast_copyINSt3__14spanImLm18446744073709551615EEENS2_IKhLm18446744073709551615EEEEEvOT_OT0_:
  176|  3.69k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  3.69k|   ranges::assert_equal_byte_lengths(out, in);
  178|  3.69k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  3.69k|}
_ZN5Botan8copy_memImEEvPT_PKS1_m:
  146|  3.92M|inline constexpr void copy_mem(T* out, const T* in, size_t n) {
  147|  3.92M|   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, "If n > 0 then args are not null");
  ------------------
  |  |   78|  3.92M|   do {                                                                                          \
  |  |   79|  7.84M|      if((expr1) && !(expr2))                                                                    \
  |  |  ------------------
  |  |  |  Branch (79:10): [True: 3.92M, False: 0]
  |  |  |  Branch (79:23): [True: 3.92M, False: 0]
  |  |  |  Branch (79:23): [True: 3.92M, False: 0]
  |  |  ------------------
  |  |   80|  3.92M|         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \
  |  |   81|  3.92M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (81:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|       |
  149|  3.92M|   if(in != nullptr && out != nullptr && n > 0) {
  ------------------
  |  Branch (149:7): [True: 3.92M, False: 0]
  |  Branch (149:24): [True: 3.92M, False: 0]
  |  Branch (149:42): [True: 3.92M, False: 0]
  ------------------
  150|  3.92M|      std::memmove(out, in, sizeof(T) * n);
  151|  3.92M|   }
  152|  3.92M|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEET_OT0_:
  209|  4.16k|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  210|  4.16k|   ToT dst;
  211|  4.16k|   typecast_copy(dst, src);
  212|  4.16k|   return dst;
  213|  4.16k|}
_ZN5Botan13typecast_copyItRNSt3__14spanIKhLm2EEEEEvRT_OT0_:
  188|  4.16k|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  189|  4.16k|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  190|  4.16k|}
_ZN5Botan13typecast_copyINSt3__14spanItLm1EEERNS2_IKhLm2EEEEEvOT_OT0_:
  176|  4.16k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  177|  4.16k|   ranges::assert_equal_byte_lengths(out, in);
  178|  4.16k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  179|  4.16k|}
_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|}

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

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

_ZN5Botan15Key_ConstraintsC2ENS0_4BitsE:
  139|  1.08k|      Key_Constraints(Key_Constraints::Bits bits) : m_value(bits) {}
_ZN5Botan15Key_ConstraintsC2Ej:
  141|    354|      explicit Key_Constraints(uint32_t bits) : m_value(bits) {}
_ZN5Botan15Key_ConstraintsC2Ev:
  143|  6.18k|      Key_Constraints() : m_value(0) {}
_ZNK5Botan15Key_Constraints8includesENS0_4BitsE:
  158|     73|      bool includes(Key_Constraints::Bits other) const { return (m_value & other) == other; }
_ZNK5Botan15Key_Constraints8includesES0_:
  160|    365|      bool includes(Key_Constraints other) const { return (m_value & other.m_value) == other.m_value; }
_ZNK5Botan15Key_Constraints5emptyEv:
  165|    386|      bool empty() const { return m_value == 0; }

_ZNK5Botan7X509_DN8get_bitsEv:
   62|  10.3k|      const std::vector<uint8_t>& get_bits() const { return m_dn_bits; }
_ZNK5Botan7X509_DN7dn_infoEv:
   70|  1.46k|      const std::vector<std::pair<OID, ASN1_String>>& dn_info() const { return m_rdn; }
_ZN5Botan14GeneralSubtreeC2Ev:
  246|    538|      GeneralSubtree() : m_base(), m_minimum(0), m_maximum(std::numeric_limits<std::size_t>::max()) {}
_ZN5Botan15NameConstraintsC2Ev:
  299|  6.76k|      NameConstraints() : m_permitted_subtrees(), m_excluded_subtrees() {}
_ZN5Botan15NameConstraintsC2EONSt3__16vectorINS_14GeneralSubtreeENS1_9allocatorIS3_EEEES7_:
  308|     49|            m_permitted_subtrees(permitted_subtrees), m_excluded_subtrees(excluded_subtrees) {}
_ZNK5Botan10Extensions18get_extension_oidsEv:
  416|    290|      const std::vector<OID>& get_extension_oids() const { return m_extension_oids; }
_ZN5Botan10Extensions15Extensions_InfoC2EbRKNSt3__16vectorIhNS2_9allocatorIhEEEENS2_10unique_ptrINS_21Certificate_ExtensionENS2_14default_deleteISA_EEEE:
  538|  11.3k|                  m_obj(std::move(ext)), m_bits(encoding), m_critical(critical) {}
_ZNK5Botan10Extensions15Extensions_Info11is_criticalEv:
  540|    645|            bool is_critical() const { return m_critical; }
_ZNK5Botan10Extensions15Extensions_Info3objEv:
  544|  3.33k|            const Certificate_Extension& obj() const {
  545|  3.33k|               BOTAN_ASSERT_NONNULL(m_obj.get());
  ------------------
  |  |   87|  3.33k|   do {                                                                                   \
  |  |   88|  3.33k|      if((ptr) == nullptr)                                                                \
  |  |  ------------------
  |  |  |  Branch (88:10): [True: 0, False: 3.33k]
  |  |  ------------------
  |  |   89|  3.33k|         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \
  |  |   90|  3.33k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (90:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  546|  3.33k|               return *m_obj;
  547|  3.33k|            }
_ZN5Botan7X509_DNC2Ev:
   39|  13.4k|      X509_DN() = default;
_ZN5Botan10ExtensionsC2Ev:
  517|  6.18k|      Extensions() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Authority_Key_IDEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 245, False: 4.21k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    245|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 92, False: 153]
  ------------------
  401|     92|               return nullptr;
  402|    153|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 153, False: 0]
  ------------------
  403|    153|               return extn_as_T;
  404|    153|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    245|         }
  408|       |
  409|  4.21k|         return nullptr;
  410|  4.45k|      }
_ZN5Botan21Certificate_ExtensionD2Ev:
  371|  16.1k|      virtual ~Certificate_Extension() = default;
_ZN5Botan11GeneralNameC2Ev:
  194|    538|      GeneralName() = default;
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension9Key_UsageEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 316, False: 4.14k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    316|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 103, False: 213]
  ------------------
  401|    103|               return nullptr;
  402|    213|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 213, False: 0]
  ------------------
  403|    213|               return extn_as_T;
  404|    213|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    316|         }
  408|       |
  409|  4.14k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension14Subject_Key_IDEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 483, False: 3.97k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    483|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 167, False: 316]
  ------------------
  401|    167|               return nullptr;
  402|    316|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 316, False: 0]
  ------------------
  403|    316|               return extn_as_T;
  404|    316|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    483|         }
  408|       |
  409|  3.97k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension16Name_ConstraintsEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 63, False: 4.39k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     63|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 56, False: 7]
  ------------------
  401|     56|               return nullptr;
  402|     56|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 7, False: 0]
  ------------------
  403|      7|               return extn_as_T;
  404|      7|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     63|         }
  408|       |
  409|  4.39k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension17Basic_ConstraintsEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 490, False: 3.96k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    490|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 249, False: 241]
  ------------------
  401|    249|               return nullptr;
  402|    249|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 241, False: 0]
  ------------------
  403|    241|               return extn_as_T;
  404|    241|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    490|         }
  408|       |
  409|  3.96k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension23Issuer_Alternative_NameEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 76, False: 4.38k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|     76|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 42, False: 34]
  ------------------
  401|     42|               return nullptr;
  402|     42|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 34, False: 0]
  ------------------
  403|     34|               return extn_as_T;
  404|     34|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|     76|         }
  408|       |
  409|  4.38k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension24Subject_Alternative_NameEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 397, False: 4.06k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    397|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 241, False: 156]
  ------------------
  401|    241|               return nullptr;
  402|    241|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 156, False: 0]
  ------------------
  403|    156|               return extn_as_T;
  404|    156|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    397|         }
  408|       |
  409|  4.06k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension18Extended_Key_UsageEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 190, False: 4.26k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    190|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 114, False: 76]
  ------------------
  401|    114|               return nullptr;
  402|    114|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 76, False: 0]
  ------------------
  403|     76|               return extn_as_T;
  404|     76|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    190|         }
  408|       |
  409|  4.26k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension20Certificate_PoliciesEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 145, False: 4.31k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    145|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 82, False: 63]
  ------------------
  401|     82|               return nullptr;
  402|     82|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 63, False: 0]
  ------------------
  403|     63|               return extn_as_T;
  404|     63|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    145|         }
  408|       |
  409|  4.31k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension28Authority_Information_AccessEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 116, False: 4.34k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    116|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 70, False: 46]
  ------------------
  401|     70|               return nullptr;
  402|     70|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 46, False: 0]
  ------------------
  403|     46|               return extn_as_T;
  404|     46|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    116|         }
  408|       |
  409|  4.34k|         return nullptr;
  410|  4.45k|      }
_ZNK5Botan10Extensions23get_extension_object_asINS_14Cert_Extension23CRL_Distribution_PointsEEEPKT_RKNS_3OIDE:
  397|  4.45k|      const T* get_extension_object_as(const OID& oid = T::static_oid()) const {
  398|  4.45k|         if(const Certificate_Extension* extn = get_extension_object(oid)) {
  ------------------
  |  Branch (398:42): [True: 165, False: 4.29k]
  ------------------
  399|       |            // Unknown_Extension oid_name is empty
  400|    165|            if(extn->oid_name().empty()) {
  ------------------
  |  Branch (400:16): [True: 93, False: 72]
  ------------------
  401|     93|               return nullptr;
  402|     93|            } else if(const T* extn_as_T = dynamic_cast<const T*>(extn)) {
  ------------------
  |  Branch (402:32): [True: 72, False: 0]
  ------------------
  403|     72|               return extn_as_T;
  404|     72|            } else {
  405|      0|               throw Decoding_Error("Exception::get_extension_object_as dynamic_cast failed");
  406|      0|            }
  407|    165|         }
  408|       |
  409|  4.29k|         return nullptr;
  410|  4.45k|      }

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

_ZNK5Botan15Modular_Reducer8multiplyERKNS_6BigIntES3_:
   30|  5.18k|      BigInt multiply(const BigInt& x, const BigInt& y) const { return reduce(x * y); }
_ZNK5Botan15Modular_Reducer11get_modulusEv:
   20|    827|      const BigInt& get_modulus() const { return m_modulus; }
_ZNK5Botan15Modular_Reducer6squareERKNS_6BigIntE:
   43|  2.91k|      BigInt square(const BigInt& x) const { return reduce(Botan::square(x)); }

_ZN5Botan16secure_allocatorIhE8allocateEm:
   45|   460k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIhE10deallocateEPhm:
   47|   460k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE10deallocateEPmm:
   47|  6.07M|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorImE8allocateEm:
   45|  6.07M|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5BotanneIhhEEbRKNS_16secure_allocatorIT_EERKNS1_IT0_EE:
   56|  81.6k|inline bool operator!=(const secure_allocator<T>&, const secure_allocator<U>&) {
   57|  81.6k|   return false;
   58|  81.6k|}
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPS5_T1_EE:
   98|  12.7k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<T*, L>& in) {
   99|  12.7k|   out.insert(out.end(), in.first, in.first + in.second);
  100|  12.7k|   return out;
  101|  12.7k|}
_ZN5BotanpLIhNS_16secure_allocatorIhEES2_EERNSt3__16vectorIT_T0_EES8_RKNS4_IS5_T1_EE:
   80|      3|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::vector<T, Alloc2>& in) {
   81|      3|   out.insert(out.end(), in.begin(), in.end());
   82|      3|   return out;
   83|      3|}
_ZN5BotanpLIhNS_16secure_allocatorIhEEmEERNSt3__16vectorIT_T0_EES8_RKNS3_4pairIPKS5_T1_EE:
   92|  66.7k|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::pair<const T*, L>& in) {
   93|  66.7k|   out.insert(out.end(), in.first, in.first + in.second);
   94|  66.7k|   return out;
   95|  66.7k|}
_ZN5Botan16secure_allocatorIjE10deallocateEPjm:
   47|  18.7k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }
_ZN5Botan16secure_allocatorIjE8allocateEm:
   45|  18.7k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan7zeroiseImNS_16secure_allocatorImEEEEvRNSt3__16vectorIT_T0_EE:
  108|    302|void zeroise(std::vector<T, Alloc>& vec) {
  109|    302|   std::fill(vec.begin(), vec.end(), static_cast<T>(0));
  110|    302|}
_ZN5Botan7zeroiseIhNS_16secure_allocatorIhEEEEvRNSt3__16vectorIT_T0_EE:
  108|    246|void zeroise(std::vector<T, Alloc>& vec) {
  109|    246|   std::fill(vec.begin(), vec.end(), static_cast<T>(0));
  110|    246|}
_ZN5BotanpLIhNSt3__19allocatorIhEENS_16secure_allocatorIhEEEERNS1_6vectorIT_T0_EESA_RKNS6_IS7_T1_EE:
   80|    495|std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, const std::vector<T, Alloc2>& in) {
   81|    495|   out.insert(out.end(), in.begin(), in.end());
   82|    495|   return out;
   83|    495|}
_ZN5Botan3zapIjNS_16secure_allocatorIjEEEEvRNSt3__16vectorIT_T0_EE:
  117|    123|void zap(std::vector<T, Alloc>& vec) {
  118|    123|   zeroise(vec);
  119|    123|   vec.clear();
  120|    123|   vec.shrink_to_fit();
  121|    123|}
_ZN5Botan7zeroiseIjNS_16secure_allocatorIjEEEEvRNSt3__16vectorIT_T0_EE:
  108|    123|void zeroise(std::vector<T, Alloc>& vec) {
  109|    123|   std::fill(vec.begin(), vec.end(), static_cast<T>(0));
  110|    123|}

_ZN5Botan24Key_Length_SpecificationC2Emmm:
   36|  7.38k|            m_min_keylen(min_k), m_max_keylen(max_k ? max_k : min_k), m_keylen_mod(k_mod) {}
_ZNK5Botan24Key_Length_Specification15valid_keylengthEm:
   42|  7.38k|      bool valid_keylength(size_t length) const {
   43|  7.38k|         return ((length >= m_min_keylen) && (length <= m_max_keylen) && (length % m_keylen_mod == 0));
  ------------------
  |  Branch (43:18): [True: 7.38k, False: 0]
  |  Branch (43:46): [True: 7.38k, False: 0]
  |  Branch (43:74): [True: 7.38k, False: 0]
  ------------------
   44|  7.38k|      }
_ZNK5Botan18SymmetricAlgorithm15valid_keylengthEm:
  107|  7.38k|      bool valid_keylength(size_t length) const { return key_spec().valid_keylength(length); }
_ZN5Botan18SymmetricAlgorithm7set_keyEPKhm:
  126|  7.38k|      void set_key(const uint8_t key[], size_t length) { set_key(std::span{key, length}); }
_ZNK5Botan18SymmetricAlgorithm23assert_key_material_setEv:
  139|  7.38k|      void assert_key_material_set() const { assert_key_material_set(has_keying_material()); }
_ZNK5Botan18SymmetricAlgorithm23assert_key_material_setEb:
  141|  7.38k|      void assert_key_material_set(bool predicate) const {
  142|  7.38k|         if(!predicate) {
  ------------------
  |  Branch (142:13): [True: 0, False: 7.38k]
  ------------------
  143|      0|            throw_key_not_set_error();
  144|      0|         }
  145|  7.38k|      }
_ZN5Botan18SymmetricAlgorithmD2Ev:
   79|    123|      virtual ~SymmetricAlgorithm() = default;

_ZN5Botan14Cert_Extension10CRL_Number10static_oidEv:
  349|  7.94k|      static OID static_oid() { return OID("2.5.29.20"); }
_ZN5Botan14Cert_Extension16Authority_Key_ID10static_oidEv:
  128|  12.1k|      static OID static_oid() { return OID("2.5.29.35"); }
_ZNK5Botan14Cert_Extension16Authority_Key_ID10get_key_idEv:
  126|    153|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point10static_oidEv:
  457|  6.15k|      static OID static_oid() { return OID("2.5.29.28"); }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_Point5pointEv:
  406|    231|            const AlternativeName& point() const { return m_point; }
_ZNK5Botan14Cert_Extension17Basic_Constraints4copyEv:
   27|     21|      std::unique_ptr<Certificate_Extension> copy() const override {
   28|     21|         return std::make_unique<Basic_Constraints>(m_is_ca, m_path_limit);
   29|     21|      }
_ZN5Botan14Cert_Extension17Basic_ConstraintsC2Ebm:
   31|    791|      Basic_Constraints(bool ca = false, size_t limit = 0) : m_is_ca(ca), m_path_limit(limit) {}
_ZNK5Botan14Cert_Extension17Basic_Constraints9get_is_caEv:
   33|    241|      bool get_is_ca() const { return m_is_ca; }
_ZN5Botan14Cert_Extension17Basic_Constraints10static_oidEv:
   37|  13.1k|      static OID static_oid() { return OID("2.5.29.19"); }
_ZNK5Botan14Cert_Extension17Basic_Constraints8oid_nameEv:
   42|    241|      std::string oid_name() const override { return "X509v3.BasicConstraints"; }
_ZNK5Botan14Cert_Extension9Key_Usage4copyEv:
   56|     10|      std::unique_ptr<Certificate_Extension> copy() const override {
   57|     10|         return std::make_unique<Key_Usage>(m_constraints);
   58|     10|      }
_ZN5Botan14Cert_Extension9Key_UsageC2ENS_15Key_ConstraintsE:
   60|     10|      explicit Key_Usage(Key_Constraints c) : m_constraints(c) {}
_ZN5Botan14Cert_Extension9Key_UsageC2Ev:
   62|    715|      explicit Key_Usage() : m_constraints(Key_Constraints::None) {}
_ZNK5Botan14Cert_Extension9Key_Usage15get_constraintsEv:
   64|    213|      Key_Constraints get_constraints() const { return m_constraints; }
_ZN5Botan14Cert_Extension9Key_Usage10static_oidEv:
   66|  15.1k|      static OID static_oid() { return OID("2.5.29.15"); }
_ZNK5Botan14Cert_Extension9Key_Usage8oid_nameEv:
   71|    213|      std::string oid_name() const override { return "X509v3.KeyUsage"; }
_ZN5Botan14Cert_Extension14Subject_Key_IDC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
   88|     72|      explicit Subject_Key_ID(const std::vector<uint8_t>& k) : m_key_id(k) {}
_ZNK5Botan14Cert_Extension14Subject_Key_ID4copyEv:
   92|     72|      std::unique_ptr<Certificate_Extension> copy() const override {
   93|     72|         return std::make_unique<Subject_Key_ID>(m_key_id);
   94|     72|      }
_ZNK5Botan14Cert_Extension14Subject_Key_ID10get_key_idEv:
   96|    316|      const std::vector<uint8_t>& get_key_id() const { return m_key_id; }
_ZN5Botan14Cert_Extension14Subject_Key_ID10static_oidEv:
   98|  15.8k|      static OID static_oid() { return OID("2.5.29.14"); }
_ZNK5Botan14Cert_Extension14Subject_Key_ID8oid_nameEv:
  103|    316|      std::string oid_name() const override { return "X509v3.SubjectKeyIdentifier"; }
_ZNK5Botan14Cert_Extension16Authority_Key_ID4copyEv:
  118|     59|      std::unique_ptr<Certificate_Extension> copy() const override {
  119|     59|         return std::make_unique<Authority_Key_ID>(m_key_id);
  120|     59|      }
_ZN5Botan14Cert_Extension16Authority_Key_IDC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  124|     59|      explicit Authority_Key_ID(const std::vector<uint8_t>& k) : m_key_id(k) {}
_ZNK5Botan14Cert_Extension16Authority_Key_ID8oid_nameEv:
  133|    153|      std::string oid_name() const override { return "X509v3.AuthorityKeyIdentifier"; }
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name12get_alt_nameEv:
  148|    173|      const AlternativeName& get_alt_name() const { return m_alt_name; }
_ZN5Botan14Cert_Extension24Subject_Alternative_Name10static_oidEv:
  150|  14.4k|      static OID static_oid() { return OID("2.5.29.17"); }
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name4copyEv:
  154|     17|      std::unique_ptr<Certificate_Extension> copy() const override {
  155|     17|         return std::make_unique<Subject_Alternative_Name>(get_alt_name());
  156|     17|      }
_ZN5Botan14Cert_Extension24Subject_Alternative_NameC2ERKNS_15AlternativeNameE:
  158|    965|      explicit Subject_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension24Subject_Alternative_Name8oid_nameEv:
  161|    156|      std::string oid_name() const override { return "X509v3.SubjectAlternativeName"; }
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name12get_alt_nameEv:
  176|     43|      const AlternativeName& get_alt_name() const { return m_alt_name; }
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name10static_oidEv:
  178|  13.5k|      static OID static_oid() { return OID("2.5.29.18"); }
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name4copyEv:
  182|      9|      std::unique_ptr<Certificate_Extension> copy() const override {
  183|      9|         return std::make_unique<Issuer_Alternative_Name>(get_alt_name());
  184|      9|      }
_ZN5Botan14Cert_Extension23Issuer_Alternative_NameC2ERKNS_15AlternativeNameE:
  186|    345|      explicit Issuer_Alternative_Name(const AlternativeName& name = AlternativeName()) : m_alt_name(name) {}
_ZNK5Botan14Cert_Extension23Issuer_Alternative_Name8oid_nameEv:
  189|     34|      std::string oid_name() const override { return "X509v3.IssuerAlternativeName"; }
_ZNK5Botan14Cert_Extension18Extended_Key_Usage4copyEv:
  204|      7|      std::unique_ptr<Certificate_Extension> copy() const override {
  205|      7|         return std::make_unique<Extended_Key_Usage>(m_oids);
  206|      7|      }
_ZN5Botan14Cert_Extension18Extended_Key_UsageC2ERKNSt3__16vectorINS_3OIDENS2_9allocatorIS4_EEEE:
  210|      7|      explicit Extended_Key_Usage(const std::vector<OID>& o) : m_oids(o) {}
_ZNK5Botan14Cert_Extension18Extended_Key_Usage18object_identifiersEv:
  212|     76|      const std::vector<OID>& object_identifiers() const { return m_oids; }
_ZN5Botan14Cert_Extension18Extended_Key_Usage10static_oidEv:
  214|  10.1k|      static OID static_oid() { return OID("2.5.29.37"); }
_ZNK5Botan14Cert_Extension18Extended_Key_Usage8oid_nameEv:
  219|     76|      std::string oid_name() const override { return "X509v3.ExtendedKeyUsage"; }
_ZNK5Botan14Cert_Extension16Name_Constraints20get_name_constraintsEv:
  248|      7|      const NameConstraints& get_name_constraints() const { return m_name_constraints; }
_ZN5Botan14Cert_Extension16Name_Constraints10static_oidEv:
  250|  11.7k|      static OID static_oid() { return OID("2.5.29.30"); }
_ZNK5Botan14Cert_Extension16Name_Constraints8oid_nameEv:
  255|      7|      std::string oid_name() const override { return "X509v3.NameConstraints"; }
_ZNK5Botan14Cert_Extension20Certificate_Policies4copyEv:
  270|      4|      std::unique_ptr<Certificate_Extension> copy() const override {
  271|      4|         return std::make_unique<Certificate_Policies>(m_oids);
  272|      4|      }
_ZN5Botan14Cert_Extension20Certificate_PoliciesC2ERKNSt3__16vectorINS_3OIDENS2_9allocatorIS4_EEEE:
  276|      4|      explicit Certificate_Policies(const std::vector<OID>& o) : m_oids(o) {}
_ZNK5Botan14Cert_Extension20Certificate_Policies15get_policy_oidsEv:
  278|     63|      const std::vector<OID>& get_policy_oids() const { return m_oids; }
_ZN5Botan14Cert_Extension20Certificate_Policies10static_oidEv:
  280|  10.4k|      static OID static_oid() { return OID("2.5.29.32"); }
_ZNK5Botan14Cert_Extension20Certificate_Policies8oid_nameEv:
  291|     63|      std::string oid_name() const override { return "X509v3.CertificatePolicies"; }
_ZNK5Botan14Cert_Extension28Authority_Information_Access4copyEv:
  306|     10|      std::unique_ptr<Certificate_Extension> copy() const override {
  307|     10|         return std::make_unique<Authority_Information_Access>(m_ocsp_responder, m_ca_issuers);
  308|     10|      }
_ZN5Botan14Cert_Extension28Authority_Information_AccessC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS2_6vectorINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS9_ISB_EEEE:
  314|     10|            m_ocsp_responder(ocsp), m_ca_issuers(ca_issuers) {}
_ZNK5Botan14Cert_Extension28Authority_Information_Access14ocsp_responderEv:
  316|     46|      std::string ocsp_responder() const { return m_ocsp_responder; }
_ZN5Botan14Cert_Extension28Authority_Information_Access10static_oidEv:
  318|  9.76k|      static OID static_oid() { return OID("1.3.6.1.5.5.7.1.1"); }
_ZNK5Botan14Cert_Extension28Authority_Information_Access10ca_issuersEv:
  322|     46|      const std::vector<std::string>& ca_issuers() const { return m_ca_issuers; }
_ZNK5Botan14Cert_Extension28Authority_Information_Access8oid_nameEv:
  325|     46|      std::string oid_name() const override { return "PKIX.AuthorityInformationAccess"; }
_ZN5Botan14Cert_Extension10CRL_NumberC2Ev:
  343|     75|      CRL_Number() : m_has_value(false), m_crl_number(0) {}
_ZN5Botan14Cert_Extension10CRL_NumberC2Em:
  345|      3|      CRL_Number(size_t n) : m_has_value(true), m_crl_number(n) {}
_ZNK5Botan14Cert_Extension14CRL_ReasonCode4copyEv:
  370|      3|      std::unique_ptr<Certificate_Extension> copy() const override {
  371|      3|         return std::make_unique<CRL_ReasonCode>(m_reason);
  372|      3|      }
_ZN5Botan14Cert_Extension14CRL_ReasonCodeC2ENS_8CRL_CodeE:
  374|    172|      explicit CRL_ReasonCode(CRL_Code r = CRL_Code::Unspecified) : m_reason(r) {}
_ZN5Botan14Cert_Extension14CRL_ReasonCode10static_oidEv:
  378|  7.87k|      static OID static_oid() { return OID("2.5.29.21"); }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_PointC2ERKNS_15AlternativeNameE:
  404|    586|            explicit Distribution_Point(const AlternativeName& name = AlternativeName()) : m_point(name) {}
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points4copyEv:
  412|      5|      std::unique_ptr<Certificate_Extension> copy() const override {
  413|      5|         return std::make_unique<CRL_Distribution_Points>(m_distribution_points);
  414|      5|      }
_ZN5Botan14Cert_Extension23CRL_Distribution_PointsC2ERKNSt3__16vectorINS1_18Distribution_PointENS2_9allocatorIS4_EEEE:
  418|      5|      explicit CRL_Distribution_Points(const std::vector<Distribution_Point>& points) : m_distribution_points(points) {}
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points21crl_distribution_urlsEv:
  422|     72|      const std::vector<std::string>& crl_distribution_urls() const { return m_crl_distribution_urls; }
_ZN5Botan14Cert_Extension23CRL_Distribution_Points10static_oidEv:
  424|  11.1k|      static OID static_oid() { return OID("2.5.29.31"); }
_ZNK5Botan14Cert_Extension23CRL_Distribution_Points8oid_nameEv:
  429|     72|      std::string oid_name() const override { return "X509v3.CRLDistributionPoints"; }
_ZN5Botan14Cert_Extension17Unknown_ExtensionC2ERKNS_3OIDEb:
  509|  9.62k|      Unknown_Extension(const OID& oid, bool critical) : m_oid(oid), m_critical(critical) {}
_ZNK5Botan14Cert_Extension17Unknown_Extension4copyEv:
  511|    425|      std::unique_ptr<Certificate_Extension> copy() const override {
  512|    425|         return std::make_unique<Unknown_Extension>(m_oid, m_critical);
  513|    425|      }
_ZN5Botan14Cert_Extension17Unknown_Extension8validateERKNS_16X509_CertificateES4_RKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEERNS6_INS5_3setINS_23Certificate_Status_CodeENS5_4lessISD_EENS7_ISD_EEEENS7_ISH_EEEEm:
  536|    425|                    size_t pos) override {
  537|    425|         if(m_critical) {
  ------------------
  |  Branch (537:13): [True: 85, False: 340]
  ------------------
  538|     85|            cert_status.at(pos).insert(Certificate_Status_Code::UNKNOWN_CRITICAL_EXTENSION);
  539|     85|         }
  540|    425|      }
_ZNK5Botan14Cert_Extension17Unknown_Extension8oid_nameEv:
  543|  1.30k|      std::string oid_name() const override { return ""; }
_ZN5Botan14Cert_Extension14Subject_Key_IDC2Ev:
   86|    657|      Subject_Key_ID() = default;
_ZN5Botan14Cert_Extension16Authority_Key_IDC2Ev:
  122|    455|      Authority_Key_ID() = default;
_ZN5Botan14Cert_Extension16Name_ConstraintsC2Ev:
  238|    578|      Name_Constraints() = default;
_ZN5Botan14Cert_Extension23CRL_Distribution_PointsC2Ev:
  416|    513|      CRL_Distribution_Points() = default;
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_PointC2Ev:
  446|    132|      CRL_Issuing_Distribution_Point() = default;
_ZN5Botan14Cert_Extension20Certificate_PoliciesC2Ev:
  274|    329|      Certificate_Policies() = default;
_ZN5Botan14Cert_Extension18Extended_Key_UsageC2Ev:
  208|    385|      Extended_Key_Usage() = default;
_ZN5Botan14Cert_Extension28Authority_Information_AccessC2Ev:
  310|    203|      Authority_Information_Access() = default;

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

_ZN5Botan11X509_ObjectD2Ev:
  103|  21.1k|      ~X509_Object() override = default;
_ZNK5Botan11X509_Object9signatureEv:
   37|  6.18k|      const std::vector<uint8_t>& signature() const { return m_sig; }
_ZNK5Botan11X509_Object11signed_bodyEv:
   42|  10.6k|      const std::vector<uint8_t>& signed_body() const { return m_tbs_bits; }
_ZNK5Botan11X509_Object19signature_algorithmEv:
   47|  12.0k|      const AlgorithmIdentifier& signature_algorithm() const { return m_sig_algo; }
_ZN5Botan11X509_ObjectC2ERKS0_:
   96|  11.0k|      X509_Object(const X509_Object&) = default;
_ZN5Botan11X509_ObjectC2Ev:
  121|  10.0k|      X509_Object() = default;

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

_ZNK5Botan28Path_Validation_Restrictions30require_revocation_informationEv:
   93|    145|      bool require_revocation_information() const { return m_require_revocation_information; }
_ZNK5Botan28Path_Validation_Restrictions22ocsp_all_intermediatesEv:
   99|    145|      bool ocsp_all_intermediates() const { return m_ocsp_all_intermediates; }
_ZNK5Botan28Path_Validation_Restrictions14trusted_hashesEv:
  104|      8|      const std::set<std::string>& trusted_hashes() const { return m_trusted_hashes; }
_ZNK5Botan28Path_Validation_Restrictions20minimum_key_strengthEv:
  109|    278|      size_t minimum_key_strength() const { return m_minimum_key_strength; }
_ZNK5Botan22Path_Validation_Result6resultEv:
  165|    435|      Certificate_Status_Code result() const { return m_overall; }
_ZN5Botan22Path_Validation_ResultC2ENS_23Certificate_Status_CodeE:
  204|    397|      explicit Path_Validation_Result(Certificate_Status_Code status) : m_overall(status) {}

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|  6.40k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t in[], size_t len) {
   35|  6.40k|   if(len <= max_fuzzer_input_size) {
  ------------------
  |  Branch (35:7): [True: 6.39k, False: 9]
  ------------------
   36|  6.39k|      fuzz(in, len);
   37|  6.39k|   }
   38|  6.40k|   return 0;
   39|  6.40k|}

_Z4fuzzPKhm:
   13|  6.39k|void fuzz(const uint8_t in[], size_t len) {
   14|  6.39k|   Botan::DataSource_Memory input(in, len);
   15|       |
   16|  6.39k|   try {
   17|  6.39k|      Botan::X509_Certificate subject(input);
   18|  6.39k|      Botan::X509_Certificate issuer(input);
   19|       |
   20|  6.39k|      std::vector<Botan::Certificate_Store*> roots;
   21|  6.39k|      std::unique_ptr<Botan::Certificate_Store> root_store(new Botan::Certificate_Store_In_Memory(issuer));
   22|  6.39k|      roots.push_back(root_store.get());
   23|       |
   24|  6.39k|      Botan::Path_Validation_Restrictions restrictions;
   25|       |
   26|  6.39k|      x509_path_validate({subject}, restrictions, roots);
   27|  6.39k|   } catch(Botan::Exception& e) {}
   28|  6.39k|}

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

_ZNK5Botan11ASN1_Object10BER_encodeEv:
   19|  4.52k|std::vector<uint8_t> ASN1_Object::BER_encode() const {
   20|  4.52k|   std::vector<uint8_t> output;
   21|  4.52k|   DER_Encoder der(output);
   22|  4.52k|   this->encode_into(der);
   23|  4.52k|   return output;
   24|  4.52k|}
_ZNK5Botan10BER_Object11assert_is_aENS_9ASN1_TypeENS_10ASN1_ClassENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   29|   177k|void BER_Object::assert_is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag, std::string_view descr) const {
   30|   177k|   if(this->is_a(expected_type_tag, expected_class_tag) == false) {
  ------------------
  |  Branch (30:7): [True: 2.91k, False: 174k]
  ------------------
   31|  2.91k|      std::stringstream msg;
   32|       |
   33|  2.91k|      msg << "Tag mismatch when decoding " << descr << " got ";
   34|       |
   35|  2.91k|      if(m_class_tag == ASN1_Class::NoObject && m_type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (35:10): [True: 665, False: 2.25k]
  |  Branch (35:49): [True: 665, False: 0]
  ------------------
   36|    665|         msg << "EOF";
   37|  2.25k|      } else {
   38|  2.25k|         if(m_class_tag == ASN1_Class::Universal || m_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (38:13): [True: 699, False: 1.55k]
  |  Branch (38:53): [True: 964, False: 587]
  ------------------
   39|  1.66k|            msg << asn1_tag_to_string(m_type_tag);
   40|  1.66k|         } else {
   41|    587|            msg << std::to_string(static_cast<uint32_t>(m_type_tag));
   42|    587|         }
   43|       |
   44|  2.25k|         msg << "/" << asn1_class_to_string(m_class_tag);
   45|  2.25k|      }
   46|       |
   47|  2.91k|      msg << " expected ";
   48|       |
   49|  2.91k|      if(expected_class_tag == ASN1_Class::Universal || expected_class_tag == ASN1_Class::Constructed) {
  ------------------
  |  Branch (49:10): [True: 763, False: 2.15k]
  |  Branch (49:57): [True: 2.07k, False: 75]
  ------------------
   50|  2.84k|         msg << asn1_tag_to_string(expected_type_tag);
   51|  2.84k|      } else {
   52|     75|         msg << std::to_string(static_cast<uint32_t>(expected_type_tag));
   53|     75|      }
   54|       |
   55|  2.91k|      msg << "/" << asn1_class_to_string(expected_class_tag);
   56|       |
   57|  2.91k|      throw BER_Decoding_Error(msg.str());
   58|  2.91k|   }
   59|   177k|}
_ZNK5Botan10BER_Object4is_aENS_9ASN1_TypeENS_10ASN1_ClassE:
   61|   316k|bool BER_Object::is_a(ASN1_Type expected_type_tag, ASN1_Class expected_class_tag) const {
   62|   316k|   return (m_type_tag == expected_type_tag && m_class_tag == expected_class_tag);
  ------------------
  |  Branch (62:12): [True: 199k, False: 117k]
  |  Branch (62:47): [True: 196k, False: 2.69k]
  ------------------
   63|   316k|}
_ZNK5Botan10BER_Object4is_aEiNS_10ASN1_ClassE:
   65|   109k|bool BER_Object::is_a(int expected_type_tag, ASN1_Class expected_class_tag) const {
   66|   109k|   return is_a(ASN1_Type(expected_type_tag), expected_class_tag);
   67|   109k|}
_ZN5Botan10BER_Object11set_taggingENS_9ASN1_TypeENS_10ASN1_ClassE:
   69|   331k|void BER_Object::set_tagging(ASN1_Type type_tag, ASN1_Class class_tag) {
   70|   331k|   m_type_tag = type_tag;
   71|   331k|   m_class_tag = class_tag;
   72|   331k|}
_ZN5Botan20asn1_class_to_stringENS_10ASN1_ClassE:
   74|  5.16k|std::string asn1_class_to_string(ASN1_Class type) {
   75|  5.16k|   switch(type) {
   76|  1.46k|      case ASN1_Class::Universal:
  ------------------
  |  Branch (76:7): [True: 1.46k, False: 3.70k]
  ------------------
   77|  1.46k|         return "UNIVERSAL";
   78|  3.04k|      case ASN1_Class::Constructed:
  ------------------
  |  Branch (78:7): [True: 3.04k, False: 2.12k]
  ------------------
   79|  3.04k|         return "CONSTRUCTED";
   80|     98|      case ASN1_Class::ContextSpecific:
  ------------------
  |  Branch (80:7): [True: 98, False: 5.06k]
  ------------------
   81|     98|         return "CONTEXT_SPECIFIC";
   82|    111|      case ASN1_Class::Application:
  ------------------
  |  Branch (82:7): [True: 111, False: 5.05k]
  ------------------
   83|    111|         return "APPLICATION";
   84|     89|      case ASN1_Class::Private:
  ------------------
  |  Branch (84:7): [True: 89, False: 5.07k]
  ------------------
   85|     89|         return "PRIVATE";
   86|      0|      case ASN1_Class::NoObject:
  ------------------
  |  Branch (86:7): [True: 0, False: 5.16k]
  ------------------
   87|      0|         return "NO_OBJECT";
   88|    364|      default:
  ------------------
  |  Branch (88:7): [True: 364, False: 4.80k]
  ------------------
   89|    364|         return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
   90|  5.16k|   }
   91|  5.16k|}
_ZN5Botan18asn1_tag_to_stringENS_9ASN1_TypeE:
   93|  4.53k|std::string asn1_tag_to_string(ASN1_Type type) {
   94|  4.53k|   switch(type) {
   95|  2.26k|      case ASN1_Type::Sequence:
  ------------------
  |  Branch (95:7): [True: 2.26k, False: 2.27k]
  ------------------
   96|  2.26k|         return "SEQUENCE";
   97|       |
   98|    275|      case ASN1_Type::Set:
  ------------------
  |  Branch (98:7): [True: 275, False: 4.26k]
  ------------------
   99|    275|         return "SET";
  100|       |
  101|     67|      case ASN1_Type::PrintableString:
  ------------------
  |  Branch (101:7): [True: 67, False: 4.47k]
  ------------------
  102|     67|         return "PRINTABLE STRING";
  103|       |
  104|     75|      case ASN1_Type::NumericString:
  ------------------
  |  Branch (104:7): [True: 75, False: 4.46k]
  ------------------
  105|     75|         return "NUMERIC STRING";
  106|       |
  107|     34|      case ASN1_Type::Ia5String:
  ------------------
  |  Branch (107:7): [True: 34, False: 4.50k]
  ------------------
  108|     34|         return "IA5 STRING";
  109|       |
  110|     52|      case ASN1_Type::TeletexString:
  ------------------
  |  Branch (110:7): [True: 52, False: 4.48k]
  ------------------
  111|     52|         return "T61 STRING";
  112|       |
  113|     35|      case ASN1_Type::Utf8String:
  ------------------
  |  Branch (113:7): [True: 35, False: 4.50k]
  ------------------
  114|     35|         return "UTF8 STRING";
  115|       |
  116|     19|      case ASN1_Type::VisibleString:
  ------------------
  |  Branch (116:7): [True: 19, False: 4.52k]
  ------------------
  117|     19|         return "VISIBLE STRING";
  118|       |
  119|     14|      case ASN1_Type::BmpString:
  ------------------
  |  Branch (119:7): [True: 14, False: 4.52k]
  ------------------
  120|     14|         return "BMP STRING";
  121|       |
  122|     14|      case ASN1_Type::UniversalString:
  ------------------
  |  Branch (122:7): [True: 14, False: 4.52k]
  ------------------
  123|     14|         return "UNIVERSAL STRING";
  124|       |
  125|     27|      case ASN1_Type::UtcTime:
  ------------------
  |  Branch (125:7): [True: 27, False: 4.51k]
  ------------------
  126|     27|         return "UTC TIME";
  127|       |
  128|     48|      case ASN1_Type::GeneralizedTime:
  ------------------
  |  Branch (128:7): [True: 48, False: 4.49k]
  ------------------
  129|     48|         return "GENERALIZED TIME";
  130|       |
  131|    247|      case ASN1_Type::OctetString:
  ------------------
  |  Branch (131:7): [True: 247, False: 4.29k]
  ------------------
  132|    247|         return "OCTET STRING";
  133|       |
  134|    344|      case ASN1_Type::BitString:
  ------------------
  |  Branch (134:7): [True: 344, False: 4.19k]
  ------------------
  135|    344|         return "BIT STRING";
  136|       |
  137|     97|      case ASN1_Type::Enumerated:
  ------------------
  |  Branch (137:7): [True: 97, False: 4.44k]
  ------------------
  138|     97|         return "ENUMERATED";
  139|       |
  140|    329|      case ASN1_Type::Integer:
  ------------------
  |  Branch (140:7): [True: 329, False: 4.21k]
  ------------------
  141|    329|         return "INTEGER";
  142|       |
  143|     50|      case ASN1_Type::Null:
  ------------------
  |  Branch (143:7): [True: 50, False: 4.48k]
  ------------------
  144|     50|         return "NULL";
  145|       |
  146|     34|      case ASN1_Type::ObjectId:
  ------------------
  |  Branch (146:7): [True: 34, False: 4.50k]
  ------------------
  147|     34|         return "OBJECT";
  148|       |
  149|     69|      case ASN1_Type::Boolean:
  ------------------
  |  Branch (149:7): [True: 69, False: 4.47k]
  ------------------
  150|     69|         return "BOOLEAN";
  151|       |
  152|      3|      case ASN1_Type::NoObject:
  ------------------
  |  Branch (152:7): [True: 3, False: 4.53k]
  ------------------
  153|      3|         return "NO_OBJECT";
  154|       |
  155|    446|      default:
  ------------------
  |  Branch (155:7): [True: 446, False: 4.09k]
  ------------------
  156|    446|         return "TAG(" + std::to_string(static_cast<uint32_t>(type)) + ")";
  157|  4.53k|   }
  158|  4.53k|}
_ZN5Botan18BER_Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  163|  6.08k|BER_Decoding_Error::BER_Decoding_Error(std::string_view str) : Decoding_Error(fmt("BER: {}", str)) {}
_ZN5Botan11BER_Bad_TagC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEj:
  165|    241|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|  17.2k|std::vector<uint8_t> put_in_sequence(const std::vector<uint8_t>& contents) {
  173|  17.2k|   return ASN1::put_in_sequence(contents.data(), contents.size());
  174|  17.2k|}
_ZN5Botan4ASN115put_in_sequenceEPKhm:
  176|  17.2k|std::vector<uint8_t> put_in_sequence(const uint8_t bits[], size_t len) {
  177|  17.2k|   std::vector<uint8_t> output;
  178|  17.2k|   DER_Encoder(output).start_sequence().raw_bytes(bits, len).end_cons();
  179|  17.2k|   return output;
  180|  17.2k|}
_ZN5Botan4ASN19to_stringERKNS_10BER_ObjectE:
  185|  37.7k|std::string to_string(const BER_Object& obj) {
  186|  37.7k|   return std::string(cast_uint8_ptr_to_char(obj.bits()), obj.length());
  187|  37.7k|}
_ZN5Botan4ASN19maybe_BERERNS_10DataSourceE:
  192|  13.9k|bool maybe_BER(DataSource& source) {
  193|  13.9k|   uint8_t first_u8;
  194|  13.9k|   if(!source.peek_byte(first_u8)) {
  ------------------
  |  Branch (194:7): [True: 2.60k, False: 11.3k]
  ------------------
  195|  2.60k|      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
  ------------------
  |  |   69|  2.60k|   do {                                                                                                \
  |  |   70|  2.60k|      if((expr1) != (expr2))                                                                           \
  |  |  ------------------
  |  |  |  Branch (70:10): [True: 0, False: 2.60k]
  |  |  ------------------
  |  |   71|  2.60k|         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   72|  2.60k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  196|  2.60k|      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
  197|  2.60k|   }
  198|       |
  199|  11.3k|   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
  200|  11.3k|   if(first_u8 == cons_seq) {
  ------------------
  |  Branch (200:7): [True: 10.5k, False: 833]
  ------------------
  201|  10.5k|      return true;
  202|  10.5k|   }
  203|    833|   return false;
  204|  11.3k|}

_ZN5Botan3OID11from_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   74|    669|OID OID::from_string(std::string_view str) {
   75|    669|   if(str.empty()) {
  ------------------
  |  Branch (75:7): [True: 0, False: 669]
  ------------------
   76|      0|      throw Invalid_Argument("OID::from_string argument must be non-empty");
   77|      0|   }
   78|       |
   79|    669|   OID o = OID_Map::global_registry().str2oid(str);
   80|    669|   if(o.has_value()) {
  ------------------
  |  Branch (80:7): [True: 669, False: 0]
  ------------------
   81|    669|      return o;
   82|    669|   }
   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|   159k|OID::OID(std::string_view oid_str) {
   97|   159k|   if(!oid_str.empty()) {
  ------------------
  |  Branch (97:7): [True: 159k, False: 0]
  ------------------
   98|   159k|      m_id = parse_oid_str(oid_str);
   99|   159k|      if(m_id.size() < 2 || m_id[0] > 2 || (m_id[0] < 2 && m_id[1] > 39)) {
  ------------------
  |  Branch (99:10): [True: 0, False: 159k]
  |  Branch (99:29): [True: 0, False: 159k]
  |  Branch (99:45): [True: 9.79k, False: 149k]
  |  Branch (99:60): [True: 0, False: 9.79k]
  ------------------
  100|      0|         throw Decoding_Error(fmt("Invalid OID '{}'", oid_str));
  101|      0|      }
  102|   159k|   }
  103|   159k|}
_ZNK5Botan3OID9to_stringEv:
  108|  21.4k|std::string OID::to_string() const {
  109|  21.4k|   std::ostringstream out;
  110|  21.4k|   out << (*this);
  111|  21.4k|   return out.str();
  112|  21.4k|}
_ZNK5Botan3OID19to_formatted_stringEv:
  114|  7.77k|std::string OID::to_formatted_string() const {
  115|  7.77k|   std::string s = this->human_name_or_empty();
  116|  7.77k|   if(!s.empty()) {
  ------------------
  |  Branch (116:7): [True: 5.80k, False: 1.97k]
  ------------------
  117|  5.80k|      return s;
  118|  5.80k|   }
  119|  1.97k|   return this->to_string();
  120|  7.77k|}
_ZNK5Botan3OID19human_name_or_emptyEv:
  122|  8.06k|std::string OID::human_name_or_empty() const {
  123|  8.06k|   return OID_Map::global_registry().oid2str(*this);
  124|  8.06k|}
_ZNK5Botan3OID14registered_oidEv:
  126|    290|bool OID::registered_oid() const {
  127|    290|   return !human_name_or_empty().empty();
  128|    290|}
_ZN5BotanltERKNS_3OIDES2_:
  133|   114k|bool operator<(const OID& a, const OID& b) {
  134|   114k|   const std::vector<uint32_t>& oid1 = a.get_components();
  135|   114k|   const std::vector<uint32_t>& oid2 = b.get_components();
  136|       |
  137|   114k|   return std::lexicographical_compare(oid1.begin(), oid1.end(), oid2.begin(), oid2.end());
  138|   114k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_3OIDE:
  140|  21.5k|std::ostream& operator<<(std::ostream& out, const OID& oid) {
  141|  21.5k|   const auto& val = oid.get_components();
  142|       |
  143|   154k|   for(size_t i = 0; i != val.size(); ++i) {
  ------------------
  |  Branch (143:22): [True: 133k, False: 21.5k]
  ------------------
  144|       |      // avoid locale issues with integer formatting
  145|   133k|      out << std::to_string(val[i]);
  146|   133k|      if(i != val.size() - 1) {
  ------------------
  |  Branch (146:10): [True: 111k, False: 21.5k]
  ------------------
  147|   111k|         out << ".";
  148|   111k|      }
  149|   133k|   }
  150|       |
  151|  21.5k|   return out;
  152|  21.5k|}
_ZNK5Botan3OID11encode_intoERNS_11DER_EncoderE:
  157|  4.52k|void OID::encode_into(DER_Encoder& der) const {
  158|  4.52k|   if(m_id.size() < 2) {
  ------------------
  |  Branch (158:7): [True: 0, False: 4.52k]
  ------------------
  159|      0|      throw Invalid_Argument("OID::encode_into: OID is invalid");
  160|      0|   }
  161|       |
  162|  4.52k|   std::vector<uint8_t> encoding;
  163|       |
  164|  4.52k|   if(m_id[0] > 2 || m_id[1] >= 40) {
  ------------------
  |  Branch (164:7): [True: 8, False: 4.52k]
  |  Branch (164:22): [True: 0, False: 4.52k]
  ------------------
  165|      8|      throw Encoding_Error("Invalid OID prefix, cannot encode");
  166|      8|   }
  167|       |
  168|  4.52k|   encoding.push_back(static_cast<uint8_t>(40 * m_id[0] + m_id[1]));
  169|       |
  170|  24.6k|   for(size_t i = 2; i != m_id.size(); ++i) {
  ------------------
  |  Branch (170:22): [True: 20.1k, False: 4.52k]
  ------------------
  171|  20.1k|      if(m_id[i] == 0) {
  ------------------
  |  Branch (171:10): [True: 467, False: 19.6k]
  ------------------
  172|    467|         encoding.push_back(0);
  173|  19.6k|      } else {
  174|  19.6k|         size_t blocks = high_bit(m_id[i]) + 6;
  175|  19.6k|         blocks = (blocks - (blocks % 7)) / 7;
  176|       |
  177|  19.6k|         BOTAN_ASSERT(blocks > 0, "Math works");
  ------------------
  |  |   51|  19.6k|   do {                                                                                 \
  |  |   52|  19.6k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 19.6k]
  |  |  ------------------
  |  |   53|  19.6k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  19.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  178|       |
  179|  28.9k|         for(size_t j = 0; j != blocks - 1; ++j) {
  ------------------
  |  Branch (179:28): [True: 9.32k, False: 19.6k]
  ------------------
  180|  9.32k|            encoding.push_back(0x80 | ((m_id[i] >> 7 * (blocks - j - 1)) & 0x7F));
  181|  9.32k|         }
  182|  19.6k|         encoding.push_back(m_id[i] & 0x7F);
  183|  19.6k|      }
  184|  20.1k|   }
  185|  4.52k|   der.add_object(ASN1_Type::ObjectId, ASN1_Class::Universal, encoding);
  186|  4.52k|}
_ZN5Botan3OID11decode_fromERNS_11BER_DecoderE:
  191|  59.7k|void OID::decode_from(BER_Decoder& decoder) {
  192|  59.7k|   BER_Object obj = decoder.get_next_object();
  193|  59.7k|   if(obj.tagging() != (ASN1_Class::Universal | ASN1_Type::ObjectId)) {
  ------------------
  |  Branch (193:7): [True: 186, False: 59.5k]
  ------------------
  194|    186|      throw BER_Bad_Tag("Error decoding OID, unknown tag", obj.tagging());
  195|    186|   }
  196|       |
  197|  59.5k|   const size_t length = obj.length();
  198|  59.5k|   const uint8_t* bits = obj.bits();
  199|       |
  200|  59.5k|   if(length < 2 && !(length == 1 && bits[0] == 0)) {
  ------------------
  |  Branch (200:7): [True: 2.25k, False: 57.3k]
  |  Branch (200:23): [True: 2.23k, False: 20]
  |  Branch (200:38): [True: 2.21k, False: 19]
  ------------------
  201|     39|      throw BER_Decoding_Error("OID encoding is too short");
  202|     39|   }
  203|       |
  204|  59.5k|   m_id.clear();
  205|  59.5k|   m_id.push_back(bits[0] / 40);
  206|  59.5k|   m_id.push_back(bits[0] % 40);
  207|       |
  208|  59.5k|   size_t i = 0;
  209|   320k|   while(i != length - 1) {
  ------------------
  |  Branch (209:10): [True: 261k, False: 59.4k]
  ------------------
  210|   261k|      uint32_t component = 0;
  211|   328k|      while(i != length - 1) {
  ------------------
  |  Branch (211:13): [True: 325k, False: 2.25k]
  ------------------
  212|   325k|         ++i;
  213|       |
  214|   325k|         if(component >> (32 - 7)) {
  ------------------
  |  Branch (214:13): [True: 59, False: 325k]
  ------------------
  215|     59|            throw Decoding_Error("OID component overflow");
  216|     59|         }
  217|       |
  218|   325k|         component = (component << 7) + (bits[i] & 0x7F);
  219|       |
  220|   325k|         if(!(bits[i] & 0x80)) {
  ------------------
  |  Branch (220:13): [True: 259k, False: 66.7k]
  ------------------
  221|   259k|            break;
  222|   259k|         }
  223|   325k|      }
  224|   261k|      m_id.push_back(component);
  225|   261k|   }
  226|  59.5k|}
asn1_oid.cpp:_ZN5Botan12_GLOBAL__N_113parse_oid_strENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   24|   159k|std::vector<uint32_t> parse_oid_str(std::string_view oid) {
   25|   159k|   try {
   26|   159k|      std::string elem;
   27|   159k|      std::vector<uint32_t> oid_elems;
   28|       |
   29|  1.51M|      for(char c : oid) {
  ------------------
  |  Branch (29:18): [True: 1.51M, False: 159k]
  ------------------
   30|  1.51M|         if(c == '.') {
  ------------------
  |  Branch (30:13): [True: 527k, False: 986k]
  ------------------
   31|   527k|            if(elem.empty()) {
  ------------------
  |  Branch (31:16): [True: 0, False: 527k]
  ------------------
   32|      0|               return std::vector<uint32_t>();
   33|      0|            }
   34|   527k|            oid_elems.push_back(to_u32bit(elem));
   35|   527k|            elem.clear();
   36|   986k|         } else {
   37|   986k|            elem += c;
   38|   986k|         }
   39|  1.51M|      }
   40|       |
   41|   159k|      if(!elem.empty()) {
  ------------------
  |  Branch (41:10): [True: 159k, False: 0]
  ------------------
   42|   159k|         oid_elems.push_back(to_u32bit(elem));
   43|   159k|      }
   44|       |
   45|   159k|      return oid_elems;
   46|   159k|   } catch(Invalid_Argument&)  // thrown by to_u32bit
   47|   159k|   {
   48|      0|      return std::vector<uint32_t>();
   49|      0|   }
   50|   159k|}

_ZN5Botan11ASN1_String14is_string_typeENS_9ASN1_TypeE:
   60|    795|bool ASN1_String::is_string_type(ASN1_Type tag) {
   61|    795|   return is_asn1_string_type(tag);
   62|    795|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
   64|  23.9k|ASN1_String::ASN1_String(std::string_view str, ASN1_Type t) : m_utf8_str(str), m_tag(t) {
   65|  23.9k|   if(!is_utf8_subset_string_type(m_tag)) {
  ------------------
  |  Branch (65:7): [True: 3, False: 23.9k]
  ------------------
   66|      3|      throw Invalid_Argument("ASN1_String only supports encoding to UTF-8 or a UTF-8 subset");
   67|      3|   }
   68|  23.9k|}
_ZN5Botan11ASN1_StringC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   70|  23.3k|ASN1_String::ASN1_String(std::string_view str) : ASN1_String(str, choose_encoding(str)) {}
_ZN5Botan11ASN1_String11decode_fromERNS_11BER_DecoderE:
   88|  23.2k|void ASN1_String::decode_from(BER_Decoder& source) {
   89|  23.2k|   BER_Object obj = source.get_next_object();
   90|       |
   91|  23.2k|   if(!is_asn1_string_type(obj.type())) {
  ------------------
  |  Branch (91:7): [True: 72, False: 23.1k]
  ------------------
   92|     72|      auto typ = static_cast<uint32_t>(obj.type());
   93|     72|      throw Decoding_Error(fmt("ASN1_String: Unknown string type {}", typ));
   94|     72|   }
   95|       |
   96|  23.1k|   m_tag = obj.type();
   97|  23.1k|   m_data.assign(obj.bits(), obj.bits() + obj.length());
   98|       |
   99|  23.1k|   if(m_tag == ASN1_Type::BmpString) {
  ------------------
  |  Branch (99:7): [True: 3.30k, False: 19.8k]
  ------------------
  100|  3.30k|      m_utf8_str = ucs2_to_utf8(m_data.data(), m_data.size());
  101|  19.8k|   } else if(m_tag == ASN1_Type::UniversalString) {
  ------------------
  |  Branch (101:14): [True: 137, False: 19.7k]
  ------------------
  102|    137|      m_utf8_str = ucs4_to_utf8(m_data.data(), m_data.size());
  103|  19.7k|   } else if(m_tag == ASN1_Type::TeletexString) {
  ------------------
  |  Branch (103:14): [True: 905, False: 18.8k]
  ------------------
  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|    905|      m_utf8_str = latin1_to_utf8(m_data.data(), m_data.size());
  109|  18.8k|   } else {
  110|       |      // All other supported string types are UTF-8 or some subset thereof
  111|  18.8k|      m_utf8_str = ASN1::to_string(obj);
  112|  18.8k|   }
  113|  23.1k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_119is_asn1_string_typeENS_9ASN1_TypeE:
   52|  24.0k|bool is_asn1_string_type(ASN1_Type tag) {
   53|  24.0k|   return (is_utf8_subset_string_type(tag) || tag == ASN1_Type::TeletexString || tag == ASN1_Type::BmpString ||
  ------------------
  |  Branch (53:12): [True: 19.4k, False: 4.57k]
  |  Branch (53:47): [True: 945, False: 3.63k]
  |  Branch (53:82): [True: 3.33k, False: 294]
  ------------------
   54|  24.0k|           tag == ASN1_Type::UniversalString);
  ------------------
  |  Branch (54:12): [True: 138, False: 156]
  ------------------
   55|  24.0k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_126is_utf8_subset_string_typeENS_9ASN1_TypeE:
   47|  48.0k|bool is_utf8_subset_string_type(ASN1_Type tag) {
   48|  48.0k|   return (tag == ASN1_Type::NumericString || tag == ASN1_Type::PrintableString || tag == ASN1_Type::VisibleString ||
  ------------------
  |  Branch (48:12): [True: 555, False: 47.4k]
  |  Branch (48:47): [True: 35.9k, False: 11.4k]
  |  Branch (48:84): [True: 324, False: 11.1k]
  ------------------
   49|  48.0k|           tag == ASN1_Type::Ia5String || tag == ASN1_Type::Utf8String);
  ------------------
  |  Branch (49:12): [True: 2.45k, False: 8.69k]
  |  Branch (49:43): [True: 4.11k, False: 4.58k]
  ------------------
   50|  48.0k|}
asn1_str.cpp:_ZN5Botan12_GLOBAL__N_115choose_encodingENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   23|  23.3k|ASN1_Type choose_encoding(std::string_view str) {
   24|  23.3k|   auto all_printable = CT::Mask<uint8_t>::set();
   25|       |
   26|  23.3k|   for(size_t i = 0; i != str.size(); ++i) {
  ------------------
  |  Branch (26:22): [True: 0, False: 23.3k]
  ------------------
   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|  23.3k|   if(all_printable.as_bool()) {
  ------------------
  |  Branch (40:7): [True: 23.3k, False: 0]
  ------------------
   41|  23.3k|      return ASN1_Type::PrintableString;
   42|  23.3k|   } else {
   43|      0|      return ASN1_Type::Utf8String;
   44|      0|   }
   45|  23.3k|}

_ZN5Botan9ASN1_TimeC2ERKNSt3__16chrono10time_pointINS2_12system_clockENS2_8durationIxNS1_5ratioILl1ELl1000000EEEEEEE:
   20|    510|ASN1_Time::ASN1_Time(const std::chrono::system_clock::time_point& time) {
   21|    510|   calendar_point cal(time);
   22|       |
   23|    510|   m_year = cal.year();
   24|    510|   m_month = cal.month();
   25|    510|   m_day = cal.day();
   26|    510|   m_hour = cal.hour();
   27|    510|   m_minute = cal.minutes();
   28|    510|   m_second = cal.seconds();
   29|       |
   30|    510|   m_tag = (m_year >= 2050) ? ASN1_Type::GeneralizedTime : ASN1_Type::UtcTime;
  ------------------
  |  Branch (30:12): [True: 0, False: 510]
  ------------------
   31|    510|}
_ZN5Botan9ASN1_Time11decode_fromERNS_11BER_DecoderE:
   53|  10.8k|void ASN1_Time::decode_from(BER_Decoder& source) {
   54|  10.8k|   BER_Object ber_time = source.get_next_object();
   55|       |
   56|  10.8k|   set_to(ASN1::to_string(ber_time), ber_time.type());
   57|  10.8k|}
_ZNK5Botan9ASN1_Time11time_is_setEv:
  106|  2.04k|bool ASN1_Time::time_is_set() const {
  107|  2.04k|   return (m_year != 0);
  108|  2.04k|}
_ZNK5Botan9ASN1_Time3cmpERKS0_:
  110|  1.02k|int32_t ASN1_Time::cmp(const ASN1_Time& other) const {
  111|  1.02k|   if(!time_is_set() || !other.time_is_set()) {
  ------------------
  |  Branch (111:7): [True: 0, False: 1.02k]
  |  Branch (111:25): [True: 0, False: 1.02k]
  ------------------
  112|      0|      throw Invalid_State("ASN1_Time::cmp: Cannot compare empty times");
  113|      0|   }
  114|       |
  115|  1.02k|   const int32_t EARLIER = -1, LATER = 1, SAME_TIME = 0;
  116|       |
  117|  1.02k|   if(m_year < other.m_year) {
  ------------------
  |  Branch (117:7): [True: 294, False: 726]
  ------------------
  118|    294|      return EARLIER;
  119|    294|   }
  120|    726|   if(m_year > other.m_year) {
  ------------------
  |  Branch (120:7): [True: 675, False: 51]
  ------------------
  121|    675|      return LATER;
  122|    675|   }
  123|     51|   if(m_month < other.m_month) {
  ------------------
  |  Branch (123:7): [True: 6, False: 45]
  ------------------
  124|      6|      return EARLIER;
  125|      6|   }
  126|     45|   if(m_month > other.m_month) {
  ------------------
  |  Branch (126:7): [True: 13, False: 32]
  ------------------
  127|     13|      return LATER;
  128|     13|   }
  129|     32|   if(m_day < other.m_day) {
  ------------------
  |  Branch (129:7): [True: 7, False: 25]
  ------------------
  130|      7|      return EARLIER;
  131|      7|   }
  132|     25|   if(m_day > other.m_day) {
  ------------------
  |  Branch (132:7): [True: 25, False: 0]
  ------------------
  133|     25|      return LATER;
  134|     25|   }
  135|      0|   if(m_hour < other.m_hour) {
  ------------------
  |  Branch (135:7): [True: 0, False: 0]
  ------------------
  136|      0|      return EARLIER;
  137|      0|   }
  138|      0|   if(m_hour > other.m_hour) {
  ------------------
  |  Branch (138:7): [True: 0, False: 0]
  ------------------
  139|      0|      return LATER;
  140|      0|   }
  141|      0|   if(m_minute < other.m_minute) {
  ------------------
  |  Branch (141:7): [True: 0, False: 0]
  ------------------
  142|      0|      return EARLIER;
  143|      0|   }
  144|      0|   if(m_minute > other.m_minute) {
  ------------------
  |  Branch (144:7): [True: 0, False: 0]
  ------------------
  145|      0|      return LATER;
  146|      0|   }
  147|      0|   if(m_second < other.m_second) {
  ------------------
  |  Branch (147:7): [True: 0, False: 0]
  ------------------
  148|      0|      return EARLIER;
  149|      0|   }
  150|      0|   if(m_second > other.m_second) {
  ------------------
  |  Branch (150:7): [True: 0, False: 0]
  ------------------
  151|      0|      return LATER;
  152|      0|   }
  153|       |
  154|      0|   return SAME_TIME;
  155|      0|}
_ZN5Botan9ASN1_Time6set_toENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS_9ASN1_TypeE:
  157|  10.8k|void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
  158|  10.8k|   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
  ------------------
  |  |   30|  10.8k|   do {                                                          \
  |  |   31|  11.2k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 10.3k, False: 417]
  |  |  |  Branch (31:12): [True: 357, False: 60]
  |  |  ------------------
  |  |   32|  10.8k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  10.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  159|  10.8k|                   "Invalid tag for ASN1_Time");
  160|       |
  161|  10.8k|   if(spec_tag == ASN1_Type::GeneralizedTime) {
  ------------------
  |  Branch (161:7): [True: 357, False: 10.4k]
  ------------------
  162|    357|      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
  ------------------
  |  |   30|    357|   do {                                                          \
  |  |   31|    357|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 9, False: 348]
  |  |  ------------------
  |  |   32|    357|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    357|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  10.4k|   } else if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (163:14): [True: 10.3k, False: 60]
  ------------------
  164|  10.3k|      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
  ------------------
  |  |   30|  10.3k|   do {                                                          \
  |  |   31|  10.3k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 11, False: 10.3k]
  |  |  ------------------
  |  |   32|  10.3k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  10.3k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  10.3k|   }
  166|       |
  167|  10.8k|   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
  ------------------
  |  |   30|  10.8k|   do {                                                          \
  |  |   31|  10.8k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 14, False: 10.7k]
  |  |  ------------------
  |  |   32|  10.8k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  10.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  168|       |
  169|  10.8k|   const size_t field_len = 2;
  170|       |
  171|  10.8k|   const size_t year_start = 0;
  172|  10.8k|   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
  ------------------
  |  Branch (172:28): [True: 10.3k, False: 431]
  ------------------
  173|  10.8k|   const size_t month_start = year_start + year_len;
  174|  10.8k|   const size_t day_start = month_start + field_len;
  175|  10.8k|   const size_t hour_start = day_start + field_len;
  176|  10.8k|   const size_t min_start = hour_start + field_len;
  177|  10.8k|   const size_t sec_start = min_start + field_len;
  178|       |
  179|  10.8k|   m_year = to_u32bit(t_spec.substr(year_start, year_len));
  180|  10.8k|   m_month = to_u32bit(t_spec.substr(month_start, field_len));
  181|  10.8k|   m_day = to_u32bit(t_spec.substr(day_start, field_len));
  182|  10.8k|   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
  183|  10.8k|   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
  184|  10.8k|   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
  185|  10.8k|   m_tag = spec_tag;
  186|       |
  187|  10.8k|   if(spec_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (187:7): [True: 10.3k, False: 432]
  ------------------
  188|  10.3k|      if(m_year >= 50) {
  ------------------
  |  Branch (188:10): [True: 908, False: 9.46k]
  ------------------
  189|    908|         m_year += 1900;
  190|  9.46k|      } else {
  191|  9.46k|         m_year += 2000;
  192|  9.46k|      }
  193|  10.3k|   }
  194|       |
  195|  10.8k|   if(!passes_sanity_check()) {
  ------------------
  |  Branch (195:7): [True: 53, False: 10.7k]
  ------------------
  196|     53|      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
  197|     53|   }
  198|  10.8k|}
_ZNK5Botan9ASN1_Time19passes_sanity_checkEv:
  203|  10.6k|bool ASN1_Time::passes_sanity_check() const {
  204|       |   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
  205|  10.6k|   if(m_year < 1950 || m_year > 3100) {
  ------------------
  |  Branch (205:7): [True: 11, False: 10.6k]
  |  Branch (205:24): [True: 5, False: 10.6k]
  ------------------
  206|     16|      return false;
  207|     16|   }
  208|  10.6k|   if(m_month == 0 || m_month > 12) {
  ------------------
  |  Branch (208:7): [True: 2, False: 10.6k]
  |  Branch (208:23): [True: 7, False: 10.6k]
  ------------------
  209|      9|      return false;
  210|      9|   }
  211|       |
  212|  10.6k|   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  213|       |
  214|  10.6k|   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
  ------------------
  |  Branch (214:7): [True: 1, False: 10.6k]
  |  Branch (214:21): [True: 10, False: 10.6k]
  ------------------
  215|     11|      return false;
  216|     11|   }
  217|       |
  218|  10.6k|   if(m_month == 2 && m_day == 29) {
  ------------------
  |  Branch (218:7): [True: 1.34k, False: 9.31k]
  |  Branch (218:23): [True: 114, False: 1.22k]
  ------------------
  219|    114|      if(m_year % 4 != 0) {
  ------------------
  |  Branch (219:10): [True: 1, False: 113]
  ------------------
  220|      1|         return false;  // not a leap year
  221|      1|      }
  222|       |
  223|    113|      if(m_year % 100 == 0 && m_year % 400 != 0) {
  ------------------
  |  Branch (223:10): [True: 32, False: 81]
  |  Branch (223:31): [True: 2, False: 30]
  ------------------
  224|      2|         return false;
  225|      2|      }
  226|    113|   }
  227|       |
  228|  10.6k|   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
  ------------------
  |  Branch (228:7): [True: 5, False: 10.6k]
  |  Branch (228:23): [True: 5, False: 10.6k]
  |  Branch (228:41): [True: 3, False: 10.6k]
  ------------------
  229|     13|      return false;
  230|     13|   }
  231|       |
  232|  10.6k|   if(m_tag == ASN1_Type::UtcTime) {
  ------------------
  |  Branch (232:7): [True: 10.3k, False: 275]
  ------------------
  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|  10.3k|      if(m_second > 59) {
  ------------------
  |  Branch (240:10): [True: 1, False: 10.3k]
  ------------------
  241|      1|         return false;
  242|      1|      }
  243|  10.3k|   }
  244|       |
  245|  10.6k|   return true;
  246|  10.6k|}
_ZN5BotanltERKNS_9ASN1_TimeES2_:
  276|    510|bool operator<(const ASN1_Time& t1, const ASN1_Time& t2) {
  277|    510|   return (t1.cmp(t2) < 0);
  278|    510|}
_ZN5BotangtERKNS_9ASN1_TimeES2_:
  280|    510|bool operator>(const ASN1_Time& t1, const ASN1_Time& t2) {
  281|    510|   return (t1.cmp(t2) > 0);
  282|    510|}

_ZNK5Botan11BER_Decoder10more_itemsEv:
  195|   121k|bool BER_Decoder::more_items() const {
  196|   121k|   if(m_source->end_of_data() && !m_pushed.is_set()) {
  ------------------
  |  Branch (196:7): [True: 37.5k, False: 83.9k]
  |  Branch (196:34): [True: 37.5k, False: 0]
  ------------------
  197|  37.5k|      return false;
  198|  37.5k|   }
  199|  83.9k|   return true;
  200|   121k|}
_ZN5Botan11BER_Decoder10verify_endEv:
  205|  9.27k|BER_Decoder& BER_Decoder::verify_end() {
  206|  9.27k|   return verify_end("BER_Decoder::verify_end called, but data remains");
  207|  9.27k|}
_ZN5Botan11BER_Decoder10verify_endENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  212|  14.5k|BER_Decoder& BER_Decoder::verify_end(std::string_view err) {
  213|  14.5k|   if(!m_source->end_of_data() || m_pushed.is_set()) {
  ------------------
  |  Branch (213:7): [True: 89, False: 14.4k]
  |  Branch (213:35): [True: 0, False: 14.4k]
  ------------------
  214|     89|      throw Decoding_Error(err);
  215|     89|   }
  216|  14.4k|   return (*this);
  217|  14.5k|}
_ZN5Botan11BER_Decoder17discard_remainingEv:
  222|    273|BER_Decoder& BER_Decoder::discard_remaining() {
  223|    273|   uint8_t buf;
  224|  6.48k|   while(m_source->read_byte(buf)) {}
  ------------------
  |  Branch (224:10): [True: 6.21k, False: 273]
  ------------------
  225|    273|   return (*this);
  226|    273|}
_ZN5Botan11BER_Decoder15get_next_objectEv:
  231|   333k|BER_Object BER_Decoder::get_next_object() {
  232|   333k|   BER_Object next;
  233|       |
  234|   333k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (234:7): [True: 20.2k, False: 313k]
  ------------------
  235|  20.2k|      std::swap(next, m_pushed);
  236|  20.2k|      return next;
  237|  20.2k|   }
  238|       |
  239|   330k|   for(;;) {
  240|   330k|      ASN1_Type type_tag;
  241|   330k|      ASN1_Class class_tag;
  242|   330k|      decode_tag(m_source, type_tag, class_tag);
  243|   330k|      next.set_tagging(type_tag, class_tag);
  244|   330k|      if(next.is_set() == false) {  // no more objects
  ------------------
  |  Branch (244:10): [True: 10.3k, False: 320k]
  ------------------
  245|  10.3k|         return next;
  246|  10.3k|      }
  247|       |
  248|   320k|      size_t field_size;
  249|   320k|      const size_t length = decode_length(m_source, field_size, ALLOWED_EOC_NESTINGS);
  250|   320k|      if(!m_source->check_available(length)) {
  ------------------
  |  Branch (250:10): [True: 1.34k, False: 319k]
  ------------------
  251|  1.34k|         throw BER_Decoding_Error("Value truncated");
  252|  1.34k|      }
  253|       |
  254|   319k|      uint8_t* out = next.mutable_bits(length);
  255|   319k|      if(m_source->read(out, length) != length) {
  ------------------
  |  Branch (255:10): [True: 0, False: 319k]
  ------------------
  256|      0|         throw BER_Decoding_Error("Value truncated");
  257|      0|      }
  258|       |
  259|   319k|      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
  ------------------
  |  Branch (259:10): [True: 17.3k, False: 301k]
  ------------------
  260|  17.3k|         continue;
  261|   301k|      } else {
  262|   301k|         break;
  263|   301k|      }
  264|   319k|   }
  265|       |
  266|   301k|   return next;
  267|   313k|}
_ZN5Botan11BER_Decoder9push_backERKNS_10BER_ObjectE:
  272|    565|void BER_Decoder::push_back(const BER_Object& obj) {
  273|    565|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (273:7): [True: 0, False: 565]
  ------------------
  274|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  275|      0|   }
  276|    565|   m_pushed = obj;
  277|    565|}
_ZN5Botan11BER_Decoder9push_backEONS_10BER_ObjectE:
  279|  26.5k|void BER_Decoder::push_back(BER_Object&& obj) {
  280|  26.5k|   if(m_pushed.is_set()) {
  ------------------
  |  Branch (280:7): [True: 0, False: 26.5k]
  ------------------
  281|      0|      throw Invalid_State("BER_Decoder: Only one push back is allowed");
  282|      0|   }
  283|  26.5k|   m_pushed = std::move(obj);
  284|  26.5k|}
_ZN5Botan11BER_Decoder10start_consENS_9ASN1_TypeENS_10ASN1_ClassE:
  286|   128k|BER_Decoder BER_Decoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  287|   128k|   BER_Object obj = get_next_object();
  288|   128k|   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
  289|   128k|   return BER_Decoder(std::move(obj), this);
  290|   128k|}
_ZN5Botan11BER_Decoder8end_consEv:
  295|  93.6k|BER_Decoder& BER_Decoder::end_cons() {
  296|  93.6k|   if(!m_parent) {
  ------------------
  |  Branch (296:7): [True: 0, False: 93.6k]
  ------------------
  297|      0|      throw Invalid_State("BER_Decoder::end_cons called with null parent");
  298|      0|   }
  299|  93.6k|   if(!m_source->end_of_data()) {
  ------------------
  |  Branch (299:7): [True: 336, False: 93.2k]
  ------------------
  300|    336|      throw Decoding_Error("BER_Decoder::end_cons called with data left");
  301|    336|   }
  302|  93.2k|   return (*m_parent);
  303|  93.6k|}
_ZN5Botan11BER_DecoderC2EONS_10BER_ObjectEPS0_:
  305|   128k|BER_Decoder::BER_Decoder(BER_Object&& obj, BER_Decoder* parent) {
  306|   128k|   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
  307|   128k|   m_source = m_data_src.get();
  308|   128k|   m_parent = parent;
  309|   128k|}
_ZN5Botan11BER_DecoderC2ERNS_10DataSourceE:
  314|  10.9k|BER_Decoder::BER_Decoder(DataSource& src) {
  315|  10.9k|   m_source = &src;
  316|  10.9k|}
_ZN5Botan11BER_DecoderC2EPKhm:
  321|  9.35k|BER_Decoder::BER_Decoder(const uint8_t data[], size_t length) {
  322|  9.35k|   m_data_src = std::make_unique<DataSource_Memory>(data, length);
  323|  9.35k|   m_source = m_data_src.get();
  324|  9.35k|}
_ZN5Botan11BER_DecoderC2ERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  337|  30.3k|BER_Decoder::BER_Decoder(const std::vector<uint8_t>& data) {
  338|  30.3k|   m_data_src = std::make_unique<DataSource_Memory>(data.data(), data.size());
  339|  30.3k|   m_source = m_data_src.get();
  340|  30.3k|}
_ZN5Botan11BER_Decoder6decodeERNS_11ASN1_ObjectENS_9ASN1_TypeENS_10ASN1_ClassE:
  356|   133k|BER_Decoder& BER_Decoder::decode(ASN1_Object& obj, ASN1_Type /*unused*/, ASN1_Class /*unused*/) {
  357|   133k|   obj.decode_from(*this);
  358|   133k|   return (*this);
  359|   133k|}
_ZN5Botan11BER_Decoder26decode_octet_string_bigintERNS_6BigIntE:
  373|     36|BER_Decoder& BER_Decoder::decode_octet_string_bigint(BigInt& out) {
  374|     36|   secure_vector<uint8_t> out_vec;
  375|     36|   decode(out_vec, ASN1_Type::OctetString);
  376|     36|   out = BigInt::decode(out_vec.data(), out_vec.size());
  377|     36|   return (*this);
  378|     36|}
_ZN5Botan11BER_Decoder6decodeERbNS_9ASN1_TypeENS_10ASN1_ClassE:
  383|  2.12k|BER_Decoder& BER_Decoder::decode(bool& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  384|  2.12k|   BER_Object obj = get_next_object();
  385|  2.12k|   obj.assert_is_a(type_tag, class_tag);
  386|       |
  387|  2.12k|   if(obj.length() != 1) {
  ------------------
  |  Branch (387:7): [True: 29, False: 2.10k]
  ------------------
  388|     29|      throw BER_Decoding_Error("BER boolean value had invalid size");
  389|     29|   }
  390|       |
  391|  2.10k|   out = (obj.bits()[0]) ? true : false;
  ------------------
  |  Branch (391:10): [True: 2.08k, False: 12]
  ------------------
  392|  2.10k|   return (*this);
  393|  2.12k|}
_ZN5Botan11BER_Decoder6decodeERmNS_9ASN1_TypeENS_10ASN1_ClassE:
  398|  4.16k|BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  399|  4.16k|   BigInt integer;
  400|  4.16k|   decode(integer, type_tag, class_tag);
  401|       |
  402|  4.16k|   if(integer.is_negative()) {
  ------------------
  |  Branch (402:7): [True: 54, False: 4.11k]
  ------------------
  403|     54|      throw BER_Decoding_Error("Decoded small integer value was negative");
  404|     54|   }
  405|       |
  406|  4.11k|   if(integer.bits() > 32) {
  ------------------
  |  Branch (406:7): [True: 113, False: 4.00k]
  ------------------
  407|    113|      throw BER_Decoding_Error("Decoded integer value larger than expected");
  408|    113|   }
  409|       |
  410|  4.00k|   out = 0;
  411|  19.4k|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (411:22): [True: 15.4k, False: 4.00k]
  ------------------
  412|  15.4k|      out = (out << 8) | integer.byte_at(3 - i);
  413|  15.4k|   }
  414|       |
  415|  4.00k|   return (*this);
  416|  4.11k|}
_ZN5Botan11BER_Decoder6decodeERNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  444|  14.4k|BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class class_tag) {
  445|  14.4k|   BER_Object obj = get_next_object();
  446|  14.4k|   obj.assert_is_a(type_tag, class_tag);
  447|       |
  448|  14.4k|   if(obj.length() == 0) {
  ------------------
  |  Branch (448:7): [True: 1.04k, False: 13.3k]
  ------------------
  449|  1.04k|      out.clear();
  450|  13.3k|   } else {
  451|  13.3k|      const bool negative = (obj.bits()[0] & 0x80) ? true : false;
  ------------------
  |  Branch (451:29): [True: 1.47k, False: 11.9k]
  ------------------
  452|       |
  453|  13.3k|      if(negative) {
  ------------------
  |  Branch (453:10): [True: 1.47k, False: 11.9k]
  ------------------
  454|  1.47k|         secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
  455|  2.42k|         for(size_t i = obj.length(); i > 0; --i) {
  ------------------
  |  Branch (455:39): [True: 2.42k, False: 0]
  ------------------
  456|  2.42k|            if(vec[i - 1]--) {
  ------------------
  |  Branch (456:16): [True: 1.47k, False: 950]
  ------------------
  457|  1.47k|               break;
  458|  1.47k|            }
  459|  2.42k|         }
  460|   268k|         for(size_t i = 0; i != obj.length(); ++i) {
  ------------------
  |  Branch (460:28): [True: 267k, False: 1.47k]
  ------------------
  461|   267k|            vec[i] = ~vec[i];
  462|   267k|         }
  463|  1.47k|         out = BigInt(vec.data(), vec.size());
  464|  1.47k|         out.flip_sign();
  465|  11.9k|      } else {
  466|  11.9k|         out = BigInt(obj.bits(), obj.length());
  467|  11.9k|      }
  468|  13.3k|   }
  469|       |
  470|  14.4k|   return (*this);
  471|  14.4k|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS_16secure_allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  509|    534|                                 ASN1_Class class_tag) {
  510|    534|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (510:7): [True: 0, False: 534]
  |  Branch (510:46): [True: 0, False: 0]
  ------------------
  511|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  512|      0|   }
  513|       |
  514|    534|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag);
  515|    534|   return (*this);
  516|    534|}
_ZN5Botan11BER_Decoder6decodeERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeES7_NS_10ASN1_ClassE:
  521|  27.7k|                                 ASN1_Class class_tag) {
  522|  27.7k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (522:7): [True: 15.4k, False: 12.3k]
  |  Branch (522:46): [True: 0, False: 15.4k]
  ------------------
  523|      0|      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
  524|      0|   }
  525|       |
  526|  27.7k|   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag);
  527|  27.7k|   return (*this);
  528|  27.7k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_110decode_tagEPNS_10DataSourceERNS_9ASN1_TypeERNS_10ASN1_ClassE:
   29|   402k|size_t decode_tag(DataSource* ber, ASN1_Type& type_tag, ASN1_Class& class_tag) {
   30|   402k|   uint8_t b;
   31|   402k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (31:7): [True: 16.4k, False: 386k]
  ------------------
   32|  16.4k|      type_tag = ASN1_Type::NoObject;
   33|  16.4k|      class_tag = ASN1_Class::NoObject;
   34|  16.4k|      return 0;
   35|  16.4k|   }
   36|       |
   37|   386k|   if((b & 0x1F) != 0x1F) {
  ------------------
  |  Branch (37:7): [True: 383k, False: 2.41k]
  ------------------
   38|   383k|      type_tag = ASN1_Type(b & 0x1F);
   39|   383k|      class_tag = ASN1_Class(b & 0xE0);
   40|   383k|      return 1;
   41|   383k|   }
   42|       |
   43|  2.41k|   size_t tag_bytes = 1;
   44|  2.41k|   class_tag = ASN1_Class(b & 0xE0);
   45|       |
   46|  2.41k|   size_t tag_buf = 0;
   47|  6.29k|   while(true) {
  ------------------
  |  Branch (47:10): [Folded - Ignored]
  ------------------
   48|  6.29k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (48:10): [True: 53, False: 6.23k]
  ------------------
   49|     53|         throw BER_Decoding_Error("Long-form tag truncated");
   50|     53|      }
   51|  6.23k|      if(tag_buf & 0xFF000000) {
  ------------------
  |  Branch (51:10): [True: 36, False: 6.20k]
  ------------------
   52|     36|         throw BER_Decoding_Error("Long-form tag overflowed 32 bits");
   53|     36|      }
   54|  6.20k|      ++tag_bytes;
   55|  6.20k|      tag_buf = (tag_buf << 7) | (b & 0x7F);
   56|  6.20k|      if((b & 0x80) == 0) {
  ------------------
  |  Branch (56:10): [True: 2.32k, False: 3.87k]
  ------------------
   57|  2.32k|         break;
   58|  2.32k|      }
   59|  6.20k|   }
   60|  2.32k|   type_tag = ASN1_Type(tag_buf);
   61|  2.32k|   return tag_bytes;
   62|  2.41k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_113decode_lengthEPNS_10DataSourceERmm:
   72|   386k|size_t decode_length(DataSource* ber, size_t& field_size, size_t allow_indef) {
   73|   386k|   uint8_t b;
   74|   386k|   if(!ber->read_byte(b)) {
  ------------------
  |  Branch (74:7): [True: 341, False: 385k]
  ------------------
   75|    341|      throw BER_Decoding_Error("Length field not found");
   76|    341|   }
   77|   385k|   field_size = 1;
   78|   385k|   if((b & 0x80) == 0) {
  ------------------
  |  Branch (78:7): [True: 345k, False: 39.8k]
  ------------------
   79|   345k|      return b;
   80|   345k|   }
   81|       |
   82|  39.8k|   field_size += (b & 0x7F);
   83|  39.8k|   if(field_size > 5) {
  ------------------
  |  Branch (83:7): [True: 761, False: 39.1k]
  ------------------
   84|    761|      throw BER_Decoding_Error("Length field is too large");
   85|    761|   }
   86|       |
   87|  39.1k|   if(field_size == 1) {
  ------------------
  |  Branch (87:7): [True: 12.4k, False: 26.6k]
  ------------------
   88|  12.4k|      if(allow_indef == 0) {
  ------------------
  |  Branch (88:10): [True: 7, False: 12.4k]
  ------------------
   89|      7|         throw BER_Decoding_Error("Nested EOC markers too deep, rejecting to avoid stack exhaustion");
   90|  12.4k|      } else {
   91|  12.4k|         return find_eoc(ber, allow_indef - 1);
   92|  12.4k|      }
   93|  12.4k|   }
   94|       |
   95|  26.6k|   size_t length = 0;
   96|       |
   97|  69.4k|   for(size_t i = 0; i != field_size - 1; ++i) {
  ------------------
  |  Branch (97:22): [True: 42.8k, False: 26.6k]
  ------------------
   98|  42.8k|      if(get_byte<0>(length) != 0) {
  ------------------
  |  Branch (98:10): [True: 0, False: 42.8k]
  ------------------
   99|      0|         throw BER_Decoding_Error("Field length overflow");
  100|      0|      }
  101|  42.8k|      if(!ber->read_byte(b)) {
  ------------------
  |  Branch (101:10): [True: 49, False: 42.8k]
  ------------------
  102|     49|         throw BER_Decoding_Error("Corrupted length field");
  103|     49|      }
  104|  42.8k|      length = (length << 8) | b;
  105|  42.8k|   }
  106|  26.6k|   return length;
  107|  26.6k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_18find_eocEPNS_10DataSourceEm:
  112|  12.4k|size_t find_eoc(DataSource* ber, size_t allow_indef) {
  113|  12.4k|   secure_vector<uint8_t> buffer(BOTAN_DEFAULT_BUFFER_SIZE), data;
  ------------------
  |  |  388|  12.4k|#define BOTAN_DEFAULT_BUFFER_SIZE 4096
  ------------------
  114|       |
  115|  25.1k|   while(true) {
  ------------------
  |  Branch (115:10): [Folded - Ignored]
  ------------------
  116|  25.1k|      const size_t got = ber->peek(buffer.data(), buffer.size(), data.size());
  117|  25.1k|      if(got == 0) {
  ------------------
  |  Branch (117:10): [True: 12.4k, False: 12.7k]
  ------------------
  118|  12.4k|         break;
  119|  12.4k|      }
  120|       |
  121|  12.7k|      data += std::make_pair(buffer.data(), got);
  122|  12.7k|   }
  123|       |
  124|  12.4k|   DataSource_Memory source(data);
  125|  12.4k|   data.clear();
  126|       |
  127|  12.4k|   size_t length = 0;
  128|  72.0k|   while(true) {
  ------------------
  |  Branch (128:10): [Folded - Ignored]
  ------------------
  129|  71.7k|      ASN1_Type type_tag;
  130|  71.7k|      ASN1_Class class_tag;
  131|  71.7k|      size_t tag_size = decode_tag(&source, type_tag, class_tag);
  132|  71.7k|      if(type_tag == ASN1_Type::NoObject) {
  ------------------
  |  Branch (132:10): [True: 6.12k, False: 65.5k]
  ------------------
  133|  6.12k|         break;
  134|  6.12k|      }
  135|       |
  136|  65.5k|      size_t length_size = 0;
  137|  65.5k|      size_t item_size = decode_length(&source, length_size, allow_indef);
  138|  65.5k|      source.discard_next(item_size);
  139|       |
  140|  65.5k|      length = BOTAN_CHECKED_ADD(length, item_size);
  ------------------
  |  |   73|  65.5k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  141|  65.5k|      length = BOTAN_CHECKED_ADD(length, tag_size);
  ------------------
  |  |   73|  65.5k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  142|  65.5k|      length = BOTAN_CHECKED_ADD(length, length_size);
  ------------------
  |  |   73|  65.5k|#define BOTAN_CHECKED_ADD(x, y) checked_add(x, y, __FILE__, __LINE__)
  ------------------
  143|       |
  144|  65.5k|      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal) {
  ------------------
  |  Branch (144:10): [True: 7.99k, False: 57.5k]
  |  Branch (144:40): [True: 5.92k, False: 2.06k]
  ------------------
  145|  5.92k|         break;
  146|  5.92k|      }
  147|  65.5k|   }
  148|  12.4k|   return length;
  149|  12.4k|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObjectC2EONS_10BER_ObjectE:
  183|   128k|      explicit DataSource_BERObject(BER_Object&& obj) : m_obj(std::move(obj)), m_offset(0) {}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject4readEPhm:
  153|  4.87M|      size_t read(uint8_t out[], size_t length) override {
  154|  4.87M|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  4.87M|   do {                                                                     \
  |  |   61|  4.87M|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 4.87M]
  |  |  ------------------
  |  |   62|  4.87M|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  4.87M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  155|  4.87M|         const size_t got = std::min<size_t>(m_obj.length() - m_offset, length);
  156|  4.87M|         copy_mem(out, m_obj.bits() + m_offset, got);
  157|  4.87M|         m_offset += got;
  158|  4.87M|         return got;
  159|  4.87M|      }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_120DataSource_BERObject15check_availableEm:
  174|   214k|      bool check_available(size_t n) override {
  175|   214k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|   214k|   do {                                                                     \
  |  |   61|   214k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 214k]
  |  |  ------------------
  |  |   62|   214k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|   214k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  176|   214k|         return (n <= (m_obj.length() - m_offset));
  177|   214k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject4peekEPhmm:
  161|  5.85k|      size_t peek(uint8_t out[], size_t length, size_t peek_offset) const override {
  162|  5.85k|         BOTAN_ASSERT_NOMSG(m_offset <= m_obj.length());
  ------------------
  |  |   60|  5.85k|   do {                                                                     \
  |  |   61|  5.85k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 5.85k]
  |  |  ------------------
  |  |   62|  5.85k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  5.85k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|  5.85k|         const size_t bytes_left = m_obj.length() - m_offset;
  164|       |
  165|  5.85k|         if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (165:13): [True: 2.90k, False: 2.94k]
  ------------------
  166|  2.90k|            return 0;
  167|  2.90k|         }
  168|       |
  169|  2.94k|         const size_t got = std::min(bytes_left - peek_offset, length);
  170|  2.94k|         copy_mem(out, m_obj.bits() + m_offset + peek_offset, got);
  171|  2.94k|         return got;
  172|  5.85k|      }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject11end_of_dataEv:
  179|   184k|      bool end_of_data() const override { return get_bytes_read() == m_obj.length(); }
ber_dec.cpp:_ZNK5Botan12_GLOBAL__N_120DataSource_BERObject14get_bytes_readEv:
  181|   184k|      size_t get_bytes_read() const override { return m_offset; }
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINS_16secure_allocatorIhEEEEvRNSt3__16vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassE:
  480|    517|                               ASN1_Class class_tag) {
  481|    517|   obj.assert_is_a(type_tag, class_tag);
  482|       |
  483|    517|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (483:7): [True: 506, False: 11]
  ------------------
  484|    506|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  485|    506|   } else {
  486|     11|      if(obj.length() == 0) {
  ------------------
  |  Branch (486:10): [True: 0, False: 11]
  ------------------
  487|      0|         throw BER_Decoding_Error("Invalid BIT STRING");
  488|      0|      }
  489|     11|      if(obj.bits()[0] >= 8) {
  ------------------
  |  Branch (489:10): [True: 0, False: 11]
  ------------------
  490|      0|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  491|      0|      }
  492|       |
  493|     11|      buffer.resize(obj.length() - 1);
  494|       |
  495|     11|      if(obj.length() > 1) {
  ------------------
  |  Branch (495:10): [True: 0, False: 11]
  ------------------
  496|      0|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  497|      0|      }
  498|     11|   }
  499|    517|}
ber_dec.cpp:_ZN5Botan12_GLOBAL__N_125asn1_decode_binary_stringINSt3__19allocatorIhEEEEvRNS2_6vectorIhT_EERKNS_10BER_ObjectENS_9ASN1_TypeESC_NS_10ASN1_ClassE:
  480|  27.5k|                               ASN1_Class class_tag) {
  481|  27.5k|   obj.assert_is_a(type_tag, class_tag);
  482|       |
  483|  27.5k|   if(real_type == ASN1_Type::OctetString) {
  ------------------
  |  Branch (483:7): [True: 11.9k, False: 15.5k]
  ------------------
  484|  11.9k|      buffer.assign(obj.bits(), obj.bits() + obj.length());
  485|  15.5k|   } else {
  486|  15.5k|      if(obj.length() == 0) {
  ------------------
  |  Branch (486:10): [True: 1, False: 15.5k]
  ------------------
  487|      1|         throw BER_Decoding_Error("Invalid BIT STRING");
  488|      1|      }
  489|  15.5k|      if(obj.bits()[0] >= 8) {
  ------------------
  |  Branch (489:10): [True: 9, False: 15.5k]
  ------------------
  490|      9|         throw BER_Decoding_Error("Bad number of unused bits in BIT STRING");
  491|      9|      }
  492|       |
  493|  15.5k|      buffer.resize(obj.length() - 1);
  494|       |
  495|  15.5k|      if(obj.length() > 1) {
  ------------------
  |  Branch (495:10): [True: 12.3k, False: 3.26k]
  ------------------
  496|  12.3k|         copy_mem(buffer.data(), obj.bits() + 1, obj.length() - 1);
  497|  12.3k|      }
  498|  15.5k|   }
  499|  27.5k|}

_ZN5Botan11DER_EncoderC2ERNSt3__16vectorIhNS1_9allocatorIhEEEE:
   71|  21.8k|DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   72|  21.8k|   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
   73|  21.8k|}
_ZN5Botan11DER_Encoder12DER_Sequence13push_contentsERS0_:
   78|  30.7k|void DER_Encoder::DER_Sequence::push_contents(DER_Encoder& der) {
   79|  30.7k|   const auto real_class_tag = m_class_tag | ASN1_Class::Constructed;
   80|       |
   81|  30.7k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (81:7): [True: 0, False: 30.7k]
  ------------------
   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|  30.7k|   der.add_object(m_type_tag, real_class_tag, m_contents.data(), m_contents.size());
   90|  30.7k|   m_contents.clear();
   91|  30.7k|}
_ZN5Botan11DER_Encoder12DER_Sequence9add_bytesEPKhm:
   96|  26.2k|void DER_Encoder::DER_Sequence::add_bytes(const uint8_t data[], size_t length) {
   97|  26.2k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (97:7): [True: 0, False: 26.2k]
  ------------------
   98|      0|      m_set_contents.push_back(secure_vector<uint8_t>(data, data + length));
   99|  26.2k|   } else {
  100|  26.2k|      m_contents += std::make_pair(data, length);
  101|  26.2k|   }
  102|  26.2k|}
_ZN5Botan11DER_Encoder12DER_Sequence9add_bytesEPKhmS3_m:
  104|  18.0k|void DER_Encoder::DER_Sequence::add_bytes(const uint8_t hdr[], size_t hdr_len, const uint8_t val[], size_t val_len) {
  105|  18.0k|   if(m_type_tag == ASN1_Type::Set) {
  ------------------
  |  Branch (105:7): [True: 0, False: 18.0k]
  ------------------
  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|  18.0k|   } else {
  112|  18.0k|      m_contents += std::make_pair(hdr, hdr_len);
  113|  18.0k|      m_contents += std::make_pair(val, val_len);
  114|  18.0k|   }
  115|  18.0k|}
_ZN5Botan11DER_Encoder12DER_SequenceC2ENS_9ASN1_TypeENS_10ASN1_ClassE:
  127|  30.7k|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|  30.7k|DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
  164|  30.7k|   m_subsequences.push_back(DER_Sequence(type_tag, class_tag));
  165|  30.7k|   return (*this);
  166|  30.7k|}
_ZN5Botan11DER_Encoder8end_consEv:
  171|  30.7k|DER_Encoder& DER_Encoder::end_cons() {
  172|  30.7k|   if(m_subsequences.empty()) {
  ------------------
  |  Branch (172:7): [True: 0, False: 30.7k]
  ------------------
  173|      0|      throw Invalid_State("DER_Encoder::end_cons: No such sequence");
  174|      0|   }
  175|       |
  176|  30.7k|   DER_Sequence last_seq = std::move(m_subsequences[m_subsequences.size() - 1]);
  177|  30.7k|   m_subsequences.pop_back();
  178|  30.7k|   last_seq.push_contents(*this);
  179|       |
  180|  30.7k|   return (*this);
  181|  30.7k|}
_ZN5Botan11DER_Encoder9raw_bytesEPKhm:
  207|  26.2k|DER_Encoder& DER_Encoder::raw_bytes(const uint8_t bytes[], size_t length) {
  208|  26.2k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (208:7): [True: 26.2k, False: 0]
  ------------------
  209|  26.2k|      m_subsequences[m_subsequences.size() - 1].add_bytes(bytes, length);
  210|  26.2k|   } 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|  26.2k|   return (*this);
  217|  26.2k|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEPKhm:
  222|  39.8k|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
  223|  39.8k|   std::vector<uint8_t> hdr;
  224|  39.8k|   encode_tag(hdr, type_tag, class_tag);
  225|  39.8k|   encode_length(hdr, length);
  226|       |
  227|  39.8k|   if(!m_subsequences.empty()) {
  ------------------
  |  Branch (227:7): [True: 18.0k, False: 21.8k]
  ------------------
  228|  18.0k|      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
  229|  21.8k|   } else if(m_append_output) {
  ------------------
  |  Branch (229:14): [True: 21.8k, False: 0]
  ------------------
  230|  21.8k|      m_append_output(hdr.data(), hdr.size());
  231|  21.8k|      m_append_output(rep, length);
  232|  21.8k|   } else {
  233|      0|      m_default_outbuf += hdr;
  234|      0|      m_default_outbuf += std::make_pair(rep, length);
  235|      0|   }
  236|       |
  237|  39.8k|   return (*this);
  238|  39.8k|}
_ZN5Botan11DER_Encoder6encodeERKNS_6BigIntE:
  264|    142|DER_Encoder& DER_Encoder::encode(const BigInt& n) {
  265|    142|   return encode(n, ASN1_Type::Integer, ASN1_Class::Universal);
  266|    142|}
_ZN5Botan11DER_Encoder6encodeEPKhmNS_9ASN1_TypeE:
  271|  4.45k|DER_Encoder& DER_Encoder::encode(const uint8_t bytes[], size_t length, ASN1_Type real_type) {
  272|  4.45k|   return encode(bytes, length, real_type, real_type, ASN1_Class::Universal);
  273|  4.45k|}
_ZN5Botan11DER_Encoder6encodeERKNS_6BigIntENS_9ASN1_TypeENS_10ASN1_ClassE:
  293|    142|DER_Encoder& DER_Encoder::encode(const BigInt& n, ASN1_Type type_tag, ASN1_Class class_tag) {
  294|    142|   if(n == 0) {
  ------------------
  |  Branch (294:7): [True: 11, False: 131]
  ------------------
  295|     11|      return add_object(type_tag, class_tag, 0);
  296|     11|   }
  297|       |
  298|    131|   const size_t extra_zero = (n.bits() % 8 == 0) ? 1 : 0;
  ------------------
  |  Branch (298:30): [True: 61, False: 70]
  ------------------
  299|    131|   secure_vector<uint8_t> contents(extra_zero + n.bytes());
  300|    131|   n.binary_encode(&contents[extra_zero]);
  301|    131|   if(n < 0) {
  ------------------
  |  Branch (301:7): [True: 0, False: 131]
  ------------------
  302|      0|      for(unsigned char& content : contents) {
  ------------------
  |  Branch (302:34): [True: 0, False: 0]
  ------------------
  303|      0|         content = ~content;
  304|      0|      }
  305|      0|      for(size_t i = contents.size(); i > 0; --i) {
  ------------------
  |  Branch (305:39): [True: 0, False: 0]
  ------------------
  306|      0|         if(++contents[i - 1]) {
  ------------------
  |  Branch (306:13): [True: 0, False: 0]
  ------------------
  307|      0|            break;
  308|      0|         }
  309|      0|      }
  310|      0|   }
  311|       |
  312|    131|   return add_object(type_tag, class_tag, contents);
  313|    142|}
_ZN5Botan11DER_Encoder6encodeEPKhmNS_9ASN1_TypeES3_NS_10ASN1_ClassE:
  319|  4.45k|   const uint8_t bytes[], size_t length, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag) {
  320|  4.45k|   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
  ------------------
  |  Branch (320:7): [True: 4.45k, False: 0]
  |  Branch (320:46): [True: 0, False: 4.45k]
  ------------------
  321|      0|      throw Invalid_Argument("DER_Encoder: Invalid tag for byte/bit string");
  322|      0|   }
  323|       |
  324|  4.45k|   if(real_type == ASN1_Type::BitString) {
  ------------------
  |  Branch (324:7): [True: 4.45k, False: 0]
  ------------------
  325|  4.45k|      secure_vector<uint8_t> encoded;
  326|  4.45k|      encoded.push_back(0);
  327|  4.45k|      encoded += std::make_pair(bytes, length);
  328|  4.45k|      return add_object(type_tag, class_tag, encoded);
  329|  4.45k|   } else {
  330|      0|      return add_object(type_tag, class_tag, bytes, length);
  331|      0|   }
  332|  4.45k|}
_ZN5Botan11DER_Encoder6encodeERKNS_11ASN1_ObjectE:
  334|  8.98k|DER_Encoder& DER_Encoder::encode(const ASN1_Object& obj) {
  335|  8.98k|   obj.encode_into(*this);
  336|  8.98k|   return (*this);
  337|  8.98k|}
_ZN5Botan11DER_Encoder10add_objectENS_9ASN1_TypeENS_10ASN1_ClassEh:
  351|     11|DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, uint8_t rep) {
  352|     11|   return add_object(type_tag, class_tag, &rep, 1);
  353|     11|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_110encode_tagERNSt3__16vectorIhNS1_9allocatorIhEEEENS_9ASN1_TypeENS_10ASN1_ClassE:
   24|  39.8k|void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   25|  39.8k|   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   26|  39.8k|   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
   27|       |
   28|  39.8k|   if((class_tag | 0xE0) != 0xE0) {
  ------------------
  |  Branch (28:7): [True: 0, False: 39.8k]
  ------------------
   29|      0|      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   30|      0|   }
   31|       |
   32|  39.8k|   if(type_tag <= 30) {
  ------------------
  |  Branch (32:7): [True: 39.8k, False: 0]
  ------------------
   33|  39.8k|      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   34|  39.8k|   } 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|  39.8k|}
der_enc.cpp:_ZN5Botan12_GLOBAL__N_113encode_lengthERNSt3__16vectorIhNS1_9allocatorIhEEEEm:
   51|  39.8k|void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   52|  39.8k|   if(length <= 127) {
  ------------------
  |  Branch (52:7): [True: 27.0k, False: 12.7k]
  ------------------
   53|  27.0k|      encoded_length.push_back(static_cast<uint8_t>(length));
   54|  27.0k|   } else {
   55|  12.7k|      const size_t bytes_needed = significant_bytes(length);
   56|       |
   57|  12.7k|      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));
   58|       |
   59|  33.4k|      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
  ------------------
  |  Branch (59:53): [True: 20.6k, False: 12.7k]
  ------------------
   60|  20.6k|         encoded_length.push_back(get_byte_var(i, length));
   61|  20.6k|      }
   62|  12.7k|   }
   63|  39.8k|}
der_enc.cpp:_ZZN5Botan11DER_EncoderC1ERNSt3__16vectorIhNS1_9allocatorIhEEEEENK3$_1clEPKhm:
   72|  43.7k|   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|  8.73k|OID_Map& OID_Map::global_registry() {
   17|  8.73k|   static OID_Map g_map;
   18|  8.73k|   return g_map;
   19|  8.73k|}
_ZN5Botan7OID_Map7oid2strERKNS_3OIDE:
   56|  8.06k|std::string OID_Map::oid2str(const OID& oid) {
   57|  8.06k|   const std::string oid_str = oid.to_string();
   58|       |
   59|  8.06k|   lock_guard_type<mutex_type> lock(m_mutex);
   60|       |
   61|  8.06k|   auto i = m_oid2str.find(oid_str);
   62|  8.06k|   if(i != m_oid2str.end()) {
  ------------------
  |  Branch (62:7): [True: 6.08k, False: 1.98k]
  ------------------
   63|  6.08k|      return i->second;
   64|  6.08k|   }
   65|       |
   66|  1.98k|   return "";
   67|  8.06k|}
_ZN5Botan7OID_Map7str2oidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   69|    669|OID OID_Map::str2oid(std::string_view str) {
   70|    669|   lock_guard_type<mutex_type> lock(m_mutex);
   71|    669|   auto i = m_str2oid.find(std::string(str));
   72|    669|   if(i != m_str2oid.end()) {
  ------------------
  |  Branch (72:7): [True: 669, False: 0]
  ------------------
   73|    669|      return i->second;
   74|    669|   }
   75|       |
   76|      0|   return OID();
   77|    669|}

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

_ZN5Botan20Buffered_Computation9update_beEj:
   19|    275|void Buffered_Computation::update_be(uint32_t val) {
   20|    275|   uint8_t inb[sizeof(val)];
   21|    275|   store_be(val, inb);
   22|    275|   add_data({inb, sizeof(inb)});
   23|    275|}

_ZN5Botan18SymmetricAlgorithm7set_keyENSt3__14spanIKhLm18446744073709551615EEE:
   17|  7.38k|void SymmetricAlgorithm::set_key(std::span<const uint8_t> key) {
   18|  7.38k|   if(!valid_keylength(key.size())) {
  ------------------
  |  Branch (18:7): [True: 0, False: 7.38k]
  ------------------
   19|      0|      throw Invalid_Key_Length(name(), key.size());
   20|      0|   }
   21|  7.38k|   key_schedule(key);
   22|  7.38k|}

_ZNK5Botan20GOST_28147_89_Params9sbox_pairEmm:
   22|   125k|uint8_t GOST_28147_89_Params::sbox_pair(size_t row, size_t col) const {
   23|   125k|   const uint8_t x = m_sboxes[4 * (col % 16) + row];
   24|   125k|   const uint8_t y = m_sboxes[4 * (col / 16) + row];
   25|   125k|   return (x >> 4) | (y << 4);
   26|   125k|}
_ZN5Botan20GOST_28147_89_ParamsC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   28|    123|GOST_28147_89_Params::GOST_28147_89_Params(std::string_view n) : m_name(n) {
   29|       |   // Encoded in the packed fromat from RFC 4357
   30|       |
   31|       |   // GostR3411_94_TestParamSet (OID 1.2.643.2.2.31.0)
   32|    123|   static const uint8_t GOST_R_3411_TEST_PARAMS[64] = {
   33|    123|      0x4E, 0x57, 0x64, 0xD1, 0xAB, 0x8D, 0xCB, 0xBF, 0x94, 0x1A, 0x7A, 0x4D, 0x2C, 0xD1, 0x10, 0x10,
   34|    123|      0xD6, 0xA0, 0x57, 0x35, 0x8D, 0x38, 0xF2, 0xF7, 0x0F, 0x49, 0xD1, 0x5A, 0xEA, 0x2F, 0x8D, 0x94,
   35|    123|      0x62, 0xEE, 0x43, 0x09, 0xB3, 0xF4, 0xA6, 0xA2, 0x18, 0xC6, 0x98, 0xE3, 0xC1, 0x7C, 0xE5, 0x7E,
   36|    123|      0x70, 0x6B, 0x09, 0x66, 0xF7, 0x02, 0x3C, 0x8B, 0x55, 0x95, 0xBF, 0x28, 0x39, 0xB3, 0x2E, 0xCC};
   37|       |
   38|       |   // GostR3411-94-CryptoProParamSet (OID 1.2.643.2.2.31.1)
   39|    123|   static const uint8_t GOST_R_3411_CRYPTOPRO_PARAMS[64] = {
   40|    123|      0xA5, 0x74, 0x77, 0xD1, 0x4F, 0xFA, 0x66, 0xE3, 0x54, 0xC7, 0x42, 0x4A, 0x60, 0xEC, 0xB4, 0x19,
   41|    123|      0x82, 0x90, 0x9D, 0x75, 0x1D, 0x4F, 0xC9, 0x0B, 0x3B, 0x12, 0x2F, 0x54, 0x79, 0x08, 0xA0, 0xAF,
   42|    123|      0xD1, 0x3E, 0x1A, 0x38, 0xC7, 0xB1, 0x81, 0xC6, 0xE6, 0x56, 0x05, 0x87, 0x03, 0x25, 0xEB, 0xFE,
   43|    123|      0x9C, 0x6D, 0xF8, 0x6D, 0x2E, 0xAB, 0xDE, 0x20, 0xBA, 0x89, 0x3C, 0x92, 0xF8, 0xD3, 0x53, 0xBC};
   44|       |
   45|    123|   if(m_name == "R3411_94_TestParam") {
  ------------------
  |  Branch (45:7): [True: 0, False: 123]
  ------------------
   46|      0|      m_sboxes = GOST_R_3411_TEST_PARAMS;
   47|    123|   } else if(m_name == "R3411_CryptoPro") {
  ------------------
  |  Branch (47:14): [True: 123, False: 0]
  ------------------
   48|    123|      m_sboxes = GOST_R_3411_CRYPTOPRO_PARAMS;
   49|    123|   } else {
   50|      0|      throw Invalid_Argument(fmt("GOST_28147_89_Params: Unknown sbox params '{}'", m_name));
   51|      0|   }
   52|    123|}
_ZN5Botan13GOST_28147_89C2ERKNS_20GOST_28147_89_ParamsE:
   58|    123|      m_SBOX(1024), m_name(fmt("GOST-28147-89({})", param.param_name())) {
   59|       |   // Convert the parallel 4x4 sboxes into larger word-based sboxes
   60|       |
   61|  31.6k|   for(size_t i = 0; i != 256; ++i) {
  ------------------
  |  Branch (61:22): [True: 31.4k, False: 123]
  ------------------
   62|  31.4k|      m_SBOX[i] = rotl<11, uint32_t>(param.sbox_pair(0, i));
   63|  31.4k|      m_SBOX[i + 256] = rotl<19, uint32_t>(param.sbox_pair(1, i));
   64|  31.4k|      m_SBOX[i + 512] = rotl<27, uint32_t>(param.sbox_pair(2, i));
   65|  31.4k|      m_SBOX[i + 768] = rotl<3, uint32_t>(param.sbox_pair(3, i));
   66|  31.4k|   }
   67|    123|}
_ZNK5Botan13GOST_28147_899encrypt_nEPKhPhm:
   92|  7.38k|void GOST_28147_89::encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
   93|  7.38k|   assert_key_material_set();
   94|       |
   95|  14.7k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (95:22): [True: 7.38k, False: 7.38k]
  ------------------
   96|  7.38k|      uint32_t N1 = load_le<uint32_t>(in, 0);
   97|  7.38k|      uint32_t N2 = load_le<uint32_t>(in, 1);
   98|       |
   99|  29.5k|      for(size_t j = 0; j != 3; ++j) {
  ------------------
  |  Branch (99:25): [True: 22.1k, False: 7.38k]
  ------------------
  100|  22.1k|         GOST_ROUND2<0, 1>(N1, N2, m_SBOX, m_EK);
  101|  22.1k|         GOST_ROUND2<2, 3>(N1, N2, m_SBOX, m_EK);
  102|  22.1k|         GOST_ROUND2<4, 5>(N1, N2, m_SBOX, m_EK);
  103|  22.1k|         GOST_ROUND2<6, 7>(N1, N2, m_SBOX, m_EK);
  104|  22.1k|      }
  105|       |
  106|  7.38k|      GOST_ROUND2<7, 6>(N1, N2, m_SBOX, m_EK);
  107|  7.38k|      GOST_ROUND2<5, 4>(N1, N2, m_SBOX, m_EK);
  108|  7.38k|      GOST_ROUND2<3, 2>(N1, N2, m_SBOX, m_EK);
  109|  7.38k|      GOST_ROUND2<1, 0>(N1, N2, m_SBOX, m_EK);
  110|       |
  111|  7.38k|      store_le(out, N2, N1);
  112|       |
  113|  7.38k|      in += BLOCK_SIZE;
  114|  7.38k|      out += BLOCK_SIZE;
  115|  7.38k|   }
  116|  7.38k|}
_ZNK5Botan13GOST_28147_8919has_keying_materialEv:
  146|  7.38k|bool GOST_28147_89::has_keying_material() const {
  147|  7.38k|   return !m_EK.empty();
  148|  7.38k|}
_ZN5Botan13GOST_28147_8912key_scheduleENSt3__14spanIKhLm18446744073709551615EEE:
  153|  7.38k|void GOST_28147_89::key_schedule(std::span<const uint8_t> key) {
  154|  7.38k|   m_EK.resize(8);
  155|  66.4k|   for(size_t i = 0; i != 8; ++i) {
  ------------------
  |  Branch (155:22): [True: 59.0k, False: 7.38k]
  ------------------
  156|  59.0k|      m_EK[i] = load_le<uint32_t>(key.data(), i);
  157|  59.0k|   }
  158|  7.38k|}
_ZN5Botan13GOST_28147_895clearEv:
  160|    123|void GOST_28147_89::clear() {
  161|    123|   zap(m_EK);
  162|    123|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm0ELm1EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  22.1k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  22.1k|   const uint32_t T0 = N1 + EK[R1];
   81|  22.1k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  22.1k|   const uint32_t T1 = N2 + EK[R2];
   84|  22.1k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  22.1k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm2ELm3EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  22.1k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  22.1k|   const uint32_t T0 = N1 + EK[R1];
   81|  22.1k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  22.1k|   const uint32_t T1 = N2 + EK[R2];
   84|  22.1k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  22.1k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm4ELm5EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  22.1k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  22.1k|   const uint32_t T0 = N1 + EK[R1];
   81|  22.1k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  22.1k|   const uint32_t T1 = N2 + EK[R2];
   84|  22.1k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  22.1k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm6ELm7EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  22.1k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  22.1k|   const uint32_t T0 = N1 + EK[R1];
   81|  22.1k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  22.1k|   const uint32_t T1 = N2 + EK[R2];
   84|  22.1k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  22.1k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm7ELm6EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  7.38k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  7.38k|   const uint32_t T0 = N1 + EK[R1];
   81|  7.38k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  7.38k|   const uint32_t T1 = N2 + EK[R2];
   84|  7.38k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  7.38k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm5ELm4EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  7.38k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  7.38k|   const uint32_t T0 = N1 + EK[R1];
   81|  7.38k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  7.38k|   const uint32_t T1 = N2 + EK[R2];
   84|  7.38k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  7.38k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm3ELm2EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  7.38k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  7.38k|   const uint32_t T0 = N1 + EK[R1];
   81|  7.38k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  7.38k|   const uint32_t T1 = N2 + EK[R2];
   84|  7.38k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  7.38k|}
gost_28147.cpp:_ZN5Botan12_GLOBAL__N_111GOST_ROUND2ILm1ELm0EEEvRjS2_RKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS4_IjNS_16secure_allocatorIjEEEE:
   79|  7.38k|void GOST_ROUND2(uint32_t& N1, uint32_t& N2, const std::vector<uint32_t>& S, const secure_vector<uint32_t>& EK) {
   80|  7.38k|   const uint32_t T0 = N1 + EK[R1];
   81|  7.38k|   N2 ^= S[get_byte<3>(T0)] | S[get_byte<2>(T0) + 256] | S[get_byte<1>(T0) + 512] | S[get_byte<0>(T0) + 768];
   82|       |
   83|  7.38k|   const uint32_t T1 = N2 + EK[R2];
   84|  7.38k|   N1 ^= S[get_byte<3>(T1)] | S[get_byte<2>(T1) + 256] | S[get_byte<1>(T1) + 512] | S[get_byte<0>(T1) + 768];
   85|  7.38k|}

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

_ZN5Botan10hex_encodeEPcPKhmb:
   33|  8.90k|void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase) {
   34|   240k|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (34:22): [True: 231k, False: 8.90k]
  ------------------
   35|   231k|      const uint8_t n0 = (input[i] >> 4) & 0xF;
   36|   231k|      const uint8_t n1 = (input[i]) & 0xF;
   37|       |
   38|   231k|      output[2 * i] = hex_encode_nibble(n0, uppercase);
   39|   231k|      output[2 * i + 1] = hex_encode_nibble(n1, uppercase);
   40|   231k|   }
   41|  8.90k|}
_ZN5Botan10hex_encodeEPKhmb:
   43|  8.90k|std::string hex_encode(const uint8_t input[], size_t input_length, bool uppercase) {
   44|  8.90k|   std::string output(2 * input_length, 0);
   45|       |
   46|  8.90k|   if(input_length) {
  ------------------
  |  Branch (46:7): [True: 8.90k, False: 0]
  ------------------
   47|  8.90k|      hex_encode(&output.front(), input, input_length, uppercase);
   48|  8.90k|   }
   49|       |
   50|  8.90k|   return output;
   51|  8.90k|}
_ZN5Botan10hex_decodeEPhPKcmRmb:
   81|  4.15k|size_t hex_decode(uint8_t output[], const char input[], size_t input_length, size_t& input_consumed, bool ignore_ws) {
   82|  4.15k|   uint8_t* out_ptr = output;
   83|  4.15k|   bool top_nibble = true;
   84|       |
   85|  4.15k|   clear_mem(output, input_length / 2);
   86|       |
   87|   218k|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (87:22): [True: 214k, False: 4.15k]
  ------------------
   88|   214k|      const uint8_t bin = hex_char_to_bin(input[i]);
   89|       |
   90|   214k|      if(bin >= 0x10) {
  ------------------
  |  Branch (90:10): [True: 0, False: 214k]
  ------------------
   91|      0|         if(bin == 0x80 && ignore_ws) {
  ------------------
  |  Branch (91:13): [True: 0, False: 0]
  |  Branch (91:28): [True: 0, False: 0]
  ------------------
   92|      0|            continue;
   93|      0|         }
   94|       |
   95|      0|         throw Invalid_Argument(fmt("hex_decode: invalid character '{}'", format_char_for_display(input[i])));
   96|      0|      }
   97|       |
   98|   214k|      if(top_nibble) {
  ------------------
  |  Branch (98:10): [True: 107k, False: 107k]
  ------------------
   99|   107k|         *out_ptr |= bin << 4;
  100|   107k|      } else {
  101|   107k|         *out_ptr |= bin;
  102|   107k|      }
  103|       |
  104|   214k|      top_nibble = !top_nibble;
  105|   214k|      if(top_nibble) {
  ------------------
  |  Branch (105:10): [True: 107k, False: 107k]
  ------------------
  106|   107k|         ++out_ptr;
  107|   107k|      }
  108|   214k|   }
  109|       |
  110|  4.15k|   input_consumed = input_length;
  111|  4.15k|   size_t written = (out_ptr - output);
  112|       |
  113|       |   /*
  114|       |   * We only got half of a uint8_t at the end; zap the half-written
  115|       |   * output and mark it as unread
  116|       |   */
  117|  4.15k|   if(!top_nibble) {
  ------------------
  |  Branch (117:7): [True: 0, False: 4.15k]
  ------------------
  118|      0|      *out_ptr = 0;
  119|      0|      input_consumed -= 1;
  120|      0|   }
  121|       |
  122|  4.15k|   return written;
  123|  4.15k|}
_ZN5Botan10hex_decodeEPhPKcmb:
  125|  4.15k|size_t hex_decode(uint8_t output[], const char input[], size_t input_length, bool ignore_ws) {
  126|  4.15k|   size_t consumed = 0;
  127|  4.15k|   size_t written = hex_decode(output, input, input_length, consumed, ignore_ws);
  128|       |
  129|  4.15k|   if(consumed != input_length) {
  ------------------
  |  Branch (129:7): [True: 0, False: 4.15k]
  ------------------
  130|      0|      throw Invalid_Argument("hex_decode: input did not have full bytes");
  131|      0|   }
  132|       |
  133|  4.15k|   return written;
  134|  4.15k|}
_ZN5Botan17hex_decode_lockedEPKcmb:
  144|  4.15k|secure_vector<uint8_t> hex_decode_locked(const char input[], size_t input_length, bool ignore_ws) {
  145|  4.15k|   secure_vector<uint8_t> bin(1 + input_length / 2);
  146|       |
  147|  4.15k|   size_t written = hex_decode(bin.data(), input, input_length, ignore_ws);
  148|       |
  149|  4.15k|   bin.resize(written);
  150|  4.15k|   return bin;
  151|  4.15k|}
hex.cpp:_ZN5Botan12_GLOBAL__N_117hex_encode_nibbleEhb:
   20|   462k|char hex_encode_nibble(uint8_t n, bool uppercase) {
   21|   462k|   BOTAN_DEBUG_ASSERT(n <= 15);
  ------------------
  |  |   99|   462k|      do {                          \
  |  |  100|   462k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   22|       |
   23|   462k|   const auto in_09 = CT::Mask<uint8_t>::is_lt(n, 10);
   24|       |
   25|   462k|   const char c_09 = n + '0';
   26|   462k|   const char c_af = n + (uppercase ? 'A' : 'a') - 10;
  ------------------
  |  Branch (26:27): [True: 462k, False: 0]
  ------------------
   27|       |
   28|   462k|   return in_09.select(c_09, c_af);
   29|   462k|}
hex.cpp:_ZN5Botan12_GLOBAL__N_115hex_char_to_binEc:
   55|   214k|uint8_t hex_char_to_bin(char input) {
   56|   214k|   const uint8_t c = static_cast<uint8_t>(input);
   57|       |
   58|   214k|   const auto is_alpha_upper = CT::Mask<uint8_t>::is_within_range(c, uint8_t('A'), uint8_t('F'));
   59|   214k|   const auto is_alpha_lower = CT::Mask<uint8_t>::is_within_range(c, uint8_t('a'), uint8_t('f'));
   60|   214k|   const auto is_decimal = CT::Mask<uint8_t>::is_within_range(c, uint8_t('0'), uint8_t('9'));
   61|       |
   62|   214k|   const auto is_whitespace =
   63|   214k|      CT::Mask<uint8_t>::is_any_of(c, {uint8_t(' '), uint8_t('\t'), uint8_t('\n'), uint8_t('\r')});
   64|       |
   65|   214k|   const uint8_t c_upper = c - uint8_t('A') + 10;
   66|   214k|   const uint8_t c_lower = c - uint8_t('a') + 10;
   67|   214k|   const uint8_t c_decim = c - uint8_t('0');
   68|       |
   69|   214k|   uint8_t ret = 0xFF;  // default value
   70|       |
   71|   214k|   ret = is_alpha_upper.select(c_upper, ret);
   72|   214k|   ret = is_alpha_lower.select(c_lower, ret);
   73|   214k|   ret = is_decimal.select(c_decim, ret);
   74|   214k|   ret = is_whitespace.select(0x80, ret);
   75|       |
   76|   214k|   return ret;
   77|   214k|}

_ZN5Botan10GOST_34_11C2Ev:
   18|    123|GOST_34_11::GOST_34_11() : m_cipher(GOST_28147_89_Params("R3411_CryptoPro")), m_sum(32), m_hash(32) {
   19|    123|   m_count = 0;
   20|    123|}
_ZN5Botan10GOST_34_115clearEv:
   22|    123|void GOST_34_11::clear() {
   23|    123|   m_cipher.clear();
   24|    123|   zeroise(m_sum);
   25|    123|   zeroise(m_hash);
   26|    123|   m_count = 0;
   27|    123|   m_buffer.clear();
   28|    123|}
_ZN5Botan10GOST_34_118add_dataENSt3__14spanIKhLm18446744073709551615EEE:
   37|    123|void GOST_34_11::add_data(std::span<const uint8_t> input) {
   38|    123|   BufferSlicer in(input);
   39|       |
   40|    369|   while(!in.empty()) {
  ------------------
  |  Branch (40:10): [True: 246, False: 123]
  ------------------
   41|    246|      if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (41:21): [True: 0, False: 246]
  ------------------
   42|      0|         compress_n(one_block->data(), 1);
   43|      0|      }
   44|       |
   45|    246|      if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (45:10): [True: 123, False: 123]
  ------------------
   46|    123|         const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   47|    123|         if(full_blocks > 0) {
  ------------------
  |  Branch (47:13): [True: 123, False: 0]
  ------------------
   48|    123|            compress_n(aligned_data.data(), full_blocks);
   49|    123|         }
   50|    123|      }
   51|    246|   }
   52|       |
   53|    123|   m_count += input.size();
   54|    123|}
_ZN5Botan10GOST_34_1110compress_nEPKhm:
   59|    492|void GOST_34_11::compress_n(const uint8_t input[], size_t blocks) {
   60|  2.33k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (60:22): [True: 1.84k, False: 492]
  ------------------
   61|  60.8k|      for(uint16_t j = 0, carry = 0; j != 32; ++j) {
  ------------------
  |  Branch (61:38): [True: 59.0k, False: 1.84k]
  ------------------
   62|  59.0k|         uint16_t s = m_sum[j] + input[32 * i + j] + carry;
   63|  59.0k|         carry = get_byte<0>(s);
   64|  59.0k|         m_sum[j] = get_byte<1>(s);
   65|  59.0k|      }
   66|       |
   67|  1.84k|      uint8_t S[32] = {0};
   68|       |
   69|  1.84k|      uint64_t U[4], V[4];
   70|  1.84k|      load_be(U, m_hash.data(), 4);
   71|  1.84k|      load_be(V, input + 32 * i, 4);
   72|       |
   73|  7.38k|      for(size_t j = 0; j != 4; ++j) {
  ------------------
  |  Branch (73:25): [True: 7.38k, False: 0]
  ------------------
   74|  7.38k|         uint8_t key[32] = {0};
   75|       |
   76|       |         // P transformation
   77|  36.9k|         for(size_t k = 0; k != 4; ++k) {
  ------------------
  |  Branch (77:28): [True: 29.5k, False: 7.38k]
  ------------------
   78|  29.5k|            const uint64_t UVk = U[k] ^ V[k];
   79|   265k|            for(size_t l = 0; l != 8; ++l) {
  ------------------
  |  Branch (79:31): [True: 236k, False: 29.5k]
  ------------------
   80|   236k|               key[4 * l + k] = get_byte_var(l, UVk);
   81|   236k|            }
   82|  29.5k|         }
   83|       |
   84|  7.38k|         m_cipher.set_key(key, 32);
   85|  7.38k|         m_cipher.encrypt(&m_hash[8 * j], S + 8 * j);
   86|       |
   87|  7.38k|         if(j == 3) {
  ------------------
  |  Branch (87:13): [True: 1.84k, False: 5.53k]
  ------------------
   88|  1.84k|            break;
   89|  1.84k|         }
   90|       |
   91|       |         // A(x)
   92|  5.53k|         uint64_t A_U = U[0];
   93|  5.53k|         U[0] = U[1];
   94|  5.53k|         U[1] = U[2];
   95|  5.53k|         U[2] = U[3];
   96|  5.53k|         U[3] = U[0] ^ A_U;
   97|       |
   98|  5.53k|         if(j == 1)  // C_3
  ------------------
  |  Branch (98:13): [True: 1.84k, False: 3.69k]
  ------------------
   99|  1.84k|         {
  100|  1.84k|            U[0] ^= 0x00FF00FF00FF00FF;
  101|  1.84k|            U[1] ^= 0xFF00FF00FF00FF00;
  102|  1.84k|            U[2] ^= 0x00FFFF00FF0000FF;
  103|  1.84k|            U[3] ^= 0xFF000000FFFF00FF;
  104|  1.84k|         }
  105|       |
  106|       |         // A(A(x))
  107|  5.53k|         uint64_t AA_V_1 = V[0] ^ V[1];
  108|  5.53k|         uint64_t AA_V_2 = V[1] ^ V[2];
  109|  5.53k|         V[0] = V[2];
  110|  5.53k|         V[1] = V[3];
  111|  5.53k|         V[2] = AA_V_1;
  112|  5.53k|         V[3] = AA_V_2;
  113|  5.53k|      }
  114|       |
  115|  1.84k|      uint8_t S2[32] = {0};
  116|       |
  117|       |      // 12 rounds of psi
  118|  1.84k|      S2[0] = S[24];
  119|  1.84k|      S2[1] = S[25];
  120|  1.84k|      S2[2] = S[26];
  121|  1.84k|      S2[3] = S[27];
  122|  1.84k|      S2[4] = S[28];
  123|  1.84k|      S2[5] = S[29];
  124|  1.84k|      S2[6] = S[30];
  125|  1.84k|      S2[7] = S[31];
  126|  1.84k|      S2[8] = S[0] ^ S[2] ^ S[4] ^ S[6] ^ S[24] ^ S[30];
  127|  1.84k|      S2[9] = S[1] ^ S[3] ^ S[5] ^ S[7] ^ S[25] ^ S[31];
  128|  1.84k|      S2[10] = S[0] ^ S[8] ^ S[24] ^ S[26] ^ S[30];
  129|  1.84k|      S2[11] = S[1] ^ S[9] ^ S[25] ^ S[27] ^ S[31];
  130|  1.84k|      S2[12] = S[0] ^ S[4] ^ S[6] ^ S[10] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
  131|  1.84k|      S2[13] = S[1] ^ S[5] ^ S[7] ^ S[11] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
  132|  1.84k|      S2[14] = S[0] ^ S[4] ^ S[8] ^ S[12] ^ S[24] ^ S[26] ^ S[28];
  133|  1.84k|      S2[15] = S[1] ^ S[5] ^ S[9] ^ S[13] ^ S[25] ^ S[27] ^ S[29];
  134|  1.84k|      S2[16] = S[2] ^ S[6] ^ S[10] ^ S[14] ^ S[26] ^ S[28] ^ S[30];
  135|  1.84k|      S2[17] = S[3] ^ S[7] ^ S[11] ^ S[15] ^ S[27] ^ S[29] ^ S[31];
  136|  1.84k|      S2[18] = S[0] ^ S[2] ^ S[6] ^ S[8] ^ S[12] ^ S[16] ^ S[24] ^ S[28];
  137|  1.84k|      S2[19] = S[1] ^ S[3] ^ S[7] ^ S[9] ^ S[13] ^ S[17] ^ S[25] ^ S[29];
  138|  1.84k|      S2[20] = S[2] ^ S[4] ^ S[8] ^ S[10] ^ S[14] ^ S[18] ^ S[26] ^ S[30];
  139|  1.84k|      S2[21] = S[3] ^ S[5] ^ S[9] ^ S[11] ^ S[15] ^ S[19] ^ S[27] ^ S[31];
  140|  1.84k|      S2[22] = S[0] ^ S[2] ^ S[10] ^ S[12] ^ S[16] ^ S[20] ^ S[24] ^ S[28] ^ S[30];
  141|  1.84k|      S2[23] = S[1] ^ S[3] ^ S[11] ^ S[13] ^ S[17] ^ S[21] ^ S[25] ^ S[29] ^ S[31];
  142|  1.84k|      S2[24] = S[0] ^ S[6] ^ S[12] ^ S[14] ^ S[18] ^ S[22] ^ S[24] ^ S[26];
  143|  1.84k|      S2[25] = S[1] ^ S[7] ^ S[13] ^ S[15] ^ S[19] ^ S[23] ^ S[25] ^ S[27];
  144|  1.84k|      S2[26] = S[2] ^ S[8] ^ S[14] ^ S[16] ^ S[20] ^ S[24] ^ S[26] ^ S[28];
  145|  1.84k|      S2[27] = S[3] ^ S[9] ^ S[15] ^ S[17] ^ S[21] ^ S[25] ^ S[27] ^ S[29];
  146|  1.84k|      S2[28] = S[4] ^ S[10] ^ S[16] ^ S[18] ^ S[22] ^ S[26] ^ S[28] ^ S[30];
  147|  1.84k|      S2[29] = S[5] ^ S[11] ^ S[17] ^ S[19] ^ S[23] ^ S[27] ^ S[29] ^ S[31];
  148|  1.84k|      S2[30] = S[0] ^ S[2] ^ S[4] ^ S[12] ^ S[18] ^ S[20] ^ S[28];
  149|  1.84k|      S2[31] = S[1] ^ S[3] ^ S[5] ^ S[13] ^ S[19] ^ S[21] ^ S[29];
  150|       |
  151|  1.84k|      xor_buf(S, S2, input + 32 * i, 32);
  152|       |
  153|  1.84k|      S2[0] = S[0] ^ S[2] ^ S[4] ^ S[6] ^ S[24] ^ S[30];
  154|  1.84k|      S2[1] = S[1] ^ S[3] ^ S[5] ^ S[7] ^ S[25] ^ S[31];
  155|       |
  156|  1.84k|      copy_mem(S, S + 2, 30);
  157|  1.84k|      S[30] = S2[0];
  158|  1.84k|      S[31] = S2[1];
  159|       |
  160|  1.84k|      xor_buf(S, m_hash.data(), 32);
  161|       |
  162|       |      // 61 rounds of psi
  163|  1.84k|      S2[0] = S[2] ^ S[6] ^ S[14] ^ S[20] ^ S[22] ^ S[26] ^ S[28] ^ S[30];
  164|  1.84k|      S2[1] = S[3] ^ S[7] ^ S[15] ^ S[21] ^ S[23] ^ S[27] ^ S[29] ^ S[31];
  165|  1.84k|      S2[2] = S[0] ^ S[2] ^ S[6] ^ S[8] ^ S[16] ^ S[22] ^ S[28];
  166|  1.84k|      S2[3] = S[1] ^ S[3] ^ S[7] ^ S[9] ^ S[17] ^ S[23] ^ S[29];
  167|  1.84k|      S2[4] = S[2] ^ S[4] ^ S[8] ^ S[10] ^ S[18] ^ S[24] ^ S[30];
  168|  1.84k|      S2[5] = S[3] ^ S[5] ^ S[9] ^ S[11] ^ S[19] ^ S[25] ^ S[31];
  169|  1.84k|      S2[6] = S[0] ^ S[2] ^ S[10] ^ S[12] ^ S[20] ^ S[24] ^ S[26] ^ S[30];
  170|  1.84k|      S2[7] = S[1] ^ S[3] ^ S[11] ^ S[13] ^ S[21] ^ S[25] ^ S[27] ^ S[31];
  171|  1.84k|      S2[8] = S[0] ^ S[6] ^ S[12] ^ S[14] ^ S[22] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
  172|  1.84k|      S2[9] = S[1] ^ S[7] ^ S[13] ^ S[15] ^ S[23] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
  173|  1.84k|      S2[10] = S[0] ^ S[4] ^ S[6] ^ S[8] ^ S[14] ^ S[16] ^ S[26] ^ S[28];
  174|  1.84k|      S2[11] = S[1] ^ S[5] ^ S[7] ^ S[9] ^ S[15] ^ S[17] ^ S[27] ^ S[29];
  175|  1.84k|      S2[12] = S[2] ^ S[6] ^ S[8] ^ S[10] ^ S[16] ^ S[18] ^ S[28] ^ S[30];
  176|  1.84k|      S2[13] = S[3] ^ S[7] ^ S[9] ^ S[11] ^ S[17] ^ S[19] ^ S[29] ^ S[31];
  177|  1.84k|      S2[14] = S[0] ^ S[2] ^ S[6] ^ S[8] ^ S[10] ^ S[12] ^ S[18] ^ S[20] ^ S[24];
  178|  1.84k|      S2[15] = S[1] ^ S[3] ^ S[7] ^ S[9] ^ S[11] ^ S[13] ^ S[19] ^ S[21] ^ S[25];
  179|  1.84k|      S2[16] = S[2] ^ S[4] ^ S[8] ^ S[10] ^ S[12] ^ S[14] ^ S[20] ^ S[22] ^ S[26];
  180|  1.84k|      S2[17] = S[3] ^ S[5] ^ S[9] ^ S[11] ^ S[13] ^ S[15] ^ S[21] ^ S[23] ^ S[27];
  181|  1.84k|      S2[18] = S[4] ^ S[6] ^ S[10] ^ S[12] ^ S[14] ^ S[16] ^ S[22] ^ S[24] ^ S[28];
  182|  1.84k|      S2[19] = S[5] ^ S[7] ^ S[11] ^ S[13] ^ S[15] ^ S[17] ^ S[23] ^ S[25] ^ S[29];
  183|  1.84k|      S2[20] = S[6] ^ S[8] ^ S[12] ^ S[14] ^ S[16] ^ S[18] ^ S[24] ^ S[26] ^ S[30];
  184|  1.84k|      S2[21] = S[7] ^ S[9] ^ S[13] ^ S[15] ^ S[17] ^ S[19] ^ S[25] ^ S[27] ^ S[31];
  185|  1.84k|      S2[22] = S[0] ^ S[2] ^ S[4] ^ S[6] ^ S[8] ^ S[10] ^ S[14] ^ S[16] ^ S[18] ^ S[20] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
  186|  1.84k|      S2[23] = S[1] ^ S[3] ^ S[5] ^ S[7] ^ S[9] ^ S[11] ^ S[15] ^ S[17] ^ S[19] ^ S[21] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
  187|  1.84k|      S2[24] = S[0] ^ S[8] ^ S[10] ^ S[12] ^ S[16] ^ S[18] ^ S[20] ^ S[22] ^ S[24] ^ S[26] ^ S[28];
  188|  1.84k|      S2[25] = S[1] ^ S[9] ^ S[11] ^ S[13] ^ S[17] ^ S[19] ^ S[21] ^ S[23] ^ S[25] ^ S[27] ^ S[29];
  189|  1.84k|      S2[26] = S[2] ^ S[10] ^ S[12] ^ S[14] ^ S[18] ^ S[20] ^ S[22] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
  190|  1.84k|      S2[27] = S[3] ^ S[11] ^ S[13] ^ S[15] ^ S[19] ^ S[21] ^ S[23] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
  191|  1.84k|      S2[28] = S[0] ^ S[2] ^ S[6] ^ S[12] ^ S[14] ^ S[16] ^ S[20] ^ S[22] ^ S[26] ^ S[28];
  192|  1.84k|      S2[29] = S[1] ^ S[3] ^ S[7] ^ S[13] ^ S[15] ^ S[17] ^ S[21] ^ S[23] ^ S[27] ^ S[29];
  193|  1.84k|      S2[30] = S[2] ^ S[4] ^ S[8] ^ S[14] ^ S[16] ^ S[18] ^ S[22] ^ S[24] ^ S[28] ^ S[30];
  194|  1.84k|      S2[31] = S[3] ^ S[5] ^ S[9] ^ S[15] ^ S[17] ^ S[19] ^ S[23] ^ S[25] ^ S[29] ^ S[31];
  195|       |
  196|  1.84k|      copy_mem(m_hash.data(), S2, 32);
  197|  1.84k|   }
  198|    492|}
_ZN5Botan10GOST_34_1112final_resultENSt3__14spanIhLm18446744073709551615EEE:
  203|    123|void GOST_34_11::final_result(std::span<uint8_t> out) {
  204|    123|   if(!m_buffer.in_alignment()) {
  ------------------
  |  Branch (204:7): [True: 123, False: 0]
  ------------------
  205|    123|      m_buffer.fill_up_with_zeros();
  206|    123|      compress_n(m_buffer.consume().data(), 1);
  207|    123|   }
  208|       |
  209|    123|   secure_vector<uint8_t> length_buf(32);
  210|    123|   const uint64_t bit_count = m_count * 8;
  211|    123|   store_le(bit_count, length_buf.data());
  212|       |
  213|    123|   secure_vector<uint8_t> sum_buf = m_sum;
  214|       |
  215|    123|   compress_n(length_buf.data(), 1);
  216|    123|   compress_n(sum_buf.data(), 1);
  217|       |
  218|    123|   copy_mem(out.data(), m_hash.data(), 32);
  219|       |
  220|    123|   clear();
  221|    123|}

_ZN5Botan12HashFunction6createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
  107|  19.5k|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|  19.5k|   if(provider.empty() == false && provider != "base") {
  ------------------
  |  Branch (118:7): [True: 0, False: 19.5k]
  |  Branch (118:36): [True: 0, False: 0]
  ------------------
  119|      0|      return nullptr;  // unknown provider
  120|      0|   }
  121|       |
  122|  19.5k|#if defined(BOTAN_HAS_SHA1)
  123|  19.5k|   if(algo_spec == "SHA-1") {
  ------------------
  |  Branch (123:7): [True: 8.94k, False: 10.5k]
  ------------------
  124|  8.94k|      return std::make_unique<SHA_1>();
  125|  8.94k|   }
  126|  10.5k|#endif
  127|       |
  128|  10.5k|#if defined(BOTAN_HAS_SHA2_32)
  129|  10.5k|   if(algo_spec == "SHA-224") {
  ------------------
  |  Branch (129:7): [True: 87, False: 10.5k]
  ------------------
  130|     87|      return std::make_unique<SHA_224>();
  131|     87|   }
  132|       |
  133|  10.5k|   if(algo_spec == "SHA-256") {
  ------------------
  |  Branch (133:7): [True: 9.47k, False: 1.02k]
  ------------------
  134|  9.47k|      return std::make_unique<SHA_256>();
  135|  9.47k|   }
  136|  1.02k|#endif
  137|       |
  138|  1.02k|#if defined(BOTAN_HAS_SHA2_64)
  139|  1.02k|   if(algo_spec == "SHA-384") {
  ------------------
  |  Branch (139:7): [True: 59, False: 970]
  ------------------
  140|     59|      return std::make_unique<SHA_384>();
  141|     59|   }
  142|       |
  143|    970|   if(algo_spec == "SHA-512") {
  ------------------
  |  Branch (143:7): [True: 74, False: 896]
  ------------------
  144|     74|      return std::make_unique<SHA_512>();
  145|     74|   }
  146|       |
  147|    896|   if(algo_spec == "SHA-512-256") {
  ------------------
  |  Branch (147:7): [True: 530, False: 366]
  ------------------
  148|    530|      return std::make_unique<SHA_512_256>();
  149|    530|   }
  150|    366|#endif
  151|       |
  152|    366|#if defined(BOTAN_HAS_RIPEMD_160)
  153|    366|   if(algo_spec == "RIPEMD-160") {
  ------------------
  |  Branch (153:7): [True: 0, False: 366]
  ------------------
  154|      0|      return std::make_unique<RIPEMD_160>();
  155|      0|   }
  156|    366|#endif
  157|       |
  158|    366|#if defined(BOTAN_HAS_WHIRLPOOL)
  159|    366|   if(algo_spec == "Whirlpool") {
  ------------------
  |  Branch (159:7): [True: 0, False: 366]
  ------------------
  160|      0|      return std::make_unique<Whirlpool>();
  161|      0|   }
  162|    366|#endif
  163|       |
  164|    366|#if defined(BOTAN_HAS_MD5)
  165|    366|   if(algo_spec == "MD5") {
  ------------------
  |  Branch (165:7): [True: 92, False: 274]
  ------------------
  166|     92|      return std::make_unique<MD5>();
  167|     92|   }
  168|    274|#endif
  169|       |
  170|    274|#if defined(BOTAN_HAS_MD4)
  171|    274|   if(algo_spec == "MD4") {
  ------------------
  |  Branch (171:7): [True: 0, False: 274]
  ------------------
  172|      0|      return std::make_unique<MD4>();
  173|      0|   }
  174|    274|#endif
  175|       |
  176|    274|#if defined(BOTAN_HAS_GOST_34_11)
  177|    274|   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11") {
  ------------------
  |  Branch (177:7): [True: 123, False: 151]
  |  Branch (177:41): [True: 0, False: 151]
  ------------------
  178|    123|      return std::make_unique<GOST_34_11>();
  179|    123|   }
  180|    151|#endif
  181|       |
  182|    151|#if defined(BOTAN_HAS_ADLER32)
  183|    151|   if(algo_spec == "Adler32") {
  ------------------
  |  Branch (183:7): [True: 0, False: 151]
  ------------------
  184|      0|      return std::make_unique<Adler32>();
  185|      0|   }
  186|    151|#endif
  187|       |
  188|    151|#if defined(BOTAN_HAS_CRC24)
  189|    151|   if(algo_spec == "CRC24") {
  ------------------
  |  Branch (189:7): [True: 0, False: 151]
  ------------------
  190|      0|      return std::make_unique<CRC24>();
  191|      0|   }
  192|    151|#endif
  193|       |
  194|    151|#if defined(BOTAN_HAS_CRC32)
  195|    151|   if(algo_spec == "CRC32") {
  ------------------
  |  Branch (195:7): [True: 0, False: 151]
  ------------------
  196|      0|      return std::make_unique<CRC32>();
  197|      0|   }
  198|    151|#endif
  199|       |
  200|    151|#if defined(BOTAN_HAS_STREEBOG)
  201|    151|   if(algo_spec == "Streebog-256") {
  ------------------
  |  Branch (201:7): [True: 151, False: 0]
  ------------------
  202|    151|      return std::make_unique<Streebog>(256);
  203|    151|   }
  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|  9.06k|std::unique_ptr<HashFunction> HashFunction::create_or_throw(std::string_view algo, std::string_view provider) {
  299|  9.06k|   if(auto hash = HashFunction::create(algo, provider)) {
  ------------------
  |  Branch (299:12): [True: 9.06k, False: 0]
  ------------------
  300|  9.06k|      return hash;
  301|  9.06k|   }
  302|      0|   throw Lookup_Error("Hash", algo, provider);
  303|  9.06k|}

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

_ZN5Botan5SHA_110compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   63|  17.6k|void SHA_1::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   64|  17.6k|   using namespace SHA1_F;
   65|       |
   66|  17.6k|#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
   67|  17.6k|   if(CPUID::has_intel_sha()) {
  ------------------
  |  Branch (67:7): [True: 0, False: 17.6k]
  ------------------
   68|      0|      return sha1_compress_x86(digest, input, blocks);
   69|      0|   }
   70|  17.6k|#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|  17.6k|#if defined(BOTAN_HAS_SHA1_SSE2)
   79|  17.6k|   if(CPUID::has_sse2()) {
  ------------------
  |  Branch (79:7): [True: 17.6k, False: 0]
  ------------------
   80|  17.6k|      return sse2_compress_n(digest, input, blocks);
   81|  17.6k|   }
   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|  17.8k|void SHA_1::init(digest_type& digest) {
  200|  17.8k|   digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0});
  201|  17.8k|}
_ZN5Botan5SHA_18add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  233|  8.94k|void SHA_1::add_data(std::span<const uint8_t> input) {
  234|  8.94k|   m_md.update(input);
  235|  8.94k|}
_ZN5Botan5SHA_112final_resultENSt3__14spanIhLm18446744073709551615EEE:
  237|  8.94k|void SHA_1::final_result(std::span<uint8_t> output) {
  238|  8.94k|   m_md.final(output);
  239|  8.94k|}

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

_ZN5Botan7SHA_25615compress_digestERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
   49|  22.0k|void SHA_256::compress_digest(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   50|  22.0k|#if defined(BOTAN_HAS_SHA2_32_X86)
   51|  22.0k|   if(CPUID::has_intel_sha()) {
  ------------------
  |  Branch (51:7): [True: 0, False: 22.0k]
  ------------------
   52|      0|      return SHA_256::compress_digest_x86(digest, input, blocks);
   53|      0|   }
   54|  22.0k|#endif
   55|       |
   56|  22.0k|#if defined(BOTAN_HAS_SHA2_32_X86_BMI2)
   57|  22.0k|   if(CPUID::has_bmi2()) {
  ------------------
  |  Branch (57:7): [True: 22.0k, False: 0]
  ------------------
   58|  22.0k|      return SHA_256::compress_digest_x86_bmi2(digest, input, blocks);
   59|  22.0k|   }
   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|    247|void SHA_224::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  177|    247|   SHA_256::compress_digest(digest, input, blocks);
  178|    247|}
_ZN5Botan7SHA_2244initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  180|    174|void SHA_224::init(digest_type& digest) {
  181|    174|   digest.assign({0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939, 0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4});
  182|    174|}
_ZN5Botan7SHA_2248add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  192|     87|void SHA_224::add_data(std::span<const uint8_t> input) {
  193|     87|   m_md.update(input);
  194|     87|}
_ZN5Botan7SHA_22412final_resultENSt3__14spanIhLm18446744073709551615EEE:
  196|     87|void SHA_224::final_result(std::span<uint8_t> output) {
  197|     87|   m_md.final(output);
  198|     87|}
_ZN5Botan7SHA_25610compress_nERNSt3__16vectorIjNS_16secure_allocatorIjEEEENS1_4spanIKhLm18446744073709551615EEEm:
  204|  21.8k|void SHA_256::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  205|  21.8k|   SHA_256::compress_digest(digest, input, blocks);
  206|  21.8k|}
_ZN5Botan7SHA_2564initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  208|  23.6k|void SHA_256::init(digest_type& digest) {
  209|  23.6k|   digest.assign({0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19});
  210|  23.6k|}
_ZN5Botan7SHA_2568add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  220|  14.4k|void SHA_256::add_data(std::span<const uint8_t> input) {
  221|  14.4k|   m_md.update(input);
  222|  14.4k|}
_ZN5Botan7SHA_25612final_resultENSt3__14spanIhLm18446744073709551615EEE:
  224|  14.1k|void SHA_256::final_result(std::span<uint8_t> output) {
  225|  14.1k|   m_md.final(output);
  226|  14.1k|}

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

_ZN5Botan7SHA_51215compress_digestERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
   43|  1.36k|void SHA_512::compress_digest(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   44|  1.36k|#if defined(BOTAN_HAS_SHA2_64_BMI2)
   45|  1.36k|   if(CPUID::has_bmi2()) {
  ------------------
  |  Branch (45:7): [True: 1.36k, False: 0]
  ------------------
   46|  1.36k|      return compress_digest_bmi2(digest, input, blocks);
   47|  1.36k|   }
   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|  1.08k|void SHA_512_256::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  186|  1.08k|   SHA_512::compress_digest(digest, input, blocks);
  187|  1.08k|}
_ZN5Botan7SHA_38410compress_nERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
  189|    124|void SHA_384::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  190|    124|   SHA_512::compress_digest(digest, input, blocks);
  191|    124|}
_ZN5Botan7SHA_51210compress_nERNSt3__16vectorImNS_16secure_allocatorImEEEENS1_4spanIKhLm18446744073709551615EEEm:
  193|    152|void SHA_512::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
  194|    152|   SHA_512::compress_digest(digest, input, blocks);
  195|    152|}
_ZN5Botan11SHA_512_2564initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  197|  1.06k|void SHA_512_256::init(digest_type& digest) {
  198|  1.06k|   digest.assign({0x22312194FC2BF72C,
  199|  1.06k|                  0x9F555FA3C84C64C2,
  200|  1.06k|                  0x2393B86B6F53B151,
  201|  1.06k|                  0x963877195940EABD,
  202|  1.06k|                  0x96283EE2A88EFFE3,
  203|  1.06k|                  0xBE5E1E2553863992,
  204|  1.06k|                  0x2B0199FC2C85B8AA,
  205|  1.06k|                  0x0EB72DDC81C52CA2});
  206|  1.06k|}
_ZN5Botan7SHA_3844initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  208|    118|void SHA_384::init(digest_type& digest) {
  209|    118|   digest.assign({0xCBBB9D5DC1059ED8,
  210|    118|                  0x629A292A367CD507,
  211|    118|                  0x9159015A3070DD17,
  212|    118|                  0x152FECD8F70E5939,
  213|    118|                  0x67332667FFC00B31,
  214|    118|                  0x8EB44A8768581511,
  215|    118|                  0xDB0C2E0D64F98FA7,
  216|    118|                  0x47B5481DBEFA4FA4});
  217|    118|}
_ZN5Botan7SHA_5124initERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  219|    148|void SHA_512::init(digest_type& digest) {
  220|    148|   digest.assign({0x6A09E667F3BCC908,
  221|    148|                  0xBB67AE8584CAA73B,
  222|    148|                  0x3C6EF372FE94F82B,
  223|    148|                  0xA54FF53A5F1D36F1,
  224|    148|                  0x510E527FADE682D1,
  225|    148|                  0x9B05688C2B3E6C1F,
  226|    148|                  0x1F83D9ABFB41BD6B,
  227|    148|                  0x5BE0CD19137E2179});
  228|    148|}
_ZN5Botan7SHA_3848add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  254|     59|void SHA_384::add_data(std::span<const uint8_t> input) {
  255|     59|   m_md.update(input);
  256|     59|}
_ZN5Botan7SHA_5128add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  258|     74|void SHA_512::add_data(std::span<const uint8_t> input) {
  259|     74|   m_md.update(input);
  260|     74|}
_ZN5Botan11SHA_512_2568add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  262|    530|void SHA_512_256::add_data(std::span<const uint8_t> input) {
  263|    530|   m_md.update(input);
  264|    530|}
_ZN5Botan7SHA_38412final_resultENSt3__14spanIhLm18446744073709551615EEE:
  266|     59|void SHA_384::final_result(std::span<uint8_t> output) {
  267|     59|   m_md.final(output);
  268|     59|}
_ZN5Botan7SHA_51212final_resultENSt3__14spanIhLm18446744073709551615EEE:
  270|     74|void SHA_512::final_result(std::span<uint8_t> output) {
  271|     74|   m_md.final(output);
  272|     74|}
_ZN5Botan11SHA_512_25612final_resultENSt3__14spanIhLm18446744073709551615EEE:
  274|    530|void SHA_512_256::final_result(std::span<uint8_t> output) {
  275|    530|   m_md.final(output);
  276|    530|}

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

_ZN5Botan8StreebogC2Em:
   25|    151|Streebog::Streebog(size_t output_bits) : m_output_bits(output_bits), m_count(0), m_h(8), m_S(8) {
   26|    151|   if(output_bits != 256 && output_bits != 512) {
  ------------------
  |  Branch (26:7): [True: 0, False: 151]
  |  Branch (26:29): [True: 0, False: 0]
  ------------------
   27|      0|      throw Invalid_Argument(fmt("Streebog: Invalid output length {}", output_bits));
   28|      0|   }
   29|       |
   30|    151|   clear();
   31|    151|}
_ZNK5Botan8Streebog4nameEv:
   33|      7|std::string Streebog::name() const {
   34|      7|   return fmt("Streebog-{}", m_output_bits);
   35|      7|}
_ZN5Botan8Streebog5clearEv:
   40|    302|void Streebog::clear() {
   41|    302|   m_count = 0;
   42|    302|   m_buffer.clear();
   43|    302|   zeroise(m_S);
   44|       |
   45|    302|   const uint64_t fill = (m_output_bits == 512) ? 0 : 0x0101010101010101;
  ------------------
  |  Branch (45:26): [True: 0, False: 302]
  ------------------
   46|    302|   std::fill(m_h.begin(), m_h.end(), fill);
   47|    302|}
_ZN5Botan8Streebog8add_dataENSt3__14spanIKhLm18446744073709551615EEE:
   52|    151|void Streebog::add_data(std::span<const uint8_t> input) {
   53|    151|   BufferSlicer in(input);
   54|       |
   55|    453|   while(!in.empty()) {
  ------------------
  |  Branch (55:10): [True: 302, False: 151]
  ------------------
   56|    302|      if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (56:21): [True: 0, False: 302]
  ------------------
   57|      0|         compress(one_block->data());
   58|      0|         m_count += 512;
   59|      0|      }
   60|       |
   61|    302|      if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (61:10): [True: 151, False: 151]
  ------------------
   62|  1.35k|         while(const auto aligned_block = m_buffer.next_aligned_block_to_process(in)) {
  ------------------
  |  Branch (62:27): [True: 1.20k, False: 151]
  ------------------
   63|  1.20k|            compress(aligned_block->data());
   64|  1.20k|            m_count += 512;
   65|  1.20k|         }
   66|    151|      }
   67|    302|   }
   68|    151|}
_ZN5Botan8Streebog12final_resultENSt3__14spanIhLm18446744073709551615EEE:
   73|    151|void Streebog::final_result(std::span<uint8_t> output) {
   74|    151|   const auto pos = m_buffer.elements_in_buffer();
   75|       |
   76|    151|   const uint8_t padding = 0x01;
   77|    151|   m_buffer.append({&padding, 1});
   78|    151|   m_buffer.fill_up_with_zeros();
   79|       |
   80|    151|   compress(m_buffer.consume().data());
   81|    151|   m_count += pos * 8;
   82|       |
   83|    151|   m_buffer.fill_up_with_zeros();
   84|    151|   store_le(m_count, m_buffer.directly_modify_first(sizeof(m_count)).data());
   85|    151|   compress(m_buffer.consume().data(), true);
   86|       |
   87|    151|   compress_64(m_S.data(), true);
   88|       |   // FIXME
   89|    151|   std::memcpy(output.data(), &m_h[8 - output_length() / 8], output_length());
   90|    151|   clear();
   91|    151|}
_ZN5Botan8Streebog8compressEPKhb:
  121|  1.51k|void Streebog::compress(const uint8_t input[], bool last_block) {
  122|  1.51k|   uint64_t M[8];
  123|  1.51k|   std::memcpy(M, input, 64);
  124|       |
  125|  1.51k|   compress_64(M, last_block);
  126|  1.51k|}
_ZN5Botan8Streebog11compress_64EPKmb:
  128|  1.66k|void Streebog::compress_64(const uint64_t M[], bool last_block) {
  129|  1.66k|   const uint64_t N = last_block ? 0 : force_le(m_count);
  ------------------
  |  Branch (129:23): [True: 302, False: 1.35k]
  ------------------
  130|       |
  131|  1.66k|   uint64_t hN[8];
  132|  1.66k|   uint64_t A[8];
  133|       |
  134|  1.66k|   copy_mem(hN, m_h.data(), 8);
  135|  1.66k|   hN[0] ^= N;
  136|  1.66k|   lps(hN);
  137|       |
  138|  1.66k|   copy_mem(A, hN, 8);
  139|       |
  140|  14.9k|   for(size_t i = 0; i != 8; ++i) {
  ------------------
  |  Branch (140:22): [True: 13.2k, False: 1.66k]
  ------------------
  141|  13.2k|      hN[i] ^= M[i];
  142|  13.2k|   }
  143|       |
  144|  21.5k|   for(size_t i = 0; i < 12; ++i) {
  ------------------
  |  Branch (144:22): [True: 19.9k, False: 1.66k]
  ------------------
  145|   179k|      for(size_t j = 0; j != 8; ++j) {
  ------------------
  |  Branch (145:25): [True: 159k, False: 19.9k]
  ------------------
  146|   159k|         A[j] ^= force_le(STREEBOG_C[i][j]);
  147|   159k|      }
  148|  19.9k|      lps(A);
  149|       |
  150|  19.9k|      lps(hN);
  151|   179k|      for(size_t j = 0; j != 8; ++j) {
  ------------------
  |  Branch (151:25): [True: 159k, False: 19.9k]
  ------------------
  152|   159k|         hN[j] ^= A[j];
  153|   159k|      }
  154|  19.9k|   }
  155|       |
  156|  14.9k|   for(size_t i = 0; i != 8; ++i) {
  ------------------
  |  Branch (156:22): [True: 13.2k, False: 1.66k]
  ------------------
  157|  13.2k|      m_h[i] ^= hN[i] ^ M[i];
  158|  13.2k|   }
  159|       |
  160|  1.66k|   if(!last_block) {
  ------------------
  |  Branch (160:7): [True: 1.35k, False: 302]
  ------------------
  161|  1.35k|      uint64_t carry = 0;
  162|  12.2k|      for(int i = 0; i < 8; i++) {
  ------------------
  |  Branch (162:22): [True: 10.8k, False: 1.35k]
  ------------------
  163|  10.8k|         const uint64_t m = force_le(M[i]);
  164|  10.8k|         const uint64_t hi = force_le(m_S[i]);
  165|  10.8k|         const uint64_t t = hi + m + carry;
  166|       |
  167|  10.8k|         m_S[i] = force_le(t);
  168|  10.8k|         if(t != m) {
  ------------------
  |  Branch (168:13): [True: 9.66k, False: 1.20k]
  ------------------
  169|  9.66k|            carry = (t < m);
  170|  9.66k|         }
  171|  10.8k|      }
  172|  1.35k|   }
  173|  1.66k|}
streebog.cpp:_ZN5Botan12_GLOBAL__N_18force_leEm:
   95|  2.85M|inline uint64_t force_le(uint64_t x) {
   96|  2.85M|#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   97|  2.85M|   return x;
   98|       |#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   99|       |   return reverse_bytes(x);
  100|       |#else
  101|       |   store_le(x, reinterpret_cast<uint8_t*>(&x));
  102|       |   return x;
  103|       |#endif
  104|  2.85M|}
streebog.cpp:_ZN5Botan12_GLOBAL__N_13lpsEPm:
  106|  41.5k|inline void lps(uint64_t block[8]) {
  107|  41.5k|   uint8_t r[64];
  108|       |   // FIXME
  109|  41.5k|   std::memcpy(r, block, 64);
  110|       |
  111|   373k|   for(int i = 0; i < 8; ++i) {
  ------------------
  |  Branch (111:19): [True: 332k, False: 41.5k]
  ------------------
  112|   332k|      block[i] = force_le(STREEBOG_Ax[0][r[i + 0 * 8]]) ^ force_le(STREEBOG_Ax[1][r[i + 1 * 8]]) ^
  113|   332k|                 force_le(STREEBOG_Ax[2][r[i + 2 * 8]]) ^ force_le(STREEBOG_Ax[3][r[i + 3 * 8]]) ^
  114|   332k|                 force_le(STREEBOG_Ax[4][r[i + 4 * 8]]) ^ force_le(STREEBOG_Ax[5][r[i + 5 * 8]]) ^
  115|   332k|                 force_le(STREEBOG_Ax[6][r[i + 6 * 8]]) ^ force_le(STREEBOG_Ax[7][r[i + 7 * 8]]);
  116|   332k|   }
  117|  41.5k|}

_ZN5Botan6BigInt11encode_1363ERKS0_m:
  105|    523|secure_vector<uint8_t> BigInt::encode_1363(const BigInt& n, size_t bytes) {
  106|    523|   if(n.bytes() > bytes) {
  ------------------
  |  Branch (106:7): [True: 28, False: 495]
  ------------------
  107|     28|      throw Encoding_Error("encode_1363: n is too large to encode properly");
  108|     28|   }
  109|       |
  110|    495|   secure_vector<uint8_t> output(bytes);
  111|    495|   n.binary_encode(output.data(), output.size());
  112|    495|   return output;
  113|    523|}
_ZN5Botan6BigInt6decodeEPKhmNS0_4BaseE:
  151|  4.96k|BigInt BigInt::decode(const uint8_t buf[], size_t length, Base base) {
  152|  4.96k|   BigInt r;
  153|  4.96k|   if(base == Binary) {
  ------------------
  |  Branch (153:7): [True: 0, False: 4.96k]
  ------------------
  154|      0|      r.binary_decode(buf, length);
  155|  4.96k|   } else if(base == Hexadecimal) {
  ------------------
  |  Branch (155:14): [True: 4.14k, False: 820]
  ------------------
  156|  4.14k|      secure_vector<uint8_t> binary;
  157|       |
  158|  4.14k|      if(length % 2) {
  ------------------
  |  Branch (158:10): [True: 3, False: 4.14k]
  ------------------
  159|       |         // Handle lack of leading 0
  160|      3|         const char buf0_with_leading_0[2] = {'0', static_cast<char>(buf[0])};
  161|       |
  162|      3|         binary = hex_decode_locked(buf0_with_leading_0, 2);
  163|       |
  164|      3|         binary += hex_decode_locked(cast_uint8_ptr_to_char(&buf[1]), length - 1, false);
  165|  4.14k|      } else {
  166|  4.14k|         binary = hex_decode_locked(cast_uint8_ptr_to_char(buf), length, false);
  167|  4.14k|      }
  168|       |
  169|  4.14k|      r.binary_decode(binary.data(), binary.size());
  170|  4.14k|   } else if(base == Decimal) {
  ------------------
  |  Branch (170:14): [True: 820, False: 0]
  ------------------
  171|       |      // This could be made faster using the same trick as to_dec_string
  172|  1.64k|      for(size_t i = 0; i != length; ++i) {
  ------------------
  |  Branch (172:25): [True: 820, False: 820]
  ------------------
  173|    820|         const char c = buf[i];
  174|       |
  175|    820|         if(c < '0' || c > '9') {
  ------------------
  |  Branch (175:13): [True: 0, False: 820]
  |  Branch (175:24): [True: 0, False: 820]
  ------------------
  176|      0|            throw Invalid_Argument("BigInt::decode: invalid decimal char");
  177|      0|         }
  178|       |
  179|    820|         const uint8_t x = c - '0';
  180|    820|         BOTAN_ASSERT_NOMSG(x < 10);
  ------------------
  |  |   60|    820|   do {                                                                     \
  |  |   61|    820|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 820]
  |  |  ------------------
  |  |   62|    820|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    820|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  181|       |
  182|    820|         r *= 10;
  183|    820|         r += x;
  184|    820|      }
  185|    820|   } else {
  186|      0|      throw Invalid_Argument("Unknown BigInt decoding method");
  187|      0|   }
  188|  4.96k|   return r;
  189|  4.96k|}

_ZN5Botan6BigInt3addEPKmmNS0_4SignE:
   16|   108k|BigInt& BigInt::add(const word y[], size_t y_words, Sign y_sign) {
   17|   108k|   const size_t x_sw = sig_words();
   18|       |
   19|   108k|   grow_to(std::max(x_sw, y_words) + 1);
   20|       |
   21|   108k|   if(sign() == y_sign) {
  ------------------
  |  Branch (21:7): [True: 60.6k, False: 47.4k]
  ------------------
   22|  60.6k|      bigint_add2(mutable_data(), size() - 1, y, y_words);
   23|  60.6k|   } else {
   24|  47.4k|      const int32_t relative_size = bigint_cmp(data(), x_sw, y, y_words);
   25|       |
   26|  47.4k|      if(relative_size >= 0) {
  ------------------
  |  Branch (26:10): [True: 47.2k, False: 241]
  ------------------
   27|       |         // *this >= y
   28|  47.2k|         bigint_sub2(mutable_data(), x_sw, y, y_words);
   29|  47.2k|      } else {
   30|       |         // *this < y
   31|    241|         bigint_sub2_rev(mutable_data(), y, y_words);
   32|    241|      }
   33|       |
   34|       |      //this->sign_fixup(relative_size, y_sign);
   35|  47.4k|      if(relative_size < 0) {
  ------------------
  |  Branch (35:10): [True: 241, False: 47.2k]
  ------------------
   36|    241|         set_sign(y_sign);
   37|  47.2k|      } else if(relative_size == 0) {
  ------------------
  |  Branch (37:17): [True: 0, False: 47.2k]
  ------------------
   38|      0|         set_sign(Positive);
   39|      0|      }
   40|  47.4k|   }
   41|       |
   42|   108k|   return (*this);
   43|   108k|}
_ZN5Botan6BigInt7mod_addERKS0_S2_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   45|   399k|BigInt& BigInt::mod_add(const BigInt& s, const BigInt& mod, secure_vector<word>& ws) {
   46|   399k|   if(this->is_negative() || s.is_negative() || mod.is_negative()) {
  ------------------
  |  Branch (46:7): [True: 0, False: 399k]
  |  Branch (46:30): [True: 0, False: 399k]
  |  Branch (46:49): [True: 0, False: 399k]
  ------------------
   47|      0|      throw Invalid_Argument("BigInt::mod_add expects all arguments are positive");
   48|      0|   }
   49|       |
   50|   399k|   BOTAN_DEBUG_ASSERT(*this < mod);
  ------------------
  |  |   99|   399k|      do {                          \
  |  |  100|   399k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   51|   399k|   BOTAN_DEBUG_ASSERT(s < mod);
  ------------------
  |  |   99|   399k|      do {                          \
  |  |  100|   399k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   52|       |
   53|       |   /*
   54|       |   t + s or t + s - p == t - (p - s)
   55|       |
   56|       |   So first compute ws = p - s
   57|       |
   58|       |   Then compute t + s and t - ws
   59|       |
   60|       |   If t - ws does not borrow, then that is the correct valued
   61|       |   */
   62|       |
   63|   399k|   const size_t mod_sw = mod.sig_words();
   64|   399k|   BOTAN_ARG_CHECK(mod_sw > 0, "BigInt::mod_add modulus must be positive");
  ------------------
  |  |   30|   399k|   do {                                                          \
  |  |   31|   399k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 399k]
  |  |  ------------------
  |  |   32|   399k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|   399k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   65|       |
   66|   399k|   this->grow_to(mod_sw);
   67|   399k|   s.grow_to(mod_sw);
   68|       |
   69|       |   // First mod_sw for p - s, 2*mod_sw for bigint_addsub workspace
   70|   399k|   if(ws.size() < 3 * mod_sw) {
  ------------------
  |  Branch (70:7): [True: 288k, False: 111k]
  ------------------
   71|   288k|      ws.resize(3 * mod_sw);
   72|   288k|   }
   73|       |
   74|   399k|   word borrow = bigint_sub3(&ws[0], mod.data(), mod_sw, s.data(), mod_sw);
   75|   399k|   BOTAN_DEBUG_ASSERT(borrow == 0);
  ------------------
  |  |   99|   399k|      do {                          \
  |  |  100|   399k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   76|   399k|   BOTAN_UNUSED(borrow);
  ------------------
  |  |  118|   399k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
   77|       |
   78|       |   // Compute t - ws
   79|   399k|   borrow = bigint_sub3(&ws[mod_sw], this->data(), mod_sw, &ws[0], mod_sw);
   80|       |
   81|       |   // Compute t + s
   82|   399k|   bigint_add3_nc(&ws[mod_sw * 2], this->data(), mod_sw, s.data(), mod_sw);
   83|       |
   84|   399k|   CT::conditional_copy_mem(borrow, &ws[0], &ws[mod_sw * 2], &ws[mod_sw], mod_sw);
   85|   399k|   set_words(&ws[0], mod_sw);
   86|       |
   87|   399k|   return (*this);
   88|   399k|}
_ZN5Botan6BigInt7mod_subERKS0_S2_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   90|  5.27M|BigInt& BigInt::mod_sub(const BigInt& s, const BigInt& mod, secure_vector<word>& ws) {
   91|  5.27M|   if(this->is_negative() || s.is_negative() || mod.is_negative()) {
  ------------------
  |  Branch (91:7): [True: 0, False: 5.27M]
  |  Branch (91:30): [True: 0, False: 5.27M]
  |  Branch (91:49): [True: 0, False: 5.27M]
  ------------------
   92|      0|      throw Invalid_Argument("BigInt::mod_sub expects all arguments are positive");
   93|      0|   }
   94|       |
   95|       |   // We are assuming in this function that *this and s are no more than mod_sw words long
   96|  5.27M|   BOTAN_DEBUG_ASSERT(*this < mod);
  ------------------
  |  |   99|  5.27M|      do {                          \
  |  |  100|  5.27M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   97|  5.27M|   BOTAN_DEBUG_ASSERT(s < mod);
  ------------------
  |  |   99|  5.27M|      do {                          \
  |  |  100|  5.27M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|       |
   99|  5.27M|   const size_t mod_sw = mod.sig_words();
  100|       |
  101|  5.27M|   this->grow_to(mod_sw);
  102|  5.27M|   s.grow_to(mod_sw);
  103|       |
  104|  5.27M|   if(ws.size() < mod_sw) {
  ------------------
  |  Branch (104:7): [True: 0, False: 5.27M]
  ------------------
  105|      0|      ws.resize(mod_sw);
  106|      0|   }
  107|       |
  108|  5.27M|   if(mod_sw == 4) {
  ------------------
  |  Branch (108:7): [True: 5.24M, False: 27.6k]
  ------------------
  109|  5.24M|      bigint_mod_sub_n<4>(mutable_data(), s.data(), mod.data(), ws.data());
  110|  5.24M|   } else if(mod_sw == 6) {
  ------------------
  |  Branch (110:14): [True: 0, False: 27.6k]
  ------------------
  111|      0|      bigint_mod_sub_n<6>(mutable_data(), s.data(), mod.data(), ws.data());
  112|  27.6k|   } else {
  113|  27.6k|      bigint_mod_sub(mutable_data(), s.data(), mod.data(), mod_sw, ws.data());
  114|  27.6k|   }
  115|       |
  116|  5.27M|   return (*this);
  117|  5.27M|}
_ZN5Botan6BigInt7mod_mulEhRKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  119|  1.59M|BigInt& BigInt::mod_mul(uint8_t y, const BigInt& mod, secure_vector<word>& ws) {
  120|  1.59M|   BOTAN_ARG_CHECK(this->is_negative() == false, "*this must be positive");
  ------------------
  |  |   30|  1.59M|   do {                                                          \
  |  |   31|  1.59M|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 1.59M]
  |  |  ------------------
  |  |   32|  1.59M|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.59M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  121|  1.59M|   BOTAN_ARG_CHECK(y < 16, "y too large");
  ------------------
  |  |   30|  1.59M|   do {                                                          \
  |  |   31|  1.59M|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 1.59M]
  |  |  ------------------
  |  |   32|  1.59M|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  1.59M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  122|       |
  123|  1.59M|   BOTAN_DEBUG_ASSERT(*this < mod);
  ------------------
  |  |   99|  1.59M|      do {                          \
  |  |  100|  1.59M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|       |
  125|  1.59M|   *this *= static_cast<word>(y);
  126|  1.59M|   this->reduce_below(mod, ws);
  127|  1.59M|   return (*this);
  128|  1.59M|}
_ZN5Botan6BigInt7rev_subEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
  130|  11.3k|BigInt& BigInt::rev_sub(const word y[], size_t y_sw, secure_vector<word>& ws) {
  131|  11.3k|   if(this->sign() != BigInt::Positive) {
  ------------------
  |  Branch (131:7): [True: 0, False: 11.3k]
  ------------------
  132|      0|      throw Invalid_State("BigInt::sub_rev requires this is positive");
  133|      0|   }
  134|       |
  135|  11.3k|   const size_t x_sw = this->sig_words();
  136|       |
  137|  11.3k|   ws.resize(std::max(x_sw, y_sw));
  138|  11.3k|   clear_mem(ws.data(), ws.size());
  139|       |
  140|  11.3k|   const int32_t relative_size = bigint_sub_abs(ws.data(), data(), x_sw, y, y_sw);
  141|       |
  142|  11.3k|   this->cond_flip_sign(relative_size > 0);
  143|  11.3k|   this->swap_reg(ws);
  144|       |
  145|  11.3k|   return (*this);
  146|  11.3k|}
_ZN5Botan6BigInt3mulERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  156|  22.7k|BigInt& BigInt::mul(const BigInt& y, secure_vector<word>& ws) {
  157|  22.7k|   const size_t x_sw = sig_words();
  158|  22.7k|   const size_t y_sw = y.sig_words();
  159|  22.7k|   set_sign((sign() == y.sign()) ? Positive : Negative);
  ------------------
  |  Branch (159:13): [True: 22.7k, False: 0]
  ------------------
  160|       |
  161|  22.7k|   if(x_sw == 0 || y_sw == 0) {
  ------------------
  |  Branch (161:7): [True: 6.87k, False: 15.9k]
  |  Branch (161:20): [True: 0, False: 15.9k]
  ------------------
  162|  6.87k|      clear();
  163|  6.87k|      set_sign(Positive);
  164|  15.9k|   } else if(x_sw == 1 && y_sw) {
  ------------------
  |  Branch (164:14): [True: 4.78k, False: 11.1k]
  |  Branch (164:27): [True: 4.78k, False: 0]
  ------------------
  165|  4.78k|      grow_to(y_sw + 1);
  166|  4.78k|      bigint_linmul3(mutable_data(), y.data(), y_sw, word_at(0));
  167|  11.1k|   } else if(y_sw == 1 && x_sw) {
  ------------------
  |  Branch (167:14): [True: 0, False: 11.1k]
  |  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|  11.1k|   } else {
  171|  11.1k|      const size_t new_size = x_sw + y_sw + 1;
  172|  11.1k|      ws.resize(new_size);
  173|  11.1k|      secure_vector<word> z_reg(new_size);
  174|       |
  175|  11.1k|      bigint_mul(z_reg.data(), z_reg.size(), data(), size(), x_sw, y.data(), y.size(), y_sw, ws.data(), ws.size());
  176|       |
  177|  11.1k|      this->swap_reg(z_reg);
  178|  11.1k|   }
  179|       |
  180|  22.7k|   return (*this);
  181|  22.7k|}
_ZN5Botan6BigInt6squareERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  183|  2.91k|BigInt& BigInt::square(secure_vector<word>& ws) {
  184|  2.91k|   const size_t sw = sig_words();
  185|       |
  186|  2.91k|   secure_vector<word> z(2 * sw);
  187|  2.91k|   ws.resize(z.size());
  188|       |
  189|  2.91k|   bigint_sqr(z.data(), z.size(), data(), size(), sw, ws.data(), ws.size());
  190|       |
  191|  2.91k|   swap_reg(z);
  192|  2.91k|   set_sign(BigInt::Positive);
  193|       |
  194|  2.91k|   return (*this);
  195|  2.91k|}
_ZN5Botan6BigIntmLEm:
  197|  4.86M|BigInt& BigInt::operator*=(word y) {
  198|  4.86M|   if(y == 0) {
  ------------------
  |  Branch (198:7): [True: 0, False: 4.86M]
  ------------------
  199|      0|      clear();
  200|      0|      set_sign(Positive);
  201|      0|   }
  202|       |
  203|  4.86M|   const word carry = bigint_linmul2(mutable_data(), size(), y);
  204|  4.86M|   set_word_at(size(), carry);
  205|       |
  206|  4.86M|   return (*this);
  207|  4.86M|}
_ZN5Botan6BigIntrMERKS0_:
  224|  45.4k|BigInt& BigInt::operator%=(const BigInt& mod) {
  225|  45.4k|   return (*this = (*this) % mod);
  226|  45.4k|}
_ZN5Botan6BigIntlSEm:
  260|  67.1k|BigInt& BigInt::operator<<=(size_t shift) {
  261|  67.1k|   const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  67.1k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  262|  67.1k|   const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  67.1k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  263|  67.1k|   const size_t size = sig_words();
  264|       |
  265|  67.1k|   const size_t bits_free = top_bits_free();
  266|       |
  267|  67.1k|   const size_t new_size = size + shift_words + (bits_free < shift_bits);
  268|       |
  269|  67.1k|   m_data.grow_to(new_size);
  270|       |
  271|  67.1k|   bigint_shl1(m_data.mutable_data(), new_size, size, shift_words, shift_bits);
  272|       |
  273|  67.1k|   return (*this);
  274|  67.1k|}
_ZN5Botan6BigIntrSEm:
  279|   149k|BigInt& BigInt::operator>>=(size_t shift) {
  280|   149k|   const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|   149k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  281|   149k|   const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|   149k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  282|       |
  283|   149k|   bigint_shr1(m_data.mutable_data(), m_data.size(), shift_words, shift_bits);
  284|       |
  285|   149k|   if(is_negative() && is_zero()) {
  ------------------
  |  Branch (285:7): [True: 0, False: 149k]
  |  Branch (285:24): [True: 0, False: 0]
  ------------------
  286|      0|      set_sign(Positive);
  287|      0|   }
  288|       |
  289|   149k|   return (*this);
  290|   149k|}

_ZN5Botan6BigInt4add2ERKS0_PKmmNS0_4SignE:
   19|  28.9k|BigInt BigInt::add2(const BigInt& x, const word y[], size_t y_words, BigInt::Sign y_sign) {
   20|  28.9k|   const size_t x_sw = x.sig_words();
   21|       |
   22|  28.9k|   BigInt z = BigInt::with_capacity(std::max(x_sw, y_words) + 1);
   23|       |
   24|  28.9k|   if(x.sign() == y_sign) {
  ------------------
  |  Branch (24:7): [True: 7.17k, False: 21.7k]
  ------------------
   25|  7.17k|      bigint_add3(z.mutable_data(), x.data(), x_sw, y, y_words);
   26|  7.17k|      z.set_sign(x.sign());
   27|  21.7k|   } else {
   28|  21.7k|      const int32_t relative_size = bigint_sub_abs(z.mutable_data(), x.data(), x_sw, y, y_words);
   29|       |
   30|       |      //z.sign_fixup(relative_size, y_sign);
   31|  21.7k|      if(relative_size < 0) {
  ------------------
  |  Branch (31:10): [True: 0, False: 21.7k]
  ------------------
   32|      0|         z.set_sign(y_sign);
   33|  21.7k|      } else if(relative_size == 0) {
  ------------------
  |  Branch (33:17): [True: 0, False: 21.7k]
  ------------------
   34|      0|         z.set_sign(BigInt::Positive);
   35|  21.7k|      } else {
   36|  21.7k|         z.set_sign(x.sign());
   37|  21.7k|      }
   38|  21.7k|   }
   39|       |
   40|  28.9k|   return z;
   41|  28.9k|}
_ZN5BotanmlERKNS_6BigIntES2_:
   46|  7.17k|BigInt operator*(const BigInt& x, const BigInt& y) {
   47|  7.17k|   const size_t x_sw = x.sig_words();
   48|  7.17k|   const size_t y_sw = y.sig_words();
   49|       |
   50|  7.17k|   BigInt z = BigInt::with_capacity(x.size() + y.size());
   51|       |
   52|  7.17k|   if(x_sw == 1 && y_sw) {
  ------------------
  |  Branch (52:7): [True: 3.03k, False: 4.14k]
  |  Branch (52:20): [True: 3.03k, False: 0]
  ------------------
   53|  3.03k|      bigint_linmul3(z.mutable_data(), y.data(), y_sw, x.word_at(0));
   54|  4.14k|   } else if(y_sw == 1 && x_sw) {
  ------------------
  |  Branch (54:14): [True: 80, False: 4.06k]
  |  Branch (54:27): [True: 80, False: 0]
  ------------------
   55|     80|      bigint_linmul3(z.mutable_data(), x.data(), x_sw, y.word_at(0));
   56|  4.06k|   } else if(x_sw && y_sw) {
  ------------------
  |  Branch (56:14): [True: 4.04k, False: 22]
  |  Branch (56:22): [True: 4.03k, False: 11]
  ------------------
   57|  4.03k|      secure_vector<word> workspace(z.size());
   58|       |
   59|  4.03k|      bigint_mul(z.mutable_data(),
   60|  4.03k|                 z.size(),
   61|  4.03k|                 x.data(),
   62|  4.03k|                 x.size(),
   63|  4.03k|                 x_sw,
   64|  4.03k|                 y.data(),
   65|  4.03k|                 y.size(),
   66|  4.03k|                 y_sw,
   67|  4.03k|                 workspace.data(),
   68|  4.03k|                 workspace.size());
   69|  4.03k|   }
   70|       |
   71|  7.17k|   z.cond_flip_sign(x_sw > 0 && y_sw > 0 && x.sign() != y.sign());
  ------------------
  |  Branch (71:21): [True: 7.15k, False: 22]
  |  Branch (71:33): [True: 7.14k, False: 11]
  |  Branch (71:45): [True: 259, False: 6.88k]
  ------------------
   72|       |
   73|  7.17k|   return z;
   74|  7.17k|}
_ZN5BotanmlERKNS_6BigIntEm:
   79|  94.5k|BigInt operator*(const BigInt& x, word y) {
   80|  94.5k|   const size_t x_sw = x.sig_words();
   81|       |
   82|  94.5k|   BigInt z = BigInt::with_capacity(x_sw + 1);
   83|       |
   84|  94.5k|   if(x_sw && y) {
  ------------------
  |  Branch (84:7): [True: 94.5k, False: 0]
  |  Branch (84:15): [True: 46.2k, False: 48.2k]
  ------------------
   85|  46.2k|      bigint_linmul3(z.mutable_data(), x.data(), x_sw, y);
   86|  46.2k|      z.set_sign(x.sign());
   87|  46.2k|   }
   88|       |
   89|  94.5k|   return z;
   90|  94.5k|}
_ZN5BotandvERKNS_6BigIntEm:
  108|  45.4k|BigInt operator/(const BigInt& x, word y) {
  109|  45.4k|   if(y == 0) {
  ------------------
  |  Branch (109:7): [True: 0, False: 45.4k]
  ------------------
  110|      0|      throw Invalid_Argument("BigInt::operator/ divide by zero");
  111|      0|   }
  112|       |
  113|  45.4k|   BigInt q;
  114|  45.4k|   word r;
  115|  45.4k|   ct_divide_word(x, y, q, r);
  116|  45.4k|   return q;
  117|  45.4k|}
_ZN5BotanrmERKNS_6BigIntES2_:
  122|  46.8k|BigInt operator%(const BigInt& n, const BigInt& mod) {
  123|  46.8k|   if(mod.is_zero()) {
  ------------------
  |  Branch (123:7): [True: 0, False: 46.8k]
  ------------------
  124|      0|      throw Invalid_Argument("BigInt::operator% divide by zero");
  125|      0|   }
  126|  46.8k|   if(mod.is_negative()) {
  ------------------
  |  Branch (126:7): [True: 0, False: 46.8k]
  ------------------
  127|      0|      throw Invalid_Argument("BigInt::operator% modulus must be > 0");
  128|      0|   }
  129|  46.8k|   if(n.is_positive() && mod.is_positive() && n < mod) {
  ------------------
  |  Branch (129:7): [True: 46.8k, False: 0]
  |  Branch (129:26): [True: 46.8k, False: 0]
  |  Branch (129:47): [True: 1.33k, False: 45.4k]
  ------------------
  130|  1.33k|      return n;
  131|  1.33k|   }
  132|       |
  133|  45.4k|   if(mod.sig_words() == 1) {
  ------------------
  |  Branch (133:7): [True: 11.9k, False: 33.5k]
  ------------------
  134|  11.9k|      return BigInt::from_word(n % mod.word_at(0));
  135|  11.9k|   }
  136|       |
  137|  33.5k|   BigInt q, r;
  138|  33.5k|   vartime_divide(n, mod, q, r);
  139|  33.5k|   return r;
  140|  45.4k|}
_ZN5BotanrmERKNS_6BigIntEm:
  145|   115k|word operator%(const BigInt& n, word mod) {
  146|   115k|   if(mod == 0) {
  ------------------
  |  Branch (146:7): [True: 0, False: 115k]
  ------------------
  147|      0|      throw Invalid_Argument("BigInt::operator% divide by zero");
  148|      0|   }
  149|       |
  150|   115k|   if(mod == 1) {
  ------------------
  |  Branch (150:7): [True: 0, False: 115k]
  ------------------
  151|      0|      return 0;
  152|      0|   }
  153|       |
  154|   115k|   word remainder = 0;
  155|       |
  156|   115k|   if(is_power_of_2(mod)) {
  ------------------
  |  Branch (156:7): [True: 103k, False: 11.9k]
  ------------------
  157|   103k|      remainder = (n.word_at(0) & (mod - 1));
  158|   103k|   } else {
  159|  11.9k|      const size_t sw = n.sig_words();
  160|  24.5k|      for(size_t i = sw; i > 0; --i) {
  ------------------
  |  Branch (160:26): [True: 12.6k, False: 11.9k]
  ------------------
  161|  12.6k|         remainder = bigint_modop_vartime(remainder, n.word_at(i - 1), mod);
  162|  12.6k|      }
  163|  11.9k|   }
  164|       |
  165|   115k|   if(remainder && n.sign() == BigInt::Negative) {
  ------------------
  |  Branch (165:7): [True: 115k, False: 0]
  |  Branch (165:20): [True: 0, False: 115k]
  ------------------
  166|      0|      return mod - remainder;
  167|      0|   }
  168|   115k|   return remainder;
  169|   115k|}
_ZN5BotanlsERKNS_6BigIntEm:
  174|  33.5k|BigInt operator<<(const BigInt& x, size_t shift) {
  175|  33.5k|   const size_t shift_words = shift / BOTAN_MP_WORD_BITS, shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  33.5k|#define BOTAN_MP_WORD_BITS 64
  ------------------
                 const size_t shift_words = shift / BOTAN_MP_WORD_BITS, shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  33.5k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  176|       |
  177|  33.5k|   const size_t x_sw = x.sig_words();
  178|       |
  179|  33.5k|   BigInt y = BigInt::with_capacity(x_sw + shift_words + (shift_bits ? 1 : 0));
  ------------------
  |  Branch (179:59): [True: 0, False: 33.5k]
  ------------------
  180|  33.5k|   bigint_shl2(y.mutable_data(), x.data(), x_sw, shift_words, shift_bits);
  181|  33.5k|   y.set_sign(x.sign());
  182|  33.5k|   return y;
  183|  33.5k|}
_ZN5BotanrsERKNS_6BigIntEm:
  188|    496|BigInt operator>>(const BigInt& x, size_t shift) {
  189|    496|   const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|    496|#define BOTAN_MP_WORD_BITS 64
  ------------------
  190|    496|   const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|    496|#define BOTAN_MP_WORD_BITS 64
  ------------------
  191|    496|   const size_t x_sw = x.sig_words();
  192|       |
  193|    496|   if(shift_words >= x_sw) {
  ------------------
  |  Branch (193:7): [True: 0, False: 496]
  ------------------
  194|      0|      return BigInt::zero();
  195|      0|   }
  196|       |
  197|    496|   BigInt y = BigInt::with_capacity(x_sw - shift_words);
  198|    496|   bigint_shr2(y.mutable_data(), x.data(), x_sw, shift_words, shift_bits);
  199|       |
  200|    496|   if(x.is_negative() && y.is_zero()) {
  ------------------
  |  Branch (200:7): [True: 0, False: 496]
  |  Branch (200:26): [True: 0, False: 0]
  ------------------
  201|      0|      y.set_sign(BigInt::Positive);
  202|    496|   } else {
  203|    496|      y.set_sign(x.sign());
  204|    496|   }
  205|       |
  206|    496|   return y;
  207|    496|}

_ZN5Botan6BigIntC2Em:
   18|  1.45k|BigInt::BigInt(uint64_t n) {
   19|  1.45k|#if BOTAN_MP_WORD_BITS == 64
   20|  1.45k|   m_data.set_word_at(0, n);
   21|       |#else
   22|       |   m_data.set_word_at(1, static_cast<word>(n >> 32));
   23|       |   m_data.set_word_at(0, static_cast<word>(n));
   24|       |#endif
   25|  1.45k|}
_ZN5Botan6BigInt8from_u64Em:
   28|    167|BigInt BigInt::from_u64(uint64_t n) {
   29|    167|   BigInt bn;
   30|       |
   31|    167|#if BOTAN_MP_WORD_BITS == 64
   32|    167|   bn.set_word_at(0, n);
   33|       |#else
   34|       |   bn.set_word_at(1, static_cast<word>(n >> 32));
   35|       |   bn.set_word_at(0, static_cast<word>(n));
   36|       |#endif
   37|       |
   38|    167|   return bn;
   39|    167|}
_ZN5Botan6BigInt9from_wordEm:
   42|  11.9k|BigInt BigInt::from_word(word n) {
   43|  11.9k|   BigInt bn;
   44|  11.9k|   bn.set_word_at(0, n);
   45|  11.9k|   return bn;
   46|  11.9k|}
_ZN5Botan6BigInt8from_s32Ei:
   49|    167|BigInt BigInt::from_s32(int32_t n) {
   50|    167|   if(n >= 0) {
  ------------------
  |  Branch (50:7): [True: 0, False: 167]
  ------------------
   51|      0|      return BigInt::from_u64(static_cast<uint64_t>(n));
   52|    167|   } else {
   53|    167|      return -BigInt::from_u64(static_cast<uint64_t>(-n));
   54|    167|   }
   55|    167|}
_ZN5Botan6BigInt13with_capacityEm:
   58|   231k|BigInt BigInt::with_capacity(size_t size) {
   59|   231k|   BigInt bn;
   60|   231k|   bn.grow_to(size);
   61|   231k|   return bn;
   62|   231k|}
_ZN5Botan6BigIntC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   67|  4.96k|BigInt::BigInt(std::string_view str) {
   68|  4.96k|   Base base = Decimal;
   69|  4.96k|   size_t markers = 0;
   70|  4.96k|   bool negative = false;
   71|       |
   72|  4.96k|   if(str.length() > 0 && str[0] == '-') {
  ------------------
  |  Branch (72:7): [True: 4.96k, False: 0]
  |  Branch (72:27): [True: 0, False: 4.96k]
  ------------------
   73|      0|      markers += 1;
   74|      0|      negative = true;
   75|      0|   }
   76|       |
   77|  4.96k|   if(str.length() > markers + 2 && str[markers] == '0' && str[markers + 1] == 'x') {
  ------------------
  |  Branch (77:7): [True: 4.14k, False: 820]
  |  Branch (77:37): [True: 4.14k, False: 0]
  |  Branch (77:60): [True: 4.14k, False: 0]
  ------------------
   78|  4.14k|      markers += 2;
   79|  4.14k|      base = Hexadecimal;
   80|  4.14k|   }
   81|       |
   82|  4.96k|   *this = decode(cast_char_ptr_to_uint8(str.data()) + markers, str.length() - markers, base);
   83|       |
   84|  4.96k|   if(negative) {
  ------------------
  |  Branch (84:7): [True: 0, False: 4.96k]
  ------------------
   85|      0|      set_sign(Negative);
   86|  4.96k|   } else {
   87|  4.96k|      set_sign(Positive);
   88|  4.96k|   }
   89|  4.96k|}
_ZN5Botan6BigIntC2EPKhm:
   91|  16.9k|BigInt::BigInt(const uint8_t input[], size_t length) {
   92|  16.9k|   binary_decode(input, length);
   93|  16.9k|}
_ZN5Botan6BigInt24from_bytes_with_max_bitsEPKhmm:
  103|     56|BigInt BigInt::from_bytes_with_max_bits(const uint8_t input[], size_t length, size_t max_bits) {
  104|     56|   const size_t input_bits = 8 * length;
  105|       |
  106|     56|   BigInt bn;
  107|     56|   bn.binary_decode(input, length);
  108|       |
  109|     56|   if(input_bits > max_bits) {
  ------------------
  |  Branch (109:7): [True: 0, False: 56]
  ------------------
  110|      0|      const size_t bits_to_shift = input_bits - max_bits;
  111|       |
  112|      0|      bn >>= bits_to_shift;
  113|      0|   }
  114|       |
  115|     56|   return bn;
  116|     56|}
_ZNK5Botan6BigInt7byte_atEm:
  125|  15.4k|uint8_t BigInt::byte_at(size_t n) const {
  126|  15.4k|   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));
  127|  15.4k|}
_ZNK5Botan6BigInt8cmp_wordEm:
  129|  63.9k|int32_t BigInt::cmp_word(word other) const {
  130|  63.9k|   if(is_negative()) {
  ------------------
  |  Branch (130:7): [True: 174, False: 63.7k]
  ------------------
  131|    174|      return -1;  // other is positive ...
  132|    174|   }
  133|       |
  134|  63.7k|   const size_t sw = this->sig_words();
  135|  63.7k|   if(sw > 1) {
  ------------------
  |  Branch (135:7): [True: 49.6k, False: 14.1k]
  ------------------
  136|  49.6k|      return 1;  // must be larger since other is just one word ...
  137|  49.6k|   }
  138|       |
  139|  14.1k|   return bigint_cmp(this->data(), sw, &other, 1);
  140|  63.7k|}
_ZNK5Botan6BigInt3cmpERKS0_b:
  145|  5.13k|int32_t BigInt::cmp(const BigInt& other, bool check_signs) const {
  146|  5.13k|   if(check_signs) {
  ------------------
  |  Branch (146:7): [True: 5.13k, False: 0]
  ------------------
  147|  5.13k|      if(other.is_positive() && this->is_negative()) {
  ------------------
  |  Branch (147:10): [True: 5.13k, False: 0]
  |  Branch (147:33): [True: 0, False: 5.13k]
  ------------------
  148|      0|         return -1;
  149|      0|      }
  150|       |
  151|  5.13k|      if(other.is_negative() && this->is_positive()) {
  ------------------
  |  Branch (151:10): [True: 0, False: 5.13k]
  |  Branch (151:33): [True: 0, False: 0]
  ------------------
  152|      0|         return 1;
  153|      0|      }
  154|       |
  155|  5.13k|      if(other.is_negative() && this->is_negative()) {
  ------------------
  |  Branch (155:10): [True: 0, False: 5.13k]
  |  Branch (155:33): [True: 0, False: 0]
  ------------------
  156|      0|         return (-bigint_cmp(this->data(), this->size(), other.data(), other.size()));
  157|      0|      }
  158|  5.13k|   }
  159|       |
  160|  5.13k|   return bigint_cmp(this->data(), this->size(), other.data(), other.size());
  161|  5.13k|}
_ZNK5Botan6BigInt8is_equalERKS0_:
  163|  10.9k|bool BigInt::is_equal(const BigInt& other) const {
  164|  10.9k|   if(this->sign() != other.sign()) {
  ------------------
  |  Branch (164:7): [True: 0, False: 10.9k]
  ------------------
  165|      0|      return false;
  166|      0|   }
  167|       |
  168|  10.9k|   return bigint_ct_is_eq(this->data(), this->sig_words(), other.data(), other.sig_words()).as_bool();
  169|  10.9k|}
_ZNK5Botan6BigInt12is_less_thanERKS0_:
  171|  98.3k|bool BigInt::is_less_than(const BigInt& other) const {
  172|  98.3k|   if(this->is_negative() && other.is_positive()) {
  ------------------
  |  Branch (172:7): [True: 57, False: 98.2k]
  |  Branch (172:30): [True: 57, False: 0]
  ------------------
  173|     57|      return true;
  174|     57|   }
  175|       |
  176|  98.2k|   if(this->is_positive() && other.is_negative()) {
  ------------------
  |  Branch (176:7): [True: 98.2k, False: 0]
  |  Branch (176:30): [True: 0, False: 98.2k]
  ------------------
  177|      0|      return false;
  178|      0|   }
  179|       |
  180|  98.2k|   if(other.is_negative() && this->is_negative()) {
  ------------------
  |  Branch (180:7): [True: 0, False: 98.2k]
  |  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|  98.2k|   return bigint_ct_is_lt(this->data(), this->sig_words(), other.data(), other.sig_words()).as_bool();
  185|  98.2k|}
_ZNK5Botan6BigInt12encode_wordsEPmm:
  187|  1.49M|void BigInt::encode_words(word out[], size_t size) const {
  188|  1.49M|   const size_t words = sig_words();
  189|       |
  190|  1.49M|   if(words > size) {
  ------------------
  |  Branch (190:7): [True: 0, False: 1.49M]
  ------------------
  191|      0|      throw Encoding_Error("BigInt::encode_words value too large to encode");
  192|      0|   }
  193|       |
  194|  1.49M|   clear_mem(out, size);
  195|  1.49M|   copy_mem(out, data(), words);
  196|  1.49M|}
_ZNK5Botan6BigInt4Data14calc_sig_wordsEv:
  198|  4.58M|size_t BigInt::Data::calc_sig_words() const {
  199|  4.58M|   const size_t sz = m_reg.size();
  200|  4.58M|   size_t sig = sz;
  201|       |
  202|  4.58M|   word sub = 1;
  203|       |
  204|  59.7M|   for(size_t i = 0; i != sz; ++i) {
  ------------------
  |  Branch (204:22): [True: 55.1M, False: 4.58M]
  ------------------
  205|  55.1M|      const word w = m_reg[sz - i - 1];
  206|  55.1M|      sub &= ct_is_zero(w);
  207|  55.1M|      sig -= sub;
  208|  55.1M|   }
  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|  4.58M|   CT::unpoison(sig);
  215|       |
  216|  4.58M|   return sig;
  217|  4.58M|}
_ZNK5Botan6BigInt13get_substringEmm:
  222|   310k|uint32_t BigInt::get_substring(size_t offset, size_t length) const {
  223|   310k|   if(length == 0 || length > 32) {
  ------------------
  |  Branch (223:7): [True: 0, False: 310k]
  |  Branch (223:22): [True: 0, False: 310k]
  ------------------
  224|      0|      throw Invalid_Argument("BigInt::get_substring invalid substring length");
  225|      0|   }
  226|       |
  227|   310k|   const uint32_t mask = 0xFFFFFFFF >> (32 - length);
  228|       |
  229|   310k|   const size_t word_offset = offset / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|   310k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  230|   310k|   const size_t wshift = (offset % BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|   310k|#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|   310k|   const word w0 = word_at(word_offset);
  238|       |
  239|   310k|   if(wshift == 0 || (offset + length) / BOTAN_MP_WORD_BITS == word_offset) {
  ------------------
  |  |   50|   302k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  |  Branch (239:7): [True: 8.20k, False: 302k]
  |  Branch (239:22): [True: 295k, False: 6.81k]
  ------------------
  240|   304k|      return static_cast<uint32_t>(w0 >> wshift) & mask;
  241|   304k|   } else {
  242|  6.81k|      const word w1 = word_at(word_offset + 1);
  243|  6.81k|      return static_cast<uint32_t>((w0 >> wshift) | (w1 << (BOTAN_MP_WORD_BITS - wshift))) & mask;
  ------------------
  |  |   50|  6.81k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  244|  6.81k|   }
  245|   310k|}
_ZNK5Botan6BigInt5bytesEv:
  277|  15.6k|size_t BigInt::bytes() const {
  278|  15.6k|   return round_up(bits(), 8) / 8;
  279|  15.6k|}
_ZNK5Botan6BigInt13top_bits_freeEv:
  281|   177k|size_t BigInt::top_bits_free() const {
  282|   177k|   const size_t words = sig_words();
  283|       |
  284|   177k|   const word top_word = word_at(words - 1);
  285|   177k|   const size_t bits_used = high_bit(top_word);
  286|   177k|   CT::unpoison(bits_used);
  287|   177k|   return BOTAN_MP_WORD_BITS - bits_used;
  ------------------
  |  |   50|   177k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  288|   177k|}
_ZNK5Botan6BigInt4bitsEv:
  290|  79.6k|size_t BigInt::bits() const {
  291|  79.6k|   const size_t words = sig_words();
  292|       |
  293|  79.6k|   if(words == 0) {
  ------------------
  |  Branch (293:7): [True: 2.82k, False: 76.8k]
  ------------------
  294|  2.82k|      return 0;
  295|  2.82k|   }
  296|       |
  297|  76.8k|   const size_t full_words = (words - 1) * BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  76.8k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  298|  76.8k|   const size_t top_bits = BOTAN_MP_WORD_BITS - top_bits_free();
  ------------------
  |  |   50|  76.8k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  299|       |
  300|  76.8k|   return full_words + top_bits;
  301|  79.6k|}
_ZNK5Botan6BigIntngEv:
  306|    426|BigInt BigInt::operator-() const {
  307|    426|   BigInt x = (*this);
  308|    426|   x.flip_sign();
  309|    426|   return x;
  310|    426|}
_ZN5Botan6BigInt12reduce_belowERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  312|  1.63M|size_t BigInt::reduce_below(const BigInt& p, secure_vector<word>& ws) {
  313|  1.63M|   if(p.is_negative() || this->is_negative()) {
  ------------------
  |  Branch (313:7): [True: 0, False: 1.63M]
  |  Branch (313:26): [True: 0, False: 1.63M]
  ------------------
  314|      0|      throw Invalid_Argument("BigInt::reduce_below both values must be positive");
  315|      0|   }
  316|       |
  317|  1.63M|   const size_t p_words = p.sig_words();
  318|       |
  319|  1.63M|   if(size() < p_words + 1) {
  ------------------
  |  Branch (319:7): [True: 3, False: 1.63M]
  ------------------
  320|      3|      grow_to(p_words + 1);
  321|      3|   }
  322|       |
  323|  1.63M|   if(ws.size() < p_words + 1) {
  ------------------
  |  Branch (323:7): [True: 33.5k, False: 1.59M]
  ------------------
  324|  33.5k|      ws.resize(p_words + 1);
  325|  33.5k|   }
  326|       |
  327|  1.63M|   clear_mem(ws.data(), ws.size());
  328|       |
  329|  1.63M|   size_t reductions = 0;
  330|       |
  331|  4.22M|   for(;;) {
  332|  4.22M|      word borrow = bigint_sub3(ws.data(), data(), p_words + 1, p.data(), p_words);
  333|  4.22M|      if(borrow) {
  ------------------
  |  Branch (333:10): [True: 1.63M, False: 2.59M]
  ------------------
  334|  1.63M|         break;
  335|  1.63M|      }
  336|       |
  337|  2.59M|      ++reductions;
  338|  2.59M|      swap_reg(ws);
  339|  2.59M|   }
  340|       |
  341|  1.63M|   return reductions;
  342|  1.63M|}
_ZN5Botan6BigInt15ct_reduce_belowERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEEm:
  344|  11.3k|void BigInt::ct_reduce_below(const BigInt& mod, secure_vector<word>& ws, size_t bound) {
  345|  11.3k|   if(mod.is_negative() || this->is_negative()) {
  ------------------
  |  Branch (345:7): [True: 0, False: 11.3k]
  |  Branch (345:28): [True: 0, False: 11.3k]
  ------------------
  346|      0|      throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
  347|      0|   }
  348|       |
  349|  11.3k|   const size_t mod_words = mod.sig_words();
  350|       |
  351|  11.3k|   grow_to(mod_words);
  352|       |
  353|  11.3k|   const size_t sz = size();
  354|       |
  355|  11.3k|   ws.resize(sz);
  356|       |
  357|  11.3k|   clear_mem(ws.data(), sz);
  358|       |
  359|  34.1k|   for(size_t i = 0; i != bound; ++i) {
  ------------------
  |  Branch (359:22): [True: 22.7k, False: 11.3k]
  ------------------
  360|  22.7k|      word borrow = bigint_sub3(ws.data(), data(), sz, mod.data(), mod_words);
  361|       |
  362|  22.7k|      CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), data(), sz);
  363|  22.7k|   }
  364|  11.3k|}
_ZNK5Botan6BigInt13binary_encodeEPh:
  375|  6.57k|void BigInt::binary_encode(uint8_t buf[]) const {
  376|  6.57k|   this->binary_encode(buf, bytes());
  377|  6.57k|}
_ZNK5Botan6BigInt13binary_encodeEPhm:
  382|  7.06k|void BigInt::binary_encode(uint8_t output[], size_t len) const {
  383|  7.06k|   const size_t full_words = len / sizeof(word);
  384|  7.06k|   const size_t extra_bytes = len % sizeof(word);
  385|       |
  386|  55.6k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (386:22): [True: 48.6k, False: 7.06k]
  ------------------
  387|  48.6k|      const word w = word_at(i);
  388|  48.6k|      store_be(w, output + (len - (i + 1) * sizeof(word)));
  389|  48.6k|   }
  390|       |
  391|  7.06k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (391:7): [True: 3.89k, False: 3.17k]
  ------------------
  392|  3.89k|      const word w = word_at(full_words);
  393|       |
  394|  16.4k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (394:25): [True: 12.5k, False: 3.89k]
  ------------------
  395|  12.5k|         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);
  396|  12.5k|      }
  397|  3.89k|   }
  398|  7.06k|}
_ZN5Botan6BigInt13binary_decodeEPKhm:
  403|  21.3k|void BigInt::binary_decode(const uint8_t buf[], size_t length) {
  404|  21.3k|   clear();
  405|       |
  406|  21.3k|   const size_t full_words = length / sizeof(word);
  407|  21.3k|   const size_t extra_bytes = length % sizeof(word);
  408|       |
  409|  21.3k|   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
  ------------------
  |  Branch (409:52): [True: 13.0k, False: 8.29k]
  ------------------
  410|       |
  411|   125k|   for(size_t i = 0; i != full_words; ++i) {
  ------------------
  |  Branch (411:22): [True: 104k, False: 21.3k]
  ------------------
  412|   104k|      reg[i] = load_be<word>(buf + length - sizeof(word) * (i + 1), 0);
  413|   104k|   }
  414|       |
  415|  21.3k|   if(extra_bytes > 0) {
  ------------------
  |  Branch (415:7): [True: 13.0k, False: 8.29k]
  ------------------
  416|  44.0k|      for(size_t i = 0; i != extra_bytes; ++i) {
  ------------------
  |  Branch (416:25): [True: 30.9k, False: 13.0k]
  ------------------
  417|  30.9k|         reg[full_words] = (reg[full_words] << 8) | buf[i];
  418|  30.9k|      }
  419|  13.0k|   }
  420|       |
  421|  21.3k|   m_data.swap(reg);
  422|  21.3k|}
_ZN5Botan6BigInt12ct_cond_swapEbRS0_:
  467|  3.25M|void BigInt::ct_cond_swap(bool predicate, BigInt& other) {
  468|  3.25M|   const size_t max_words = std::max(size(), other.size());
  469|  3.25M|   grow_to(max_words);
  470|  3.25M|   other.grow_to(max_words);
  471|       |
  472|  3.25M|   bigint_cnd_swap(predicate, this->mutable_data(), other.mutable_data(), max_words);
  473|  3.25M|}
_ZN5Botan6BigInt14cond_flip_signEb:
  475|  67.3k|void BigInt::cond_flip_sign(bool predicate) {
  476|       |   // This code is assuming Negative == 0, Positive == 1
  477|       |
  478|  67.3k|   const auto mask = CT::Mask<uint8_t>::expand(predicate);
  479|       |
  480|  67.3k|   const uint8_t current_sign = static_cast<uint8_t>(sign());
  481|       |
  482|  67.3k|   const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
  483|       |
  484|  67.3k|   set_sign(static_cast<Sign>(new_sign));
  485|  67.3k|}

_ZN5Botan9ct_divideERKNS_6BigIntES2_RS0_S3_:
   48|  3.81k|void ct_divide(const BigInt& x, const BigInt& y, BigInt& q_out, BigInt& r_out) {
   49|  3.81k|   if(y.is_zero()) {
  ------------------
  |  Branch (49:7): [True: 0, False: 3.81k]
  ------------------
   50|      0|      throw Invalid_Argument("ct_divide: cannot divide by zero");
   51|      0|   }
   52|       |
   53|  3.81k|   const size_t x_words = x.sig_words();
   54|  3.81k|   const size_t y_words = y.sig_words();
   55|       |
   56|  3.81k|   const size_t x_bits = x.bits();
   57|       |
   58|  3.81k|   BigInt q = BigInt::with_capacity(x_words);
   59|  3.81k|   BigInt r = BigInt::with_capacity(y_words);
   60|  3.81k|   BigInt t = BigInt::with_capacity(y_words);  // a temporary
   61|       |
   62|  3.26M|   for(size_t i = 0; i != x_bits; ++i) {
  ------------------
  |  Branch (62:22): [True: 3.25M, False: 3.81k]
  ------------------
   63|  3.25M|      const size_t b = x_bits - 1 - i;
   64|  3.25M|      const bool x_b = x.get_bit(b);
   65|       |
   66|  3.25M|      r *= 2;
   67|  3.25M|      r.conditionally_set_bit(0, x_b);
   68|       |
   69|  3.25M|      const bool r_gte_y = bigint_sub3(t.mutable_data(), r.data(), r.size(), y.data(), y_words) == 0;
   70|       |
   71|  3.25M|      q.conditionally_set_bit(b, r_gte_y);
   72|  3.25M|      r.ct_cond_swap(r_gte_y, t);
   73|  3.25M|   }
   74|       |
   75|  3.81k|   sign_fixup(x, y, q, r);
   76|  3.81k|   r_out = r;
   77|  3.81k|   q_out = q;
   78|  3.81k|}
_ZN5Botan14ct_divide_wordERKNS_6BigIntEmRS0_Rm:
   80|  45.4k|void ct_divide_word(const BigInt& x, word y, BigInt& q_out, word& r_out) {
   81|  45.4k|   if(y == 0) {
  ------------------
  |  Branch (81:7): [True: 0, False: 45.4k]
  ------------------
   82|      0|      throw Invalid_Argument("ct_divide_word: cannot divide by zero");
   83|      0|   }
   84|       |
   85|  45.4k|   const size_t x_words = x.sig_words();
   86|  45.4k|   const size_t x_bits = x.bits();
   87|       |
   88|  45.4k|   BigInt q = BigInt::with_capacity(x_words);
   89|  45.4k|   word r = 0;
   90|       |
   91|  5.75M|   for(size_t i = 0; i != x_bits; ++i) {
  ------------------
  |  Branch (91:22): [True: 5.71M, False: 45.4k]
  ------------------
   92|  5.71M|      const size_t b = x_bits - 1 - i;
   93|  5.71M|      const bool x_b = x.get_bit(b);
   94|       |
   95|  5.71M|      const auto r_carry = CT::Mask<word>::expand(r >> (BOTAN_MP_WORD_BITS - 1));
  ------------------
  |  |   50|  5.71M|#define BOTAN_MP_WORD_BITS 64
  ------------------
   96|       |
   97|  5.71M|      r *= 2;
   98|  5.71M|      r += x_b;
   99|       |
  100|  5.71M|      const auto r_gte_y = CT::Mask<word>::is_gte(r, y) | r_carry;
  101|  5.71M|      q.conditionally_set_bit(b, r_gte_y.as_bool());
  102|  5.71M|      r = r_gte_y.select(r - y, r);
  103|  5.71M|   }
  104|       |
  105|  45.4k|   if(x.is_negative()) {
  ------------------
  |  Branch (105:7): [True: 0, False: 45.4k]
  ------------------
  106|      0|      q.flip_sign();
  107|      0|      if(r != 0) {
  ------------------
  |  Branch (107:10): [True: 0, False: 0]
  ------------------
  108|      0|         --q;
  109|      0|         r = y - r;
  110|      0|      }
  111|      0|   }
  112|       |
  113|  45.4k|   r_out = r;
  114|  45.4k|   q_out = q;
  115|  45.4k|}
_ZN5Botan14vartime_divideERKNS_6BigIntES2_RS0_S3_:
  155|  33.5k|void vartime_divide(const BigInt& x, const BigInt& y_arg, BigInt& q_out, BigInt& r_out) {
  156|  33.5k|   if(y_arg.is_zero()) {
  ------------------
  |  Branch (156:7): [True: 0, False: 33.5k]
  ------------------
  157|      0|      throw Invalid_Argument("vartime_divide: cannot divide by zero");
  158|      0|   }
  159|       |
  160|  33.5k|   const size_t y_words = y_arg.sig_words();
  161|       |
  162|  33.5k|   BOTAN_ASSERT_NOMSG(y_words > 0);
  ------------------
  |  |   60|  33.5k|   do {                                                                     \
  |  |   61|  33.5k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 33.5k]
  |  |  ------------------
  |  |   62|  33.5k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  33.5k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  163|       |
  164|  33.5k|   BigInt y = y_arg;
  165|       |
  166|  33.5k|   BigInt r = x;
  167|  33.5k|   BigInt q = BigInt::zero();
  168|  33.5k|   secure_vector<word> ws;
  169|       |
  170|  33.5k|   r.set_sign(BigInt::Positive);
  171|  33.5k|   y.set_sign(BigInt::Positive);
  172|       |
  173|       |   // Calculate shifts needed to normalize y with high bit set
  174|  33.5k|   const size_t shifts = y.top_bits_free();
  175|       |
  176|  33.5k|   y <<= shifts;
  177|  33.5k|   r <<= shifts;
  178|       |
  179|       |   // we know y has not changed size, since we only shifted up to set high bit
  180|  33.5k|   const size_t t = y_words - 1;
  181|  33.5k|   const size_t n = std::max(y_words, r.sig_words()) - 1;  // r may have changed size however
  182|       |
  183|  33.5k|   BOTAN_ASSERT_NOMSG(n >= t);
  ------------------
  |  |   60|  33.5k|   do {                                                                     \
  |  |   61|  33.5k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 33.5k]
  |  |  ------------------
  |  |   62|  33.5k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  33.5k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  184|       |
  185|  33.5k|   q.grow_to(n - t + 1);
  186|       |
  187|  33.5k|   word* q_words = q.mutable_data();
  188|       |
  189|  33.5k|   BigInt shifted_y = y << (BOTAN_MP_WORD_BITS * (n - t));
  ------------------
  |  |   50|  33.5k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  190|       |
  191|       |   // Set q_{n-t} to number of times r > shifted_y
  192|  33.5k|   q_words[n - t] = r.reduce_below(shifted_y, ws);
  193|       |
  194|  33.5k|   const word y_t0 = y.word_at(t);
  195|  33.5k|   const word y_t1 = y.word_at(t - 1);
  196|  33.5k|   BOTAN_DEBUG_ASSERT((y_t0 >> (BOTAN_MP_WORD_BITS - 1)) == 1);
  ------------------
  |  |   99|  33.5k|      do {                          \
  |  |  100|  33.5k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  197|       |
  198|  80.8k|   for(size_t j = n; j != t; --j) {
  ------------------
  |  Branch (198:22): [True: 47.2k, False: 33.5k]
  ------------------
  199|  47.2k|      const word x_j0 = r.word_at(j);
  200|  47.2k|      const word x_j1 = r.word_at(j - 1);
  201|  47.2k|      const word x_j2 = r.word_at(j - 2);
  202|       |
  203|  47.2k|      word qjt = bigint_divop_vartime(x_j0, x_j1, y_t0);
  204|       |
  205|  47.2k|      qjt = CT::Mask<word>::is_equal(x_j0, y_t0).select(MP_WORD_MAX, qjt);
  206|       |
  207|       |      // Per HAC 14.23, this operation is required at most twice
  208|  47.2k|      qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);
  209|  47.2k|      qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);
  210|  47.2k|      BOTAN_DEBUG_ASSERT(division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2) == false);
  ------------------
  |  |   99|  47.2k|      do {                          \
  |  |  100|  47.2k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  211|       |
  212|  47.2k|      shifted_y >>= BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  47.2k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  213|       |      // Now shifted_y == y << (BOTAN_MP_WORD_BITS * (j-t-1))
  214|       |
  215|       |      // TODO this sequence could be better
  216|  47.2k|      r -= qjt * shifted_y;
  217|  47.2k|      qjt -= r.is_negative();
  218|  47.2k|      r += static_cast<word>(r.is_negative()) * shifted_y;
  219|       |
  220|  47.2k|      q_words[j - t - 1] = qjt;
  221|  47.2k|   }
  222|       |
  223|  33.5k|   r >>= shifts;
  224|       |
  225|  33.5k|   sign_fixup(x, y_arg, q, r);
  226|       |
  227|  33.5k|   r_out = r;
  228|  33.5k|   q_out = q;
  229|  33.5k|}
divide.cpp:_ZN5Botan12_GLOBAL__N_110sign_fixupERKNS_6BigIntES3_RS1_S4_:
   21|  37.3k|void sign_fixup(const BigInt& x, const BigInt& y, BigInt& q, BigInt& r) {
   22|  37.3k|   q.cond_flip_sign(x.sign() != y.sign());
   23|       |
   24|  37.3k|   if(x.is_negative() && r.is_nonzero()) {
  ------------------
  |  Branch (24:7): [True: 0, False: 37.3k]
  |  Branch (24:26): [True: 0, False: 0]
  ------------------
   25|      0|      q -= 1;
   26|      0|      r = y.abs() - r;
   27|      0|   }
   28|  37.3k|}
divide.cpp:_ZN5Botan12_GLOBAL__N_114division_checkEmmmmmm:
   30|  94.5k|inline bool division_check(word q, word y2, word y1, word x3, word x2, word x1) {
   31|       |   /*
   32|       |   Compute (y3,y2,y1) = (y2,y1) * q
   33|       |   and return true if (y3,y2,y1) > (x3,x2,x1)
   34|       |   */
   35|       |
   36|  94.5k|   word y3 = 0;
   37|  94.5k|   y1 = word_madd2(q, y1, &y3);
   38|  94.5k|   y2 = word_madd2(q, y2, &y3);
   39|       |
   40|  94.5k|   const word x[3] = {x1, x2, x3};
   41|  94.5k|   const word y[3] = {y1, y2, y3};
   42|       |
   43|  94.5k|   return bigint_ct_is_lt(x, 3, y, 3).as_bool();
   44|  94.5k|}

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

_ZN5Botan12basecase_mulEPmmPKmmS2_m:
   20|  56.9k|void basecase_mul(word z[], size_t z_size, const word x[], size_t x_size, const word y[], size_t y_size) {
   21|  56.9k|   if(z_size < x_size + y_size) {
  ------------------
  |  Branch (21:7): [True: 0, False: 56.9k]
  ------------------
   22|      0|      throw Invalid_Argument("basecase_mul z_size too small");
   23|      0|   }
   24|       |
   25|  56.9k|   const size_t x_size_8 = x_size - (x_size % 8);
   26|       |
   27|  56.9k|   clear_mem(z, z_size);
   28|       |
   29|   414k|   for(size_t i = 0; i != y_size; ++i) {
  ------------------
  |  Branch (29:22): [True: 358k, False: 56.9k]
  ------------------
   30|   358k|      const word y_i = y[i];
   31|       |
   32|   358k|      word carry = 0;
   33|       |
   34|   735k|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (34:25): [True: 377k, False: 358k]
  ------------------
   35|   377k|         carry = word8_madd3(z + i + j, x + j, y_i, carry);
   36|   377k|      }
   37|       |
   38|  1.62M|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (38:32): [True: 1.27M, False: 358k]
  ------------------
   39|  1.27M|         z[i + j] = word_madd3(x[j], y_i, z[i + j], &carry);
   40|  1.27M|      }
   41|       |
   42|   358k|      z[x_size + i] = carry;
   43|   358k|   }
   44|  56.9k|}
_ZN5Botan12basecase_sqrEPmmPKmm:
   46|   129k|void basecase_sqr(word z[], size_t z_size, const word x[], size_t x_size) {
   47|   129k|   if(z_size < 2 * x_size) {
  ------------------
  |  Branch (47:7): [True: 0, False: 129k]
  ------------------
   48|      0|      throw Invalid_Argument("basecase_sqr z_size too small");
   49|      0|   }
   50|       |
   51|   129k|   const size_t x_size_8 = x_size - (x_size % 8);
   52|       |
   53|   129k|   clear_mem(z, z_size);
   54|       |
   55|   890k|   for(size_t i = 0; i != x_size; ++i) {
  ------------------
  |  Branch (55:22): [True: 760k, False: 129k]
  ------------------
   56|   760k|      const word x_i = x[i];
   57|       |
   58|   760k|      word carry = 0;
   59|       |
   60|  1.45M|      for(size_t j = 0; j != x_size_8; j += 8) {
  ------------------
  |  Branch (60:25): [True: 695k, False: 760k]
  ------------------
   61|   695k|         carry = word8_madd3(z + i + j, x + j, x_i, carry);
   62|   695k|      }
   63|       |
   64|  4.01M|      for(size_t j = x_size_8; j != x_size; ++j) {
  ------------------
  |  Branch (64:32): [True: 3.25M, False: 760k]
  ------------------
   65|  3.25M|         z[i + j] = word_madd3(x[j], x_i, z[i + j], &carry);
   66|  3.25M|      }
   67|       |
   68|   760k|      z[x_size + i] = carry;
   69|   760k|   }
   70|   129k|}
_ZN5Botan10bigint_mulEPmmPKmmmS2_mmS0_m:
  291|  11.7M|                size_t ws_size) {
  292|  11.7M|   clear_mem(z, z_size);
  293|       |
  294|  11.7M|   if(x_sw == 1) {
  ------------------
  |  Branch (294:7): [True: 9.59k, False: 11.6M]
  ------------------
  295|  9.59k|      bigint_linmul3(z, y, y_sw, x[0]);
  296|  11.6M|   } else if(y_sw == 1) {
  ------------------
  |  Branch (296:14): [True: 113, False: 11.6M]
  ------------------
  297|    113|      bigint_linmul3(z, x, x_sw, y[0]);
  298|  11.6M|   } else if(sized_for_comba_mul<4>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (298:14): [True: 11.6M, False: 95.3k]
  ------------------
  299|  11.6M|      bigint_comba_mul4(z, x, y);
  300|  11.6M|   } else if(sized_for_comba_mul<6>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (300:14): [True: 3.12k, False: 92.2k]
  ------------------
  301|  3.12k|      bigint_comba_mul6(z, x, y);
  302|  92.2k|   } else if(sized_for_comba_mul<8>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (302:14): [True: 28.1k, False: 64.1k]
  ------------------
  303|  28.1k|      bigint_comba_mul8(z, x, y);
  304|  64.1k|   } else if(sized_for_comba_mul<9>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (304:14): [True: 1.68k, False: 62.4k]
  ------------------
  305|  1.68k|      bigint_comba_mul9(z, x, y);
  306|  62.4k|   } else if(sized_for_comba_mul<16>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (306:14): [True: 1.54k, False: 60.8k]
  ------------------
  307|  1.54k|      bigint_comba_mul16(z, x, y);
  308|  60.8k|   } else if(sized_for_comba_mul<24>(x_sw, x_size, y_sw, y_size, z_size)) {
  ------------------
  |  Branch (308:14): [True: 1.00k, False: 59.8k]
  ------------------
  309|  1.00k|      bigint_comba_mul24(z, x, y);
  310|  59.8k|   } else if(x_sw < KARATSUBA_MULTIPLY_THRESHOLD || y_sw < KARATSUBA_MULTIPLY_THRESHOLD || !workspace) {
  ------------------
  |  Branch (310:14): [True: 54.3k, False: 5.56k]
  |  Branch (310:53): [True: 147, False: 5.41k]
  |  Branch (310:92): [True: 0, False: 5.41k]
  ------------------
  311|  54.4k|      basecase_mul(z, z_size, x, x_sw, y, y_sw);
  312|  54.4k|   } else {
  313|  5.41k|      const size_t N = karatsuba_size(z_size, x_size, x_sw, y_size, y_sw);
  314|       |
  315|  5.41k|      if(N && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (315:10): [True: 4.40k, False: 1.01k]
  |  Branch (315:15): [True: 4.40k, False: 0]
  |  Branch (315:34): [True: 4.39k, False: 5]
  ------------------
  316|  4.39k|         karatsuba_mul(z, x, y, N, workspace);
  317|  4.39k|      } else {
  318|  1.02k|         basecase_mul(z, z_size, x, x_sw, y, y_sw);
  319|  1.02k|      }
  320|  5.41k|   }
  321|  11.7M|}
_ZN5Botan10bigint_sqrEPmmPKmmmS0_m:
  326|  4.55M|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|  4.55M|   clear_mem(z, z_size);
  328|       |
  329|  4.55M|   BOTAN_ASSERT(z_size / 2 >= x_sw, "Output size is sufficient");
  ------------------
  |  |   51|  4.55M|   do {                                                                                 \
  |  |   52|  4.55M|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 4.55M]
  |  |  ------------------
  |  |   53|  4.55M|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  4.55M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  330|       |
  331|  4.55M|   if(x_sw == 1) {
  ------------------
  |  Branch (331:7): [True: 34.6k, False: 4.52M]
  ------------------
  332|  34.6k|      bigint_linmul3(z, x, x_sw, x[0]);
  333|  4.52M|   } else if(sized_for_comba_sqr<4>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (333:14): [True: 4.35M, False: 167k]
  ------------------
  334|  4.35M|      bigint_comba_sqr4(z, x);
  335|  4.35M|   } else if(sized_for_comba_sqr<6>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (335:14): [True: 3.41k, False: 163k]
  ------------------
  336|  3.41k|      bigint_comba_sqr6(z, x);
  337|   163k|   } else if(sized_for_comba_sqr<8>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (337:14): [True: 12.2k, False: 151k]
  ------------------
  338|  12.2k|      bigint_comba_sqr8(z, x);
  339|   151k|   } else if(sized_for_comba_sqr<9>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (339:14): [True: 2.40k, False: 149k]
  ------------------
  340|  2.40k|      bigint_comba_sqr9(z, x);
  341|   149k|   } else if(sized_for_comba_sqr<16>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (341:14): [True: 3.94k, False: 145k]
  ------------------
  342|  3.94k|      bigint_comba_sqr16(z, x);
  343|   145k|   } else if(sized_for_comba_sqr<24>(x_sw, x_size, z_size)) {
  ------------------
  |  Branch (343:14): [True: 3.33k, False: 141k]
  ------------------
  344|  3.33k|      bigint_comba_sqr24(z, x);
  345|   141k|   } else if(x_size < KARATSUBA_SQUARE_THRESHOLD || !workspace) {
  ------------------
  |  Branch (345:14): [True: 120k, False: 21.1k]
  |  Branch (345:53): [True: 0, False: 21.1k]
  ------------------
  346|   120k|      basecase_sqr(z, z_size, x, x_sw);
  347|   120k|   } else {
  348|  21.1k|      const size_t N = karatsuba_size(z_size, x_size, x_sw);
  349|       |
  350|  21.1k|      if(N && z_size >= 2 * N && ws_size >= 2 * N) {
  ------------------
  |  Branch (350:10): [True: 15.9k, False: 5.17k]
  |  Branch (350:15): [True: 15.9k, False: 0]
  |  Branch (350:34): [True: 15.9k, False: 0]
  ------------------
  351|  15.9k|         karatsuba_sqr(z, x, N, workspace);
  352|  15.9k|      } else {
  353|  5.17k|         basecase_sqr(z, z_size, x, x_sw);
  354|  5.17k|      }
  355|  21.1k|   }
  356|  4.55M|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmmmm:
  202|  5.41k|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|  5.41k|   if(x_sw > x_size || x_sw > y_size || y_sw > x_size || y_sw > y_size) {
  ------------------
  |  Branch (203:7): [True: 0, False: 5.41k]
  |  Branch (203:24): [True: 0, False: 5.41k]
  |  Branch (203:41): [True: 23, False: 5.39k]
  |  Branch (203:58): [True: 0, False: 5.39k]
  ------------------
  204|     23|      return 0;
  205|     23|   }
  206|       |
  207|  5.39k|   if(((x_size == x_sw) && (x_size % 2)) || ((y_size == y_sw) && (y_size % 2))) {
  ------------------
  |  Branch (207:8): [True: 32, False: 5.36k]
  |  Branch (207:28): [True: 0, False: 32]
  |  Branch (207:46): [True: 58, False: 5.33k]
  |  Branch (207:66): [True: 0, False: 58]
  ------------------
  208|      0|      return 0;
  209|      0|   }
  210|       |
  211|  5.39k|   const size_t start = (x_sw > y_sw) ? x_sw : y_sw;
  ------------------
  |  Branch (211:25): [True: 13, False: 5.38k]
  ------------------
  212|  5.39k|   const size_t end = (x_size < y_size) ? x_size : y_size;
  ------------------
  |  Branch (212:23): [True: 211, False: 5.18k]
  ------------------
  213|       |
  214|  5.39k|   if(start == end) {
  ------------------
  |  Branch (214:7): [True: 90, False: 5.30k]
  ------------------
  215|     90|      if(start % 2) {
  ------------------
  |  Branch (215:10): [True: 0, False: 90]
  ------------------
  216|      0|         return 0;
  217|      0|      }
  218|     90|      return start;
  219|     90|   }
  220|       |
  221|  6.28k|   for(size_t j = start; j <= end; ++j) {
  ------------------
  |  Branch (221:26): [True: 6.28k, False: 0]
  ------------------
  222|  6.28k|      if(j % 2) {
  ------------------
  |  Branch (222:10): [True: 984, False: 5.30k]
  ------------------
  223|    984|         continue;
  224|    984|      }
  225|       |
  226|  5.30k|      if(2 * j > z_size) {
  ------------------
  |  Branch (226:10): [True: 992, False: 4.31k]
  ------------------
  227|    992|         return 0;
  228|    992|      }
  229|       |
  230|  4.31k|      if(x_sw <= j && j <= x_size && y_sw <= j && j <= y_size) {
  ------------------
  |  Branch (230:10): [True: 4.31k, False: 0]
  |  Branch (230:23): [True: 4.31k, False: 0]
  |  Branch (230:38): [True: 4.31k, False: 0]
  |  Branch (230:51): [True: 4.31k, False: 0]
  ------------------
  231|  4.31k|         if(j % 4 == 2 && (j + 2) <= x_size && (j + 2) <= y_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (231:13): [True: 385, False: 3.92k]
  |  Branch (231:27): [True: 385, False: 0]
  |  Branch (231:48): [True: 385, False: 0]
  |  Branch (231:69): [True: 64, False: 321]
  ------------------
  232|     64|            return j + 2;
  233|     64|         }
  234|  4.24k|         return j;
  235|  4.31k|      }
  236|  4.31k|   }
  237|       |
  238|      0|   return 0;
  239|  5.30k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_mulEPmPKmS3_mS1_:
   80|  17.5k|void karatsuba_mul(word z[], const word x[], const word y[], size_t N, word workspace[]) {
   81|  17.5k|   if(N < KARATSUBA_MULTIPLY_THRESHOLD || N % 2) {
  ------------------
  |  Branch (81:7): [True: 13.1k, False: 4.39k]
  |  Branch (81:43): [True: 0, False: 4.39k]
  ------------------
   82|  13.1k|      switch(N) {
   83|      0|         case 6:
  ------------------
  |  Branch (83:10): [True: 0, False: 13.1k]
  ------------------
   84|      0|            return bigint_comba_mul6(z, x, y);
   85|      0|         case 8:
  ------------------
  |  Branch (85:10): [True: 0, False: 13.1k]
  ------------------
   86|      0|            return bigint_comba_mul8(z, x, y);
   87|      0|         case 9:
  ------------------
  |  Branch (87:10): [True: 0, False: 13.1k]
  ------------------
   88|      0|            return bigint_comba_mul9(z, x, y);
   89|  11.0k|         case 16:
  ------------------
  |  Branch (89:10): [True: 11.0k, False: 2.16k]
  ------------------
   90|  11.0k|            return bigint_comba_mul16(z, x, y);
   91|    735|         case 24:
  ------------------
  |  Branch (91:10): [True: 735, False: 12.4k]
  ------------------
   92|    735|            return bigint_comba_mul24(z, x, y);
   93|  1.42k|         default:
  ------------------
  |  Branch (93:10): [True: 1.42k, False: 11.7k]
  ------------------
   94|  1.42k|            return basecase_mul(z, 2 * N, x, N, y, N);
   95|  13.1k|      }
   96|  13.1k|   }
   97|       |
   98|  4.39k|   const size_t N2 = N / 2;
   99|       |
  100|  4.39k|   const word* x0 = x;
  101|  4.39k|   const word* x1 = x + N2;
  102|  4.39k|   const word* y0 = y;
  103|  4.39k|   const word* y1 = y + N2;
  104|  4.39k|   word* z0 = z;
  105|  4.39k|   word* z1 = z + N;
  106|       |
  107|  4.39k|   word* ws0 = workspace;
  108|  4.39k|   word* ws1 = workspace + N;
  109|       |
  110|  4.39k|   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.39k|   const auto cmp0 = bigint_sub_abs(z0, x0, x1, N2, workspace);
  123|  4.39k|   const auto cmp1 = bigint_sub_abs(z1, y1, y0, N2, workspace);
  124|  4.39k|   const auto neg_mask = ~(cmp0 ^ cmp1);
  125|       |
  126|  4.39k|   karatsuba_mul(ws0, z0, z1, N2, ws1);
  127|       |
  128|       |   // Compute X_lo * Y_lo
  129|  4.39k|   karatsuba_mul(z0, x0, y0, N2, ws1);
  130|       |
  131|       |   // Compute X_hi * Y_hi
  132|  4.39k|   karatsuba_mul(z1, x1, y1, N2, ws1);
  133|       |
  134|  4.39k|   const word ws_carry = bigint_add3_nc(ws1, z0, N, z1, N);
  135|  4.39k|   word z_carry = bigint_add2_nc(z + N2, N, ws1, N);
  136|       |
  137|  4.39k|   z_carry += bigint_add2_nc(z + N + N2, N2, &ws_carry, 1);
  138|  4.39k|   bigint_add2_nc(z + N + N2, N2, &z_carry, 1);
  139|       |
  140|  4.39k|   clear_mem(workspace + N, N2);
  141|       |
  142|  4.39k|   bigint_cnd_add_or_sub(neg_mask, z + N2, workspace, 2 * N - N2);
  143|  4.39k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_114karatsuba_sizeEmmm:
  244|  21.1k|size_t karatsuba_size(size_t z_size, size_t x_size, size_t x_sw) {
  245|  21.1k|   if(x_sw == x_size) {
  ------------------
  |  Branch (245:7): [True: 0, False: 21.1k]
  ------------------
  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|  26.3k|   for(size_t j = x_sw; j <= x_size; ++j) {
  ------------------
  |  Branch (252:25): [True: 26.3k, False: 0]
  ------------------
  253|  26.3k|      if(j % 2) {
  ------------------
  |  Branch (253:10): [True: 5.17k, False: 21.1k]
  ------------------
  254|  5.17k|         continue;
  255|  5.17k|      }
  256|       |
  257|  21.1k|      if(2 * j > z_size) {
  ------------------
  |  Branch (257:10): [True: 5.17k, False: 15.9k]
  ------------------
  258|  5.17k|         return 0;
  259|  5.17k|      }
  260|       |
  261|  15.9k|      if(j % 4 == 2 && (j + 2) <= x_size && 2 * (j + 2) <= z_size) {
  ------------------
  |  Branch (261:10): [True: 1.45k, False: 14.5k]
  |  Branch (261:24): [True: 1.45k, False: 0]
  |  Branch (261:45): [True: 0, False: 1.45k]
  ------------------
  262|      0|         return j + 2;
  263|      0|      }
  264|  15.9k|      return j;
  265|  15.9k|   }
  266|       |
  267|      0|   return 0;
  268|  21.1k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_113karatsuba_sqrEPmPKmmS1_:
  148|  57.8k|void karatsuba_sqr(word z[], const word x[], size_t N, word workspace[]) {
  149|  57.8k|   if(N < KARATSUBA_SQUARE_THRESHOLD || N % 2) {
  ------------------
  |  Branch (149:7): [True: 43.8k, False: 13.9k]
  |  Branch (149:41): [True: 0, False: 13.9k]
  ------------------
  150|  43.8k|      switch(N) {
  151|      0|         case 6:
  ------------------
  |  Branch (151:10): [True: 0, False: 43.8k]
  ------------------
  152|      0|            return bigint_comba_sqr6(z, x);
  153|      0|         case 8:
  ------------------
  |  Branch (153:10): [True: 0, False: 43.8k]
  ------------------
  154|      0|            return bigint_comba_sqr8(z, x);
  155|      0|         case 9:
  ------------------
  |  Branch (155:10): [True: 0, False: 43.8k]
  ------------------
  156|      0|            return bigint_comba_sqr9(z, x);
  157|  38.8k|         case 16:
  ------------------
  |  Branch (157:10): [True: 38.8k, False: 5.02k]
  ------------------
  158|  38.8k|            return bigint_comba_sqr16(z, x);
  159|  1.15k|         case 24:
  ------------------
  |  Branch (159:10): [True: 1.15k, False: 42.7k]
  ------------------
  160|  1.15k|            return bigint_comba_sqr24(z, x);
  161|  3.87k|         default:
  ------------------
  |  Branch (161:10): [True: 3.87k, False: 39.9k]
  ------------------
  162|  3.87k|            return basecase_sqr(z, 2 * N, x, N);
  163|  43.8k|      }
  164|  43.8k|   }
  165|       |
  166|  13.9k|   const size_t N2 = N / 2;
  167|       |
  168|  13.9k|   const word* x0 = x;
  169|  13.9k|   const word* x1 = x + N2;
  170|  13.9k|   word* z0 = z;
  171|  13.9k|   word* z1 = z + N;
  172|       |
  173|  13.9k|   word* ws0 = workspace;
  174|  13.9k|   word* ws1 = workspace + N;
  175|       |
  176|  13.9k|   clear_mem(workspace, 2 * N);
  177|       |
  178|       |   // See comment in karatsuba_mul
  179|  13.9k|   bigint_sub_abs(z0, x0, x1, N2, workspace);
  180|  13.9k|   karatsuba_sqr(ws0, z0, N2, ws1);
  181|       |
  182|  13.9k|   karatsuba_sqr(z0, x0, N2, ws1);
  183|  13.9k|   karatsuba_sqr(z1, x1, N2, ws1);
  184|       |
  185|  13.9k|   const word ws_carry = bigint_add3_nc(ws1, z0, N, z1, N);
  186|  13.9k|   word z_carry = bigint_add2_nc(z + N2, N, ws1, N);
  187|       |
  188|  13.9k|   z_carry += bigint_add2_nc(z + N + N2, N2, &ws_carry, 1);
  189|  13.9k|   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|  13.9k|   bigint_sub2(z + N2, 2 * N - N2, ws0, N);
  197|  13.9k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm4EEEbmmmmm:
  271|  11.6M|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|  11.6M|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 11.6M, False: 69.7k]
  |  Branch (272:26): [True: 11.6M, False: 7.37k]
  |  Branch (272:42): [True: 11.6M, False: 4.65k]
  |  Branch (272:56): [True: 11.6M, False: 967]
  |  Branch (272:72): [True: 11.6M, False: 12.6k]
  ------------------
  273|  11.6M|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm6EEEbmmmmm:
  271|  95.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|  95.3k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 54.0k, False: 41.3k]
  |  Branch (272:26): [True: 46.6k, False: 7.41k]
  |  Branch (272:42): [True: 45.2k, False: 1.34k]
  |  Branch (272:56): [True: 44.3k, False: 967]
  |  Branch (272:72): [True: 3.12k, False: 41.1k]
  ------------------
  273|  95.3k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm8EEEbmmmmm:
  271|  92.2k|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|  92.2k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 80.4k, False: 11.7k]
  |  Branch (272:26): [True: 70.7k, False: 9.74k]
  |  Branch (272:42): [True: 68.9k, False: 1.75k]
  |  Branch (272:56): [True: 65.5k, False: 3.39k]
  |  Branch (272:72): [True: 28.1k, False: 37.4k]
  ------------------
  273|  92.2k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm9EEEbmmmmm:
  271|  64.1k|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|  64.1k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 53.9k, False: 10.1k]
  |  Branch (272:26): [True: 35.2k, False: 18.6k]
  |  Branch (272:42): [True: 34.3k, False: 894]
  |  Branch (272:56): [True: 32.2k, False: 2.15k]
  |  Branch (272:72): [True: 1.68k, False: 30.5k]
  ------------------
  273|  64.1k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm16EEEbmmmmm:
  271|  62.4k|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|  62.4k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 53.9k, False: 8.42k]
  |  Branch (272:26): [True: 32.8k, False: 21.1k]
  |  Branch (272:42): [True: 32.4k, False: 410]
  |  Branch (272:56): [True: 32.1k, False: 268]
  |  Branch (272:72): [True: 1.54k, False: 30.6k]
  ------------------
  273|  62.4k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_mulILm24EEEbmmmmm:
  271|  60.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|  60.8k|   return (x_sw <= SZ && x_size >= SZ && y_sw <= SZ && y_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (272:12): [True: 54.2k, False: 6.58k]
  |  Branch (272:26): [True: 5.44k, False: 48.8k]
  |  Branch (272:42): [True: 5.14k, False: 299]
  |  Branch (272:56): [True: 2.94k, False: 2.20k]
  |  Branch (272:72): [True: 1.00k, False: 1.93k]
  ------------------
  273|  60.8k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm4EEEbmmm:
  276|  4.52M|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|  4.52M|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 4.39M, False: 132k]
  |  Branch (277:26): [True: 4.38M, False: 1.68k]
  |  Branch (277:42): [True: 4.35M, False: 32.8k]
  ------------------
  278|  4.52M|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm6EEEbmmm:
  276|   167k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   167k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 122k, False: 44.6k]
  |  Branch (277:26): [True: 120k, False: 1.68k]
  |  Branch (277:42): [True: 3.41k, False: 117k]
  ------------------
  278|   167k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm8EEEbmmm:
  276|   163k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   163k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 132k, False: 30.8k]
  |  Branch (277:26): [True: 128k, False: 4.21k]
  |  Branch (277:42): [True: 12.2k, False: 116k]
  ------------------
  278|   163k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm9EEEbmmm:
  276|   151k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   151k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 123k, False: 28.4k]
  |  Branch (277:26): [True: 106k, False: 16.4k]
  |  Branch (277:42): [True: 2.40k, False: 104k]
  ------------------
  278|   151k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm16EEEbmmm:
  276|   149k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   149k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 125k, False: 23.8k]
  |  Branch (277:26): [True: 106k, False: 19.2k]
  |  Branch (277:42): [True: 3.94k, False: 102k]
  ------------------
  278|   149k|}
mp_karat.cpp:_ZN5Botan12_GLOBAL__N_119sized_for_comba_sqrILm24EEEbmmm:
  276|   145k|inline bool sized_for_comba_sqr(size_t x_sw, size_t x_size, size_t z_size) {
  277|   145k|   return (x_sw <= SZ && x_size >= SZ && z_size >= 2 * SZ);
  ------------------
  |  Branch (277:12): [True: 126k, False: 18.5k]
  |  Branch (277:26): [True: 7.55k, False: 119k]
  |  Branch (277:42): [True: 3.33k, False: 4.21k]
  ------------------
  278|   145k|}

_ZN5Botan25bigint_monty_redc_genericEPmmPKmmmS0_:
   31|   194k|void bigint_monty_redc_generic(word z[], size_t z_size, const word p[], size_t p_size, word p_dash, word ws[]) {
   32|   194k|   BOTAN_ARG_CHECK(z_size >= 2 * p_size && p_size > 0, "Invalid sizes for bigint_monty_redc_generic");
  ------------------
  |  |   30|   194k|   do {                                                          \
  |  |   31|   388k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:12): [True: 194k, False: 0]
  |  |  |  Branch (31:12): [True: 194k, False: 0]
  |  |  ------------------
  |  |   32|   194k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|   194k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   33|       |
   34|   194k|   word w2 = 0, w1 = 0, w0 = 0;
   35|       |
   36|   194k|   w0 = z[0];
   37|       |
   38|   194k|   ws[0] = w0 * p_dash;
   39|       |
   40|   194k|   word3_muladd(&w2, &w1, &w0, ws[0], p[0]);
   41|       |
   42|   194k|   w0 = w1;
   43|   194k|   w1 = w2;
   44|   194k|   w2 = 0;
   45|       |
   46|  1.01M|   for(size_t i = 1; i != p_size; ++i) {
  ------------------
  |  Branch (46:22): [True: 823k, False: 194k]
  ------------------
   47|  6.95M|      for(size_t j = 0; j < i; ++j) {
  ------------------
  |  Branch (47:25): [True: 6.13M, False: 823k]
  ------------------
   48|  6.13M|         word3_muladd(&w2, &w1, &w0, ws[j], p[i - j]);
   49|  6.13M|      }
   50|       |
   51|   823k|      word3_add(&w2, &w1, &w0, z[i]);
   52|       |
   53|   823k|      ws[i] = w0 * p_dash;
   54|       |
   55|   823k|      word3_muladd(&w2, &w1, &w0, ws[i], p[0]);
   56|       |
   57|   823k|      w0 = w1;
   58|   823k|      w1 = w2;
   59|   823k|      w2 = 0;
   60|   823k|   }
   61|       |
   62|  1.01M|   for(size_t i = 0; i != p_size - 1; ++i) {
  ------------------
  |  Branch (62:22): [True: 823k, False: 194k]
  ------------------
   63|  6.95M|      for(size_t j = i + 1; j != p_size; ++j) {
  ------------------
  |  Branch (63:29): [True: 6.13M, False: 823k]
  ------------------
   64|  6.13M|         word3_muladd(&w2, &w1, &w0, ws[j], p[p_size + i - j]);
   65|  6.13M|      }
   66|       |
   67|   823k|      word3_add(&w2, &w1, &w0, z[p_size + i]);
   68|       |
   69|   823k|      ws[i] = w0;
   70|       |
   71|   823k|      w0 = w1;
   72|   823k|      w1 = w2;
   73|   823k|      w2 = 0;
   74|   823k|   }
   75|       |
   76|   194k|   word3_add(&w2, &w1, &w0, z[2 * p_size - 1]);
   77|       |
   78|   194k|   ws[p_size - 1] = w0;
   79|   194k|   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|   194k|   word borrow = bigint_sub3(z, ws, p_size + 1, p, p_size);
   98|       |
   99|   194k|   BOTAN_DEBUG_ASSERT(borrow == 0 || borrow == 1);
  ------------------
  |  |   99|   194k|      do {                          \
  |  |  100|   194k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  100|       |
  101|   194k|   CT::conditional_assign_mem(borrow, z, ws, p_size);
  102|   194k|   clear_mem(z + p_size, z_size - p_size);
  103|   194k|}

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

_ZN5Botan11inverse_modERKNS_6BigIntES2_:
  178|  1.74k|BigInt inverse_mod(const BigInt& n, const BigInt& mod) {
  179|  1.74k|   if(mod.is_zero()) {
  ------------------
  |  Branch (179:7): [True: 0, False: 1.74k]
  ------------------
  180|      0|      throw Invalid_Argument("inverse_mod modulus cannot be zero");
  181|      0|   }
  182|  1.74k|   if(mod.is_negative() || n.is_negative()) {
  ------------------
  |  Branch (182:7): [True: 0, False: 1.74k]
  |  Branch (182:28): [True: 0, False: 1.74k]
  ------------------
  183|      0|      throw Invalid_Argument("inverse_mod: arguments must be non-negative");
  184|      0|   }
  185|  1.74k|   if(n.is_zero() || (n.is_even() && mod.is_even())) {
  ------------------
  |  Branch (185:7): [True: 0, False: 1.74k]
  |  Branch (185:23): [True: 492, False: 1.24k]
  |  Branch (185:38): [True: 0, False: 492]
  ------------------
  186|      0|      return BigInt::zero();
  187|      0|   }
  188|       |
  189|  1.74k|   if(mod.is_odd()) {
  ------------------
  |  Branch (189:7): [True: 1.74k, False: 0]
  ------------------
  190|       |      /*
  191|       |      Fastpath for common case. This leaks if n is greater than mod or
  192|       |      not, but we don't guarantee const time behavior in that case.
  193|       |      */
  194|  1.74k|      if(n < mod) {
  ------------------
  |  Branch (194:10): [True: 1.74k, False: 0]
  ------------------
  195|  1.74k|         return inverse_mod_odd_modulus(n, mod);
  196|  1.74k|      } else {
  197|      0|         return inverse_mod_odd_modulus(ct_modulo(n, mod), mod);
  198|      0|      }
  199|  1.74k|   }
  200|       |
  201|       |   // If n is even and mod is even we already returned 0
  202|       |   // If n is even and mod is odd we jumped directly to odd-modulus algo
  203|      0|   BOTAN_DEBUG_ASSERT(n.is_odd());
  ------------------
  |  |   99|      0|      do {                          \
  |  |  100|      0|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  204|       |
  205|      0|   const size_t mod_lz = low_zero_bits(mod);
  206|      0|   BOTAN_ASSERT_NOMSG(mod_lz > 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]
  |  |  ------------------
  ------------------
  207|      0|   const size_t mod_bits = mod.bits();
  208|      0|   BOTAN_ASSERT_NOMSG(mod_bits > mod_lz);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  209|       |
  210|      0|   if(mod_lz == mod_bits - 1) {
  ------------------
  |  Branch (210:7): [True: 0, False: 0]
  ------------------
  211|       |      // In this case we are performing an inversion modulo 2^k
  212|      0|      return inverse_mod_pow2(n, mod_lz);
  213|      0|   }
  214|       |
  215|      0|   if(mod_lz == 1) {
  ------------------
  |  Branch (215:7): [True: 0, False: 0]
  ------------------
  216|       |      /*
  217|       |      Inversion modulo 2*o is an easier special case of CRT
  218|       |
  219|       |      This is exactly the main CRT flow below but taking advantage of
  220|       |      the fact that any odd number ^-1 modulo 2 is 1. As a result both
  221|       |      inv_2k and c can be taken to be 1, m2k is 2, and h is always
  222|       |      either 0 or 1, and its value depends only on the low bit of inv_o.
  223|       |
  224|       |      This is worth special casing because we generate RSA primes such
  225|       |      that phi(n) is of this form. However this only works for keys
  226|       |      that we generated in this way; pre-existing keys will typically
  227|       |      fall back to the general algorithm below.
  228|       |      */
  229|       |
  230|      0|      const BigInt o = mod >> 1;
  231|      0|      const BigInt n_redc = ct_modulo(n, o);
  232|      0|      const BigInt inv_o = inverse_mod_odd_modulus(n_redc, o);
  233|       |
  234|       |      // No modular inverse in this case:
  235|      0|      if(inv_o == 0) {
  ------------------
  |  Branch (235:10): [True: 0, False: 0]
  ------------------
  236|      0|         return BigInt::zero();
  237|      0|      }
  238|       |
  239|      0|      BigInt h = inv_o;
  240|      0|      h.ct_cond_add(!inv_o.get_bit(0), o);
  241|      0|      return h;
  242|      0|   }
  243|       |
  244|       |   /*
  245|       |   * In this case we are performing an inversion modulo 2^k*o for
  246|       |   * some k >= 2 and some odd (not necessarily prime) integer.
  247|       |   * Compute the inversions modulo 2^k and modulo o, then combine them
  248|       |   * using CRT, which is possible because 2^k and o are relatively prime.
  249|       |   */
  250|       |
  251|      0|   const BigInt o = mod >> mod_lz;
  252|      0|   const BigInt n_redc = ct_modulo(n, o);
  253|      0|   const BigInt inv_o = inverse_mod_odd_modulus(n_redc, o);
  254|      0|   const BigInt inv_2k = inverse_mod_pow2(n, mod_lz);
  255|       |
  256|       |   // No modular inverse in this case:
  257|      0|   if(inv_o == 0 || inv_2k == 0) {
  ------------------
  |  Branch (257:7): [True: 0, False: 0]
  |  Branch (257:21): [True: 0, False: 0]
  ------------------
  258|      0|      return BigInt::zero();
  259|      0|   }
  260|       |
  261|      0|   const BigInt m2k = BigInt::power_of_2(mod_lz);
  262|       |   // Compute the CRT parameter
  263|      0|   const BigInt c = inverse_mod_pow2(o, mod_lz);
  264|       |
  265|       |   // Compute h = c*(inv_2k-inv_o) mod 2^k
  266|      0|   BigInt h = c * (inv_2k - inv_o);
  267|      0|   const bool h_neg = h.is_negative();
  268|      0|   h.set_sign(BigInt::Positive);
  269|      0|   h.mask_bits(mod_lz);
  270|      0|   const bool h_nonzero = h.is_nonzero();
  271|      0|   h.ct_cond_assign(h_nonzero && h_neg, m2k - h);
  ------------------
  |  Branch (271:21): [True: 0, False: 0]
  |  Branch (271:34): [True: 0, False: 0]
  ------------------
  272|       |
  273|       |   // Return result inv_o + h * o
  274|      0|   h *= o;
  275|      0|   h += inv_o;
  276|      0|   return h;
  277|      0|}
mod_inv.cpp:_ZN5Botan12_GLOBAL__N_123inverse_mod_odd_modulusERKNS_6BigIntES3_:
   18|  1.74k|BigInt inverse_mod_odd_modulus(const BigInt& n, const BigInt& mod) {
   19|       |   // Caller should assure these preconditions:
   20|  1.74k|   BOTAN_DEBUG_ASSERT(n.is_positive());
  ------------------
  |  |   99|  1.74k|      do {                          \
  |  |  100|  1.74k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   21|  1.74k|   BOTAN_DEBUG_ASSERT(mod.is_positive());
  ------------------
  |  |   99|  1.74k|      do {                          \
  |  |  100|  1.74k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   22|  1.74k|   BOTAN_DEBUG_ASSERT(n < mod);
  ------------------
  |  |   99|  1.74k|      do {                          \
  |  |  100|  1.74k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   23|  1.74k|   BOTAN_DEBUG_ASSERT(mod >= 3 && mod.is_odd());
  ------------------
  |  |   99|  1.74k|      do {                          \
  |  |  100|  1.74k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
   24|       |
   25|       |   /*
   26|       |   This uses a modular inversion algorithm designed by Niels Möller
   27|       |   and implemented in Nettle. The same algorithm was later also
   28|       |   adapted to GMP in mpn_sec_invert.
   29|       |
   30|       |   It can be easily implemented in a way that does not depend on
   31|       |   secret branches or memory lookups, providing resistance against
   32|       |   some forms of side channel attack.
   33|       |
   34|       |   There is also a description of the algorithm in Appendix 5 of "Fast
   35|       |   Software Polynomial Multiplication on ARM Processors using the NEON Engine"
   36|       |   by Danilo Câmara, Conrado P. L. Gouvêa, Julio López, and Ricardo
   37|       |   Dahab in LNCS 8182
   38|       |      https://conradoplg.cryptoland.net/files/2010/12/mocrysen13.pdf
   39|       |
   40|       |   Thanks to Niels for creating the algorithm, explaining some things
   41|       |   about it, and the reference to the paper.
   42|       |   */
   43|       |
   44|  1.74k|   const size_t mod_words = mod.sig_words();
   45|  1.74k|   BOTAN_ASSERT(mod_words > 0, "Not empty");
  ------------------
  |  |   51|  1.74k|   do {                                                                                 \
  |  |   52|  1.74k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |   53|  1.74k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  1.74k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   46|       |
   47|  1.74k|   secure_vector<word> tmp_mem(5 * mod_words);
   48|       |
   49|  1.74k|   word* v_w = &tmp_mem[0];
   50|  1.74k|   word* u_w = &tmp_mem[1 * mod_words];
   51|  1.74k|   word* b_w = &tmp_mem[2 * mod_words];
   52|  1.74k|   word* a_w = &tmp_mem[3 * mod_words];
   53|  1.74k|   word* mp1o2 = &tmp_mem[4 * mod_words];
   54|       |
   55|  1.74k|   CT::poison(tmp_mem.data(), tmp_mem.size());
   56|       |
   57|  1.74k|   copy_mem(a_w, n.data(), std::min(n.size(), mod_words));
   58|  1.74k|   copy_mem(b_w, mod.data(), std::min(mod.size(), mod_words));
   59|  1.74k|   u_w[0] = 1;
   60|       |   // v_w = 0
   61|       |
   62|       |   // compute (mod + 1) / 2 which [because mod is odd] is equal to
   63|       |   // (mod / 2) + 1
   64|  1.74k|   copy_mem(mp1o2, mod.data(), std::min(mod.size(), mod_words));
   65|  1.74k|   bigint_shr1(mp1o2, mod_words, 0, 1);
   66|  1.74k|   word carry = bigint_add2_nc(mp1o2, mod_words, u_w, 1);
   67|  1.74k|   BOTAN_ASSERT_NOMSG(carry == 0);
  ------------------
  |  |   60|  1.74k|   do {                                                                     \
  |  |   61|  1.74k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |   62|  1.74k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.74k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   68|       |
   69|       |   // Only n.bits() + mod.bits() iterations are required, but avoid leaking the size of n
   70|  1.74k|   const size_t execs = 2 * mod.bits();
   71|       |
   72|   886k|   for(size_t i = 0; i != execs; ++i) {
  ------------------
  |  Branch (72:22): [True: 884k, False: 1.74k]
  ------------------
   73|   884k|      const word odd_a = a_w[0] & 1;
   74|       |
   75|       |      //if(odd_a) a -= b
   76|   884k|      word underflow = bigint_cnd_sub(odd_a, a_w, b_w, mod_words);
   77|       |
   78|       |      //if(underflow) { b -= a; a = abs(a); swap(u, v); }
   79|   884k|      bigint_cnd_add(underflow, b_w, a_w, mod_words);
   80|   884k|      bigint_cnd_abs(underflow, a_w, mod_words);
   81|   884k|      bigint_cnd_swap(underflow, u_w, v_w, mod_words);
   82|       |
   83|       |      // a >>= 1
   84|   884k|      bigint_shr1(a_w, mod_words, 0, 1);
   85|       |
   86|       |      //if(odd_a) u -= v;
   87|   884k|      word borrow = bigint_cnd_sub(odd_a, u_w, v_w, mod_words);
   88|       |
   89|       |      // if(borrow) u += p
   90|   884k|      bigint_cnd_add(borrow, u_w, mod.data(), mod_words);
   91|       |
   92|   884k|      const word odd_u = u_w[0] & 1;
   93|       |
   94|       |      // u >>= 1
   95|   884k|      bigint_shr1(u_w, mod_words, 0, 1);
   96|       |
   97|       |      //if(odd_u) u += mp1o2;
   98|   884k|      bigint_cnd_add(odd_u, u_w, mp1o2, mod_words);
   99|   884k|   }
  100|       |
  101|  1.74k|   auto a_is_0 = CT::Mask<word>::set();
  102|  8.65k|   for(size_t i = 0; i != mod_words; ++i) {
  ------------------
  |  Branch (102:22): [True: 6.91k, False: 1.74k]
  ------------------
  103|  6.91k|      a_is_0 &= CT::Mask<word>::is_zero(a_w[i]);
  104|  6.91k|   }
  105|       |
  106|  1.74k|   auto b_is_1 = CT::Mask<word>::is_equal(b_w[0], 1);
  107|  6.91k|   for(size_t i = 1; i != mod_words; ++i) {
  ------------------
  |  Branch (107:22): [True: 5.17k, False: 1.74k]
  ------------------
  108|  5.17k|      b_is_1 &= CT::Mask<word>::is_zero(b_w[i]);
  109|  5.17k|   }
  110|       |
  111|  1.74k|   BOTAN_ASSERT(a_is_0.as_bool(), "A is zero");
  ------------------
  |  |   51|  1.74k|   do {                                                                                 \
  |  |   52|  1.74k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |   53|  1.74k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  1.74k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|       |
  113|       |   // if b != 1 then gcd(n,mod) > 1 and inverse does not exist
  114|       |   // in which case zero out the result to indicate this
  115|  1.74k|   (~b_is_1).if_set_zero_out(v_w, mod_words);
  116|       |
  117|       |   /*
  118|       |   * We've placed the result in the lowest words of the temp buffer.
  119|       |   * So just clear out the other values and then give that buffer to a
  120|       |   * BigInt.
  121|       |   */
  122|  1.74k|   clear_mem(&tmp_mem[mod_words], 4 * mod_words);
  123|       |
  124|  1.74k|   CT::unpoison(tmp_mem.data(), tmp_mem.size());
  125|       |
  126|  1.74k|   BigInt r;
  127|  1.74k|   r.swap_reg(tmp_mem);
  128|  1.74k|   return r;
  129|  1.74k|}

_ZN5Botan13monty_inverseEm:
   16|  2.91k|word monty_inverse(word a) {
   17|  2.91k|   if(a % 2 == 0) {
  ------------------
  |  Branch (17:7): [True: 0, False: 2.91k]
  ------------------
   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|  2.91k|   word b = 1;
   27|  2.91k|   word r = 0;
   28|       |
   29|   189k|   for(size_t i = 0; i != BOTAN_MP_WORD_BITS; ++i) {
  ------------------
  |  |   50|   189k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  |  Branch (29:22): [True: 186k, False: 2.91k]
  ------------------
   30|   186k|      const word bi = b % 2;
   31|   186k|      r >>= 1;
   32|   186k|      r += bi << (BOTAN_MP_WORD_BITS - 1);
  ------------------
  |  |   50|   186k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   33|       |
   34|   186k|      b -= a * bi;
   35|   186k|      b >>= 1;
   36|   186k|   }
   37|       |
   38|       |   // Now invert in addition space
   39|  2.91k|   r = (MP_WORD_MAX - r) + 1;
   40|       |
   41|  2.91k|   return r;
   42|  2.91k|}
_ZN5Botan17Montgomery_ParamsC2ERKNS_6BigIntERKNS_15Modular_ReducerE:
   44|    569|Montgomery_Params::Montgomery_Params(const BigInt& p, const Modular_Reducer& mod_p) {
   45|    569|   if(p.is_even() || p < 3) {
  ------------------
  |  Branch (45:7): [True: 4, False: 565]
  |  Branch (45:22): [True: 3, False: 562]
  ------------------
   46|      7|      throw Invalid_Argument("Montgomery_Params invalid modulus");
   47|      7|   }
   48|       |
   49|    562|   m_p = p;
   50|    562|   m_p_words = m_p.sig_words();
   51|    562|   m_p_dash = monty_inverse(m_p.word_at(0));
   52|       |
   53|    562|   const BigInt r = BigInt::power_of_2(m_p_words * BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|    562|#define BOTAN_MP_WORD_BITS 64
  ------------------
   54|       |
   55|    562|   m_r1 = mod_p.reduce(r);
   56|    562|   m_r2 = mod_p.square(m_r1);
   57|    562|   m_r3 = mod_p.multiply(m_r1, m_r2);
   58|    562|}
_ZN5Botan17Montgomery_ParamsC2ERKNS_6BigIntE:
   60|  1.53k|Montgomery_Params::Montgomery_Params(const BigInt& p) {
   61|  1.53k|   if(p.is_even() || p < 3) {
  ------------------
  |  Branch (61:7): [True: 0, False: 1.53k]
  |  Branch (61:22): [True: 0, False: 1.53k]
  ------------------
   62|      0|      throw Invalid_Argument("Montgomery_Params invalid modulus");
   63|      0|   }
   64|       |
   65|  1.53k|   m_p = p;
   66|  1.53k|   m_p_words = m_p.sig_words();
   67|  1.53k|   m_p_dash = monty_inverse(m_p.word_at(0));
   68|       |
   69|  1.53k|   const BigInt r = BigInt::power_of_2(m_p_words * BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|  1.53k|#define BOTAN_MP_WORD_BITS 64
  ------------------
   70|       |
   71|       |   // It might be faster to use ct_modulo here vs setting up Barrett reduction?
   72|  1.53k|   Modular_Reducer mod_p(p);
   73|       |
   74|  1.53k|   m_r1 = mod_p.reduce(r);
   75|  1.53k|   m_r2 = mod_p.square(m_r1);
   76|  1.53k|   m_r3 = mod_p.multiply(m_r1, m_r2);
   77|  1.53k|}
_ZNK5Botan17Montgomery_Params4redcERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
   84|  1.75k|BigInt Montgomery_Params::redc(const BigInt& x, secure_vector<word>& ws) const {
   85|  1.75k|   const size_t output_size = m_p_words + 1;
   86|       |
   87|  1.75k|   if(ws.size() < output_size) {
  ------------------
  |  Branch (87:7): [True: 1.75k, False: 0]
  ------------------
   88|  1.75k|      ws.resize(output_size);
   89|  1.75k|   }
   90|       |
   91|  1.75k|   BigInt z = x;
   92|  1.75k|   z.grow_to(2 * m_p_words);
   93|       |
   94|  1.75k|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
   95|       |
   96|  1.75k|   return z;
   97|  1.75k|}
_ZNK5Botan17Montgomery_Params3mulERKNS_6BigIntES3_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
   99|  9.61k|BigInt Montgomery_Params::mul(const BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  100|  9.61k|   const size_t output_size = 2 * m_p_words + 2;
  101|       |
  102|  9.61k|   if(ws.size() < output_size) {
  ------------------
  |  Branch (102:7): [True: 9.61k, False: 0]
  ------------------
  103|  9.61k|      ws.resize(output_size);
  104|  9.61k|   }
  105|       |
  106|  9.61k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|  9.61k|      do {                          \
  |  |  100|  9.61k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|  9.61k|   BOTAN_DEBUG_ASSERT(y.sig_words() <= m_p_words);
  ------------------
  |  |   99|  9.61k|      do {                          \
  |  |  100|  9.61k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  108|       |
  109|  9.61k|   BigInt z = BigInt::with_capacity(output_size);
  110|  9.61k|   bigint_mul(z.mutable_data(),
  111|  9.61k|              z.size(),
  112|  9.61k|              x.data(),
  113|  9.61k|              x.size(),
  114|  9.61k|              std::min(m_p_words, x.size()),
  115|  9.61k|              y.data(),
  116|  9.61k|              y.size(),
  117|  9.61k|              std::min(m_p_words, y.size()),
  118|  9.61k|              ws.data(),
  119|  9.61k|              ws.size());
  120|       |
  121|  9.61k|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
  122|       |
  123|  9.61k|   return z;
  124|  9.61k|}
_ZNK5Botan17Montgomery_Params6mul_byERNS_6BigIntERKS1_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  182|  79.7k|void Montgomery_Params::mul_by(BigInt& x, const BigInt& y, secure_vector<word>& ws) const {
  183|  79.7k|   const size_t output_size = 2 * m_p_words;
  184|       |
  185|  79.7k|   if(ws.size() < 2 * output_size) {
  ------------------
  |  Branch (185:7): [True: 0, False: 79.7k]
  ------------------
  186|      0|      ws.resize(2 * output_size);
  187|      0|   }
  188|       |
  189|  79.7k|   word* z_data = &ws[0];
  190|  79.7k|   word* ws_data = &ws[output_size];
  191|       |
  192|  79.7k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|  79.7k|      do {                          \
  |  |  100|  79.7k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  193|       |
  194|  79.7k|   bigint_mul(z_data,
  195|  79.7k|              output_size,
  196|  79.7k|              x.data(),
  197|  79.7k|              x.size(),
  198|  79.7k|              std::min(m_p_words, x.size()),
  199|  79.7k|              y.data(),
  200|  79.7k|              y.size(),
  201|  79.7k|              std::min(m_p_words, y.size()),
  202|  79.7k|              ws_data,
  203|  79.7k|              output_size);
  204|       |
  205|  79.7k|   bigint_monty_redc(z_data, m_p.data(), m_p_words, m_p_dash, ws_data, output_size);
  206|       |
  207|  79.7k|   if(x.size() < output_size) {
  ------------------
  |  Branch (207:7): [True: 0, False: 79.7k]
  ------------------
  208|      0|      x.grow_to(output_size);
  209|      0|   }
  210|  79.7k|   copy_mem(x.mutable_data(), z_data, output_size);
  211|  79.7k|}
_ZNK5Botan17Montgomery_Params11square_thisERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  231|   320k|void Montgomery_Params::square_this(BigInt& x, secure_vector<word>& ws) const {
  232|   320k|   const size_t output_size = 2 * m_p_words;
  233|       |
  234|   320k|   if(ws.size() < 2 * output_size) {
  ------------------
  |  Branch (234:7): [True: 1.71k, False: 318k]
  ------------------
  235|  1.71k|      ws.resize(2 * output_size);
  236|  1.71k|   }
  237|       |
  238|   320k|   word* z_data = &ws[0];
  239|   320k|   word* ws_data = &ws[output_size];
  240|       |
  241|   320k|   BOTAN_DEBUG_ASSERT(x.sig_words() <= m_p_words);
  ------------------
  |  |   99|   320k|      do {                          \
  |  |  100|   320k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  242|       |
  243|   320k|   bigint_sqr(z_data, output_size, x.data(), x.size(), std::min(m_p_words, x.size()), ws_data, output_size);
  244|       |
  245|   320k|   bigint_monty_redc(z_data, m_p.data(), m_p_words, m_p_dash, ws_data, output_size);
  246|       |
  247|   320k|   if(x.size() < output_size) {
  ------------------
  |  Branch (247:7): [True: 0, False: 320k]
  ------------------
  248|      0|      x.grow_to(output_size);
  249|      0|   }
  250|   320k|   copy_mem(x.mutable_data(), z_data, output_size);
  251|   320k|}
_ZN5Botan14Montgomery_IntC2ERKNSt3__110shared_ptrIKNS_17Montgomery_ParamsEEERKNS_6BigIntEb:
  256|  11.4k|      m_params(params) {
  257|  11.4k|   if(redc_needed == false) {
  ------------------
  |  Branch (257:7): [True: 9.61k, False: 1.81k]
  ------------------
  258|  9.61k|      m_v = v;
  259|  9.61k|   } else {
  260|  1.81k|      BOTAN_ASSERT_NOMSG(m_v < m_params->p());
  ------------------
  |  |   60|  1.81k|   do {                                                                     \
  |  |   61|  1.81k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 1.81k]
  |  |  ------------------
  |  |   62|  1.81k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  1.81k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  261|  1.81k|      secure_vector<word> ws;
  262|  1.81k|      m_v = m_params->mul(v, m_params->R2(), ws);
  263|  1.81k|   }
  264|  11.4k|}
_ZN5Botan14Montgomery_Int8fix_sizeEv:
  292|  11.3k|void Montgomery_Int::fix_size() {
  293|  11.3k|   const size_t p_words = m_params->p_words();
  294|       |
  295|  11.3k|   if(m_v.sig_words() > p_words) {
  ------------------
  |  Branch (295:7): [True: 6, False: 11.3k]
  ------------------
  296|      6|      throw Internal_Error("Montgomery_Int::fix_size v too large");
  297|      6|   }
  298|       |
  299|  11.3k|   m_v.grow_to(p_words);
  300|  11.3k|}
_ZNK5Botan14Montgomery_Int5valueEv:
  324|  1.75k|BigInt Montgomery_Int::value() const {
  325|  1.75k|   secure_vector<word> ws;
  326|  1.75k|   return m_params->redc(m_v, ws);
  327|  1.75k|}
_ZNK5Botan14Montgomery_IntmlERKS0_:
  363|  7.79k|Montgomery_Int Montgomery_Int::operator*(const Montgomery_Int& other) const {
  364|  7.79k|   secure_vector<word> ws;
  365|  7.79k|   return Montgomery_Int(m_params, m_params->mul(m_v, other.m_v, ws), false);
  366|  7.79k|}
_ZN5Botan14Montgomery_Int6mul_byERKS0_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  372|  79.7k|Montgomery_Int& Montgomery_Int::mul_by(const Montgomery_Int& other, secure_vector<word>& ws) {
  373|  79.7k|   m_params->mul_by(m_v, other.m_v, ws);
  374|  79.7k|   return (*this);
  375|  79.7k|}
_ZN5Botan14Montgomery_Int19square_this_n_timesERNSt3__16vectorImNS_16secure_allocatorImEEEEm:
  392|   229k|Montgomery_Int& Montgomery_Int::square_this_n_times(secure_vector<word>& ws, size_t n) {
  393|   549k|   for(size_t i = 0; i != n; ++i) {
  ------------------
  |  Branch (393:22): [True: 320k, False: 229k]
  ------------------
  394|   320k|      m_params->square_this(m_v, ws);
  395|   320k|   }
  396|   229k|   return (*this);
  397|   229k|}

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

_ZN5Botan10prime_p521Ev:
   15|    823|const BigInt& prime_p521() {
   16|    823|   static const BigInt p521(
   17|    823|      "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
   18|    823|      "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
   19|       |
   20|    823|   return p521;
   21|    823|}
_ZN5Botan10prime_p192Ev:
  122|  3.71k|const BigInt& prime_p192() {
  123|  3.71k|   static const BigInt p192("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF");
  124|  3.71k|   return p192;
  125|  3.71k|}
_ZN5Botan9redc_p192ERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  127|  55.6k|void redc_p192(BigInt& x, secure_vector<word>& ws) {
  128|  55.6k|   BOTAN_DEBUG_ASSERT(x.is_positive());
  ------------------
  |  |   99|  55.6k|      do {                          \
  |  |  100|  55.6k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|       |
  130|  55.6k|   BOTAN_UNUSED(ws);
  ------------------
  |  |  118|  55.6k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  131|       |
  132|  55.6k|   static const size_t p192_limbs = 192 / BOTAN_MP_WORD_BITS;
  ------------------
  |  |   50|  55.6k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  133|       |
  134|  55.6k|   x.grow_to(2 * p192_limbs);
  135|  55.6k|   word* xw = x.mutable_data();
  136|       |
  137|  55.6k|   const uint64_t X00 = get_uint32(xw, 0);
  138|  55.6k|   const uint64_t X01 = get_uint32(xw, 1);
  139|  55.6k|   const uint64_t X02 = get_uint32(xw, 2);
  140|  55.6k|   const uint64_t X03 = get_uint32(xw, 3);
  141|  55.6k|   const uint64_t X04 = get_uint32(xw, 4);
  142|  55.6k|   const uint64_t X05 = get_uint32(xw, 5);
  143|  55.6k|   const uint64_t X06 = get_uint32(xw, 6);
  144|  55.6k|   const uint64_t X07 = get_uint32(xw, 7);
  145|  55.6k|   const uint64_t X08 = get_uint32(xw, 8);
  146|  55.6k|   const uint64_t X09 = get_uint32(xw, 9);
  147|  55.6k|   const uint64_t X10 = get_uint32(xw, 10);
  148|  55.6k|   const uint64_t X11 = get_uint32(xw, 11);
  149|       |
  150|  55.6k|   const uint64_t S0 = X00 + X06 + X10;
  151|  55.6k|   const uint64_t S1 = X01 + X07 + X11;
  152|  55.6k|   const uint64_t S2 = X02 + X06 + X08 + X10;
  153|  55.6k|   const uint64_t S3 = X03 + X07 + X09 + X11;
  154|  55.6k|   const uint64_t S4 = X04 + X08 + X10;
  155|  55.6k|   const uint64_t S5 = X05 + X09 + X11;
  156|       |
  157|  55.6k|   uint64_t S = 0;
  158|  55.6k|   uint32_t R0 = 0, R1 = 0;
  159|       |
  160|  55.6k|   S += S0;
  161|  55.6k|   R0 = static_cast<uint32_t>(S);
  162|  55.6k|   S >>= 32;
  163|       |
  164|  55.6k|   S += S1;
  165|  55.6k|   R1 = static_cast<uint32_t>(S);
  166|  55.6k|   S >>= 32;
  167|       |
  168|  55.6k|   set_words(xw, 0, R0, R1);
  169|       |
  170|  55.6k|   S += S2;
  171|  55.6k|   R0 = static_cast<uint32_t>(S);
  172|  55.6k|   S >>= 32;
  173|       |
  174|  55.6k|   S += S3;
  175|  55.6k|   R1 = static_cast<uint32_t>(S);
  176|  55.6k|   S >>= 32;
  177|       |
  178|  55.6k|   set_words(xw, 2, R0, R1);
  179|       |
  180|  55.6k|   S += S4;
  181|  55.6k|   R0 = static_cast<uint32_t>(S);
  182|  55.6k|   S >>= 32;
  183|       |
  184|  55.6k|   S += S5;
  185|  55.6k|   R1 = static_cast<uint32_t>(S);
  186|  55.6k|   S >>= 32;
  187|       |
  188|  55.6k|   set_words(xw, 4, R0, R1);
  189|       |
  190|       |   // No underflow possible
  191|       |
  192|       |   /*
  193|       |   This is a table of (i*P-192) % 2**192 for i in 1...3
  194|       |   */
  195|  55.6k|   static const word p192_mults[3][p192_limbs] = {
  196|  55.6k|#if(BOTAN_MP_WORD_BITS == 64)
  197|  55.6k|      {0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFFFFFFFFFFFFFF},
  198|  55.6k|      {0xFFFFFFFFFFFFFFFE, 0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFF},
  199|  55.6k|      {0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFC, 0xFFFFFFFFFFFFFFFF},
  200|       |#else
  201|       |      {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
  202|       |      {0xFFFFFFFE, 0xFFFFFFFF, 0xFFFFFFFD, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
  203|       |      {0xFFFFFFFD, 0xFFFFFFFF, 0xFFFFFFFC, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
  204|       |#endif
  205|  55.6k|   };
  206|       |
  207|  55.6k|   CT::unpoison(S);
  208|  55.6k|   BOTAN_ASSERT(S <= 2, "Expected overflow");
  ------------------
  |  |   51|  55.6k|   do {                                                                                 \
  |  |   52|  55.6k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 55.6k]
  |  |  ------------------
  |  |   53|  55.6k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|  55.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  209|       |
  210|  55.6k|   BOTAN_ASSERT_NOMSG(x.size() >= p192_limbs + 1);
  ------------------
  |  |   60|  55.6k|   do {                                                                     \
  |  |   61|  55.6k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 55.6k]
  |  |  ------------------
  |  |   62|  55.6k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  55.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  211|  55.6k|   x.mask_bits(192);
  212|  55.6k|   word borrow = bigint_sub2(x.mutable_data(), p192_limbs + 1, p192_mults[S], p192_limbs);
  213|  55.6k|   BOTAN_DEBUG_ASSERT(borrow == 0 || borrow == 1);
  ------------------
  |  |   99|  55.6k|      do {                          \
  |  |  100|  55.6k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  214|  55.6k|   bigint_cnd_add(borrow, x.mutable_data(), p192_limbs + 1, p192_mults[0], p192_limbs);
  215|  55.6k|}
_ZN5Botan10prime_p224Ev:
  217|    824|const BigInt& prime_p224() {
  218|    824|   static const BigInt p224("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001");
  219|    824|   return p224;
  220|    824|}
_ZN5Botan10prime_p256Ev:
  319|  22.6k|const BigInt& prime_p256() {
  320|  22.6k|   static const BigInt p256("0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF");
  321|  22.6k|   return p256;
  322|  22.6k|}
_ZN5Botan9redc_p256ERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  324|   262k|void redc_p256(BigInt& x, secure_vector<word>& ws) {
  325|   262k|   BOTAN_DEBUG_ASSERT(x.is_positive());
  ------------------
  |  |   99|   262k|      do {                          \
  |  |  100|   262k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  326|       |
  327|   262k|   static const size_t p256_limbs = (BOTAN_MP_WORD_BITS == 32) ? 8 : 4;
  ------------------
  |  |   50|   262k|#define BOTAN_MP_WORD_BITS 64
  ------------------
  |  Branch (327:37): [Folded - Ignored]
  ------------------
  328|       |
  329|   262k|   BOTAN_UNUSED(ws);
  ------------------
  |  |  118|   262k|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  330|       |
  331|   262k|   x.grow_to(2 * p256_limbs);
  332|   262k|   word* xw = x.mutable_data();
  333|       |
  334|   262k|   const int64_t X00 = get_uint32(xw, 0);
  335|   262k|   const int64_t X01 = get_uint32(xw, 1);
  336|   262k|   const int64_t X02 = get_uint32(xw, 2);
  337|   262k|   const int64_t X03 = get_uint32(xw, 3);
  338|   262k|   const int64_t X04 = get_uint32(xw, 4);
  339|   262k|   const int64_t X05 = get_uint32(xw, 5);
  340|   262k|   const int64_t X06 = get_uint32(xw, 6);
  341|   262k|   const int64_t X07 = get_uint32(xw, 7);
  342|   262k|   const int64_t X08 = get_uint32(xw, 8);
  343|   262k|   const int64_t X09 = get_uint32(xw, 9);
  344|   262k|   const int64_t X10 = get_uint32(xw, 10);
  345|   262k|   const int64_t X11 = get_uint32(xw, 11);
  346|   262k|   const int64_t X12 = get_uint32(xw, 12);
  347|   262k|   const int64_t X13 = get_uint32(xw, 13);
  348|   262k|   const int64_t X14 = get_uint32(xw, 14);
  349|   262k|   const int64_t X15 = get_uint32(xw, 15);
  350|       |
  351|       |   // Adds 6 * P-256 to prevent underflow
  352|   262k|   const int64_t S0 = 0xFFFFFFFA + X00 + X08 + X09 - (X11 + X12 + X13) - X14;
  353|   262k|   const int64_t S1 = 0xFFFFFFFF + X01 + X09 + X10 - X12 - (X13 + X14 + X15);
  354|   262k|   const int64_t S2 = 0xFFFFFFFF + X02 + X10 + X11 - (X13 + X14 + X15);
  355|   262k|   const int64_t S3 = 0x00000005 + X03 + (X11 + X12) * 2 + X13 - X15 - X08 - X09;
  356|   262k|   const int64_t S4 = 0x00000000 + X04 + (X12 + X13) * 2 + X14 - X09 - X10;
  357|   262k|   const int64_t S5 = 0x00000000 + X05 + (X13 + X14) * 2 + X15 - X10 - X11;
  358|   262k|   const int64_t S6 = 0x00000006 + X06 + X13 + X14 * 3 + X15 * 2 - X08 - X09;
  359|   262k|   const int64_t S7 = 0xFFFFFFFA + X07 + X15 * 3 + X08 - X10 - (X11 + X12 + X13);
  360|       |
  361|   262k|   int64_t S = 0;
  362|       |
  363|   262k|   uint32_t R0 = 0, R1 = 0;
  364|       |
  365|   262k|   S += S0;
  366|   262k|   R0 = static_cast<uint32_t>(S);
  367|   262k|   S >>= 32;
  368|       |
  369|   262k|   S += S1;
  370|   262k|   R1 = static_cast<uint32_t>(S);
  371|   262k|   S >>= 32;
  372|       |
  373|   262k|   set_words(xw, 0, R0, R1);
  374|       |
  375|   262k|   S += S2;
  376|   262k|   R0 = static_cast<uint32_t>(S);
  377|   262k|   S >>= 32;
  378|       |
  379|   262k|   S += S3;
  380|   262k|   R1 = static_cast<uint32_t>(S);
  381|   262k|   S >>= 32;
  382|       |
  383|   262k|   set_words(xw, 2, R0, R1);
  384|       |
  385|   262k|   S += S4;
  386|   262k|   R0 = static_cast<uint32_t>(S);
  387|   262k|   S >>= 32;
  388|       |
  389|   262k|   S += S5;
  390|   262k|   R1 = static_cast<uint32_t>(S);
  391|   262k|   S >>= 32;
  392|       |
  393|   262k|   set_words(xw, 4, R0, R1);
  394|       |
  395|   262k|   S += S6;
  396|   262k|   R0 = static_cast<uint32_t>(S);
  397|   262k|   S >>= 32;
  398|       |
  399|   262k|   S += S7;
  400|   262k|   R1 = static_cast<uint32_t>(S);
  401|   262k|   S >>= 32;
  402|   262k|   set_words(xw, 6, R0, R1);
  403|       |
  404|   262k|   S += 5;  // the top digits of 6*P-256
  405|       |
  406|       |   /*
  407|       |   This is a table of (i*P-256) % 2**256 for i in 1...10
  408|       |   */
  409|   262k|   static const word p256_mults[11][p256_limbs] = {
  410|   262k|#if(BOTAN_MP_WORD_BITS == 64)
  411|   262k|      {0xFFFFFFFFFFFFFFFF, 0x00000000FFFFFFFF, 0x0000000000000000, 0xFFFFFFFF00000001},
  412|   262k|      {0xFFFFFFFFFFFFFFFE, 0x00000001FFFFFFFF, 0x0000000000000000, 0xFFFFFFFE00000002},
  413|   262k|      {0xFFFFFFFFFFFFFFFD, 0x00000002FFFFFFFF, 0x0000000000000000, 0xFFFFFFFD00000003},
  414|   262k|      {0xFFFFFFFFFFFFFFFC, 0x00000003FFFFFFFF, 0x0000000000000000, 0xFFFFFFFC00000004},
  415|   262k|      {0xFFFFFFFFFFFFFFFB, 0x00000004FFFFFFFF, 0x0000000000000000, 0xFFFFFFFB00000005},
  416|   262k|      {0xFFFFFFFFFFFFFFFA, 0x00000005FFFFFFFF, 0x0000000000000000, 0xFFFFFFFA00000006},
  417|   262k|      {0xFFFFFFFFFFFFFFF9, 0x00000006FFFFFFFF, 0x0000000000000000, 0xFFFFFFF900000007},
  418|   262k|      {0xFFFFFFFFFFFFFFF8, 0x00000007FFFFFFFF, 0x0000000000000000, 0xFFFFFFF800000008},
  419|   262k|      {0xFFFFFFFFFFFFFFF7, 0x00000008FFFFFFFF, 0x0000000000000000, 0xFFFFFFF700000009},
  420|   262k|      {0xFFFFFFFFFFFFFFF6, 0x00000009FFFFFFFF, 0x0000000000000000, 0xFFFFFFF60000000A},
  421|   262k|      {0xFFFFFFFFFFFFFFF5, 0x0000000AFFFFFFFF, 0x0000000000000000, 0xFFFFFFF50000000B},
  422|       |#else
  423|       |      {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0xFFFFFFFF},
  424|       |      {0xFFFFFFFE, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000001, 0x00000000, 0x00000000, 0x00000002, 0xFFFFFFFE},
  425|       |      {0xFFFFFFFD, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000002, 0x00000000, 0x00000000, 0x00000003, 0xFFFFFFFD},
  426|       |      {0xFFFFFFFC, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000003, 0x00000000, 0x00000000, 0x00000004, 0xFFFFFFFC},
  427|       |      {0xFFFFFFFB, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000004, 0x00000000, 0x00000000, 0x00000005, 0xFFFFFFFB},
  428|       |      {0xFFFFFFFA, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000005, 0x00000000, 0x00000000, 0x00000006, 0xFFFFFFFA},
  429|       |      {0xFFFFFFF9, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000006, 0x00000000, 0x00000000, 0x00000007, 0xFFFFFFF9},
  430|       |      {0xFFFFFFF8, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000007, 0x00000000, 0x00000000, 0x00000008, 0xFFFFFFF8},
  431|       |      {0xFFFFFFF7, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000008, 0x00000000, 0x00000000, 0x00000009, 0xFFFFFFF7},
  432|       |      {0xFFFFFFF6, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000009, 0x00000000, 0x00000000, 0x0000000A, 0xFFFFFFF6},
  433|       |      {0xFFFFFFF5, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000A, 0x00000000, 0x00000000, 0x0000000B, 0xFFFFFFF5},
  434|       |#endif
  435|   262k|   };
  436|       |
  437|   262k|   CT::unpoison(S);
  438|   262k|   BOTAN_ASSERT(S >= 0 && S <= 10, "Expected overflow");
  ------------------
  |  |   51|   262k|   do {                                                                                 \
  |  |   52|   524k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:12): [True: 262k, False: 0]
  |  |  |  Branch (52:12): [True: 262k, False: 0]
  |  |  ------------------
  |  |   53|   262k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|   262k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  439|       |
  440|   262k|   BOTAN_ASSERT_NOMSG(x.size() >= p256_limbs + 1);
  ------------------
  |  |   60|   262k|   do {                                                                     \
  |  |   61|   262k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 262k]
  |  |  ------------------
  |  |   62|   262k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|   262k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  441|   262k|   x.mask_bits(256);
  442|   262k|   word borrow = bigint_sub2(x.mutable_data(), p256_limbs + 1, p256_mults[S], p256_limbs);
  443|   262k|   BOTAN_DEBUG_ASSERT(borrow == 0 || borrow == 1);
  ------------------
  |  |   99|   262k|      do {                          \
  |  |  100|   262k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  444|   262k|   bigint_cnd_add(borrow, x.mutable_data(), p256_limbs + 1, p256_mults[0], p256_limbs);
  445|   262k|}
_ZN5Botan10prime_p384Ev:
  447|    823|const BigInt& prime_p384() {
  448|    823|   static const BigInt p384(
  449|    823|      "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF");
  450|    823|   return p384;
  451|    823|}
nistp_redc.cpp:_ZN5Botan12_GLOBAL__N_110get_uint32EPKmm:
  103|  4.86M|inline uint32_t get_uint32(const word xw[], size_t i) {
  104|       |#if(BOTAN_MP_WORD_BITS == 32)
  105|       |   return xw[i];
  106|       |#else
  107|  4.86M|   return static_cast<uint32_t>(xw[i / 2] >> ((i % 2) * 32));
  108|  4.86M|#endif
  109|  4.86M|}
nistp_redc.cpp:_ZN5Botan12_GLOBAL__N_19set_wordsEPmmjj:
  111|  1.21M|inline void set_words(word x[], size_t i, uint32_t R0, uint32_t R1) {
  112|       |#if(BOTAN_MP_WORD_BITS == 32)
  113|       |   x[i] = R0;
  114|       |   x[i + 1] = R1;
  115|       |#else
  116|  1.21M|   x[i / 2] = (static_cast<uint64_t>(R1) << 32) | R0;
  117|  1.21M|#endif
  118|  1.21M|}

_ZN5Botan17sqrt_modulo_primeERKNS_6BigIntES2_:
   26|    663|BigInt sqrt_modulo_prime(const BigInt& a, const BigInt& p) {
   27|    663|   BOTAN_ARG_CHECK(p > 1, "invalid prime");
  ------------------
  |  |   30|    663|   do {                                                          \
  |  |   31|    663|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   32|    663|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    663|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   28|    663|   BOTAN_ARG_CHECK(a < p, "value to solve for must be less than p");
  ------------------
  |  |   30|    663|   do {                                                          \
  |  |   31|    663|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   32|    663|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    663|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   29|    663|   BOTAN_ARG_CHECK(a >= 0, "value to solve for must not be negative");
  ------------------
  |  |   30|    663|   do {                                                          \
  |  |   31|    663|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   32|    663|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    663|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   30|       |
   31|       |   // some very easy cases
   32|    663|   if(p == 2 || a <= 1) {
  ------------------
  |  Branch (32:7): [True: 0, False: 663]
  |  Branch (32:17): [True: 0, False: 663]
  ------------------
   33|      0|      return a;
   34|      0|   }
   35|       |
   36|    663|   BOTAN_ARG_CHECK(p.is_odd(), "invalid prime");
  ------------------
  |  |   30|    663|   do {                                                          \
  |  |   31|    663|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 663]
  |  |  ------------------
  |  |   32|    663|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|    663|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   37|       |
   38|    663|   if(jacobi(a, p) != 1) {  // not a quadratic residue
  ------------------
  |  Branch (38:7): [True: 167, False: 496]
  ------------------
   39|    167|      return BigInt::from_s32(-1);
   40|    167|   }
   41|       |
   42|    496|   Modular_Reducer mod_p(p);
   43|    496|   auto monty_p = std::make_shared<Montgomery_Params>(p, mod_p);
   44|       |
   45|       |   // If p == 3 (mod 4) there is a simple solution
   46|    496|   if(p % 4 == 3) {
  ------------------
  |  Branch (46:7): [True: 496, False: 0]
  ------------------
   47|    496|      return monty_exp_vartime(monty_p, a, ((p + 1) >> 2));
   48|    496|   }
   49|       |
   50|       |   // Otherwise we have to use Shanks-Tonelli
   51|      0|   size_t s = low_zero_bits(p - 1);
   52|      0|   BigInt q = p >> s;
   53|       |
   54|      0|   q -= 1;
   55|      0|   q >>= 1;
   56|       |
   57|      0|   BigInt r = monty_exp_vartime(monty_p, a, q);
   58|      0|   BigInt n = mod_p.multiply(a, mod_p.square(r));
   59|      0|   r = mod_p.multiply(r, a);
   60|       |
   61|      0|   if(n == 1) {
  ------------------
  |  Branch (61:7): [True: 0, False: 0]
  ------------------
   62|      0|      return r;
   63|      0|   }
   64|       |
   65|       |   // find random quadratic nonresidue z
   66|      0|   word z = 2;
   67|      0|   for(;;) {
   68|      0|      if(jacobi(BigInt::from_word(z), p) == -1) {  // found one
  ------------------
  |  Branch (68:10): [True: 0, False: 0]
  ------------------
   69|      0|         break;
   70|      0|      }
   71|       |
   72|      0|      z += 1;  // try next z
   73|       |
   74|       |      /*
   75|       |      * The expected number of tests to find a non-residue modulo a
   76|       |      * prime is 2. If we have not found one after 256 then almost
   77|       |      * certainly we have been given a non-prime p.
   78|       |      */
   79|      0|      if(z >= 256) {
  ------------------
  |  Branch (79:10): [True: 0, False: 0]
  ------------------
   80|      0|         return BigInt::from_s32(-1);
   81|      0|      }
   82|      0|   }
   83|       |
   84|      0|   BigInt c = monty_exp_vartime(monty_p, BigInt::from_word(z), (q << 1) + 1);
   85|       |
   86|      0|   while(n > 1) {
  ------------------
  |  Branch (86:10): [True: 0, False: 0]
  ------------------
   87|      0|      q = n;
   88|       |
   89|      0|      size_t i = 0;
   90|      0|      while(q != 1) {
  ------------------
  |  Branch (90:13): [True: 0, False: 0]
  ------------------
   91|      0|         q = mod_p.square(q);
   92|      0|         ++i;
   93|       |
   94|      0|         if(i >= s) {
  ------------------
  |  Branch (94:13): [True: 0, False: 0]
  ------------------
   95|      0|            return BigInt::from_s32(-1);
   96|      0|         }
   97|      0|      }
   98|       |
   99|      0|      BOTAN_ASSERT_NOMSG(s >= (i + 1));  // No underflow!
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  100|      0|      c = monty_exp_vartime(monty_p, c, BigInt::power_of_2(s - i - 1));
  101|      0|      r = mod_p.multiply(r, c);
  102|      0|      c = mod_p.square(c);
  103|      0|      n = mod_p.multiply(n, c);
  104|       |
  105|       |      // s decreases as the algorithm proceeds
  106|      0|      BOTAN_ASSERT_NOMSG(s >= i);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  107|      0|      s = i;
  108|      0|   }
  109|       |
  110|      0|   return r;
  111|      0|}
_ZN5Botan6jacobiERKNS_6BigIntES2_:
  116|    663|int32_t jacobi(const BigInt& a, const BigInt& n) {
  117|    663|   if(n.is_even() || n < 2) {
  ------------------
  |  Branch (117:7): [True: 0, False: 663]
  |  Branch (117:22): [True: 0, False: 663]
  ------------------
  118|      0|      throw Invalid_Argument("jacobi: second argument must be odd and > 1");
  119|      0|   }
  120|       |
  121|    663|   BigInt x = a % n;
  122|    663|   BigInt y = n;
  123|    663|   int32_t J = 1;
  124|       |
  125|  46.1k|   while(y > 1) {
  ------------------
  |  Branch (125:10): [True: 45.4k, False: 663]
  ------------------
  126|  45.4k|      x %= y;
  127|  45.4k|      if(x > y / 2) {
  ------------------
  |  Branch (127:10): [True: 20.6k, False: 24.8k]
  ------------------
  128|  20.6k|         x = y - x;
  129|  20.6k|         if(y % 4 == 3) {
  ------------------
  |  Branch (129:13): [True: 10.6k, False: 10.0k]
  ------------------
  130|  10.6k|            J = -J;
  131|  10.6k|         }
  132|  20.6k|      }
  133|  45.4k|      if(x.is_zero()) {
  ------------------
  |  Branch (133:10): [True: 0, False: 45.4k]
  ------------------
  134|      0|         return 0;
  135|      0|      }
  136|       |
  137|  45.4k|      size_t shifts = low_zero_bits(x);
  138|  45.4k|      x >>= shifts;
  139|  45.4k|      if(shifts % 2) {
  ------------------
  |  Branch (139:10): [True: 14.5k, False: 30.8k]
  ------------------
  140|  14.5k|         word y_mod_8 = y % 8;
  141|  14.5k|         if(y_mod_8 == 3 || y_mod_8 == 5) {
  ------------------
  |  Branch (141:13): [True: 3.57k, False: 11.0k]
  |  Branch (141:29): [True: 3.63k, False: 7.38k]
  ------------------
  142|  7.20k|            J = -J;
  143|  7.20k|         }
  144|  14.5k|      }
  145|       |
  146|  45.4k|      if(x % 4 == 3 && y % 4 == 3) {
  ------------------
  |  Branch (146:10): [True: 22.7k, False: 22.7k]
  |  Branch (146:24): [True: 11.6k, False: 11.0k]
  ------------------
  147|  11.6k|         J = -J;
  148|  11.6k|      }
  149|  45.4k|      std::swap(x, y);
  150|  45.4k|   }
  151|    663|   return J;
  152|    663|}
_ZN5Botan6squareERKNS_6BigIntE:
  157|  2.91k|BigInt square(const BigInt& x) {
  158|  2.91k|   BigInt z = x;
  159|  2.91k|   secure_vector<word> ws;
  160|  2.91k|   z.square(ws);
  161|  2.91k|   return z;
  162|  2.91k|}
_ZN5Botan13low_zero_bitsERKNS_6BigIntE:
  167|  45.4k|size_t low_zero_bits(const BigInt& n) {
  168|  45.4k|   size_t low_zero = 0;
  169|       |
  170|  45.4k|   auto seen_nonempty_word = CT::Mask<word>::cleared();
  171|       |
  172|   430k|   for(size_t i = 0; i != n.size(); ++i) {
  ------------------
  |  Branch (172:22): [True: 384k, False: 45.4k]
  ------------------
  173|   384k|      const word x = n.word_at(i);
  174|       |
  175|       |      // ctz(0) will return sizeof(word)
  176|   384k|      const size_t tz_x = ctz(x);
  177|       |
  178|       |      // if x > 0 we want to count tz_x in total but not any
  179|       |      // further words, so set the mask after the addition
  180|   384k|      low_zero += seen_nonempty_word.if_not_set_return(tz_x);
  181|       |
  182|   384k|      seen_nonempty_word |= CT::Mask<word>::expand(x);
  183|   384k|   }
  184|       |
  185|       |   // if we saw no words with x > 0 then n == 0 and the value we have
  186|       |   // computed is meaningless. Instead return BigInt::zero() in that case.
  187|  45.4k|   return static_cast<size_t>(seen_nonempty_word.if_set_return(low_zero));
  188|  45.4k|}

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

_ZN5Botan4EMSA6createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   35|  1.48k|std::unique_ptr<EMSA> EMSA::create(std::string_view algo_spec) {
   36|  1.48k|   SCAN_Name req(algo_spec);
   37|       |
   38|  1.48k|#if defined(BOTAN_HAS_EMSA_PKCS1)
   39|  1.48k|   if(req.algo_name() == "EMSA_PKCS1" || req.algo_name() == "PKCS1v15" || req.algo_name() == "EMSA-PKCS1-v1_5" ||
  ------------------
  |  Branch (39:7): [True: 0, False: 1.48k]
  |  Branch (39:42): [True: 0, False: 1.48k]
  |  Branch (39:75): [True: 0, False: 1.48k]
  ------------------
   40|  1.48k|      req.algo_name() == "EMSA3") {
  ------------------
  |  Branch (40:7): [True: 1.23k, False: 250]
  ------------------
   41|  1.23k|      if(req.arg_count() == 2 && req.arg(0) == "Raw") {
  ------------------
  |  Branch (41:10): [True: 0, False: 1.23k]
  |  Branch (41:10): [True: 0, False: 1.23k]
  |  Branch (41:34): [True: 0, False: 0]
  ------------------
   42|      0|         return std::make_unique<EMSA_PKCS1v15_Raw>(req.arg(1));
   43|  1.23k|      } else if(req.arg_count() == 1) {
  ------------------
  |  Branch (43:17): [True: 1.23k, False: 0]
  ------------------
   44|  1.23k|         if(req.arg(0) == "Raw") {
  ------------------
  |  Branch (44:13): [True: 0, False: 1.23k]
  ------------------
   45|      0|            return std::make_unique<EMSA_PKCS1v15_Raw>();
   46|  1.23k|         } else {
   47|  1.23k|            if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (47:21): [True: 1.23k, False: 0]
  ------------------
   48|  1.23k|               return std::make_unique<EMSA_PKCS1v15>(std::move(hash));
   49|  1.23k|            }
   50|  1.23k|         }
   51|  1.23k|      }
   52|  1.23k|   }
   53|    250|#endif
   54|       |
   55|    250|#if defined(BOTAN_HAS_EMSA_PSSR)
   56|    250|   if(req.algo_name() == "PSS_Raw" || req.algo_name() == "PSSR_Raw") {
  ------------------
  |  Branch (56:7): [True: 0, False: 250]
  |  Branch (56:39): [True: 0, False: 250]
  ------------------
   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|    250|   if(req.algo_name() == "PSS" || req.algo_name() == "PSSR" || req.algo_name() == "EMSA-PSS" ||
  ------------------
  |  Branch (69:7): [True: 0, False: 250]
  |  Branch (69:35): [True: 0, False: 250]
  |  Branch (69:64): [True: 0, False: 250]
  ------------------
   70|    250|      req.algo_name() == "PSS-MGF1" || req.algo_name() == "EMSA4") {
  ------------------
  |  Branch (70:7): [True: 0, False: 250]
  |  Branch (70:40): [True: 56, False: 194]
  ------------------
   71|     56|      if(req.arg_count_between(1, 3) && req.arg(1, "MGF1") == "MGF1") {
  ------------------
  |  Branch (71:10): [True: 56, False: 0]
  |  Branch (71:10): [True: 56, False: 0]
  |  Branch (71:41): [True: 56, False: 0]
  ------------------
   72|     56|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (72:18): [True: 56, False: 0]
  ------------------
   73|     56|            if(req.arg_count() == 3) {
  ------------------
  |  Branch (73:16): [True: 56, False: 0]
  ------------------
   74|     56|               const size_t salt_size = req.arg_as_integer(2, 0);
   75|     56|               return std::make_unique<PSSR>(std::move(hash), salt_size);
   76|     56|            } else {
   77|      0|               return std::make_unique<PSSR>(std::move(hash));
   78|      0|            }
   79|     56|         }
   80|     56|      }
   81|     56|   }
   82|    194|#endif
   83|       |
   84|    194|#if defined(BOTAN_HAS_ISO_9796)
   85|    194|   if(req.algo_name() == "ISO_9796_DS2") {
  ------------------
  |  Branch (85:7): [True: 0, False: 194]
  ------------------
   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|    194|   if(req.algo_name() == "ISO_9796_DS3") {
  ------------------
  |  Branch (95:7): [True: 0, False: 194]
  ------------------
   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|    194|#endif
  104|       |
  105|    194|#if defined(BOTAN_HAS_EMSA_X931)
  106|    194|   if(req.algo_name() == "EMSA_X931" || req.algo_name() == "EMSA2" || req.algo_name() == "X9.31") {
  ------------------
  |  Branch (106:7): [True: 0, False: 194]
  |  Branch (106:41): [True: 0, False: 194]
  |  Branch (106:71): [True: 0, False: 194]
  ------------------
  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|    194|#endif
  114|       |
  115|    194|#if defined(BOTAN_HAS_EMSA_RAW)
  116|    194|   if(req.algo_name() == "Raw") {
  ------------------
  |  Branch (116:7): [True: 0, False: 194]
  ------------------
  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|    194|#endif
  127|       |
  128|    194|   return nullptr;
  129|    194|}
_ZN5Botan4EMSA15create_or_throwENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  131|  1.48k|std::unique_ptr<EMSA> EMSA::create_or_throw(std::string_view algo_spec) {
  132|  1.48k|   auto emsa = EMSA::create(algo_spec);
  133|  1.48k|   if(emsa) {
  ------------------
  |  Branch (133:7): [True: 1.29k, False: 194]
  ------------------
  134|  1.29k|      return emsa;
  135|  1.29k|   }
  136|    194|   throw Algorithm_Not_Found(algo_spec);
  137|  1.48k|}

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

_ZN5Botan4PSSRC2ENSt3__110unique_ptrINS_12HashFunctionENS1_14default_deleteIS3_EEEEm:
  151|     56|      m_hash(std::move(hash)), m_salt_size(salt_size), m_required_salt_len(true) {}
_ZN5Botan4PSSR6updateEPKhm:
  156|     56|void PSSR::update(const uint8_t input[], size_t length) {
  157|     56|   m_hash->update(input, length);
  158|     56|}
_ZN5Botan4PSSR8raw_dataEv:
  163|     56|std::vector<uint8_t> PSSR::raw_data() {
  164|     56|   return m_hash->final_stdvec();
  165|     56|}
_ZN5Botan4PSSR6verifyERKNSt3__16vectorIhNS1_9allocatorIhEEEES7_m:
  177|     48|bool PSSR::verify(const std::vector<uint8_t>& coded, const std::vector<uint8_t>& raw, size_t key_bits) {
  178|     48|   size_t salt_size = 0;
  179|     48|   const bool ok = pss_verify(*m_hash, coded, raw, key_bits, &salt_size);
  180|       |
  181|     48|   if(m_required_salt_len && salt_size != m_salt_size) {
  ------------------
  |  Branch (181:7): [True: 48, False: 0]
  |  Branch (181:30): [True: 48, False: 0]
  ------------------
  182|     48|      return false;
  183|     48|   }
  184|       |
  185|      0|   return ok;
  186|     48|}
pssr.cpp:_ZN5Botan12_GLOBAL__N_110pss_verifyERNS_12HashFunctionERKNSt3__16vectorIhNS3_9allocatorIhEEEES9_mPm:
   70|     48|                size_t* out_salt_size) {
   71|     48|   const size_t HASH_SIZE = hash.output_length();
   72|     48|   const size_t key_bytes = ceil_tobytes(key_bits);
   73|       |
   74|     48|   if(key_bits < 8 * HASH_SIZE + 9) {
  ------------------
  |  Branch (74:7): [True: 0, False: 48]
  ------------------
   75|      0|      return false;
   76|      0|   }
   77|       |
   78|     48|   if(message_hash.size() != HASH_SIZE) {
  ------------------
  |  Branch (78:7): [True: 0, False: 48]
  ------------------
   79|      0|      return false;
   80|      0|   }
   81|       |
   82|     48|   if(pss_repr.size() > key_bytes || pss_repr.size() <= 1) {
  ------------------
  |  Branch (82:7): [True: 3, False: 45]
  |  Branch (82:38): [True: 1, False: 44]
  ------------------
   83|      4|      return false;
   84|      4|   }
   85|       |
   86|     44|   if(pss_repr[pss_repr.size() - 1] != 0xBC) {
  ------------------
  |  Branch (86:7): [True: 16, False: 28]
  ------------------
   87|     16|      return false;
   88|     16|   }
   89|       |
   90|     28|   std::vector<uint8_t> coded = pss_repr;
   91|     28|   if(coded.size() < key_bytes) {
  ------------------
  |  Branch (91:7): [True: 15, False: 13]
  ------------------
   92|     15|      std::vector<uint8_t> temp(key_bytes);
   93|     15|      BufferStuffer stuffer(temp);
   94|     15|      stuffer.append(0x00, stuffer.remaining_capacity() - coded.size());
   95|     15|      stuffer.append(coded);
   96|     15|      coded = temp;
   97|     15|   }
   98|       |
   99|     28|   const size_t TOP_BITS = 8 * ((key_bits + 7) / 8) - key_bits;
  100|     28|   if(TOP_BITS > 8 - high_bit(coded[0])) {
  ------------------
  |  Branch (100:7): [True: 3, False: 25]
  ------------------
  101|      3|      return false;
  102|      3|   }
  103|       |
  104|     25|   uint8_t* DB = coded.data();
  105|     25|   const size_t DB_size = coded.size() - HASH_SIZE - 1;
  106|       |
  107|     25|   const uint8_t* H = &coded[DB_size];
  108|     25|   const size_t H_size = HASH_SIZE;
  109|       |
  110|     25|   mgf1_mask(hash, H, H_size, DB, DB_size);
  111|     25|   DB[0] &= 0xFF >> TOP_BITS;
  112|       |
  113|     25|   size_t salt_offset = 0;
  114|     29|   for(size_t j = 0; j != DB_size; ++j) {
  ------------------
  |  Branch (114:22): [True: 29, False: 0]
  ------------------
  115|     29|      if(DB[j] == 0x01) {
  ------------------
  |  Branch (115:10): [True: 6, False: 23]
  ------------------
  116|      6|         salt_offset = j + 1;
  117|      6|         break;
  118|      6|      }
  119|     23|      if(DB[j]) {
  ------------------
  |  Branch (119:10): [True: 19, False: 4]
  ------------------
  120|     19|         return false;
  121|     19|      }
  122|     23|   }
  123|      6|   if(salt_offset == 0) {
  ------------------
  |  Branch (123:7): [True: 0, False: 6]
  ------------------
  124|      0|      return false;
  125|      0|   }
  126|       |
  127|      6|   const size_t salt_size = DB_size - salt_offset;
  128|       |
  129|      6|   std::array<uint8_t, 8> padding = {0};
  130|      6|   hash.update(padding);
  131|      6|   hash.update(message_hash);
  132|      6|   hash.update(&DB[salt_offset], salt_size);
  133|       |
  134|      6|   const std::vector<uint8_t> H2 = hash.final_stdvec();
  135|       |
  136|      6|   const bool ok = CT::is_equal(H, H2.data(), HASH_SIZE).as_bool();
  137|       |
  138|      6|   if(out_salt_size && ok) {
  ------------------
  |  Branch (138:7): [True: 6, False: 0]
  |  Branch (138:24): [True: 0, False: 6]
  ------------------
  139|      0|      *out_salt_size = salt_size;
  140|      0|   }
  141|       |
  142|      6|   return ok;
  143|      6|}

_ZN5Botan12pkcs_hash_idENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   78|  1.23k|std::vector<uint8_t> pkcs_hash_id(std::string_view name) {
   79|       |   // Special case for SSL/TLS RSA signatures
   80|  1.23k|   if(name == "Parallel(MD5,SHA-1)") {
  ------------------
  |  Branch (80:7): [True: 0, False: 1.23k]
  ------------------
   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.23k|   if(name == "MD5") {
  ------------------
  |  Branch (86:7): [True: 92, False: 1.14k]
  ------------------
   87|     92|      return std::vector<uint8_t>(MD5_PKCS_ID, MD5_PKCS_ID + sizeof(MD5_PKCS_ID));
   88|     92|   }
   89|       |
   90|  1.14k|   if(name == "RIPEMD-160") {
  ------------------
  |  Branch (90:7): [True: 0, False: 1.14k]
  ------------------
   91|      0|      return std::vector<uint8_t>(RIPEMD_160_PKCS_ID, RIPEMD_160_PKCS_ID + sizeof(RIPEMD_160_PKCS_ID));
   92|      0|   }
   93|       |
   94|  1.14k|   if(name == "SHA-1") {
  ------------------
  |  Branch (94:7): [True: 41, False: 1.10k]
  ------------------
   95|     41|      return std::vector<uint8_t>(SHA_1_PKCS_ID, SHA_1_PKCS_ID + sizeof(SHA_1_PKCS_ID));
   96|     41|   }
   97|       |
   98|  1.10k|   if(name == "SHA-224") {
  ------------------
  |  Branch (98:7): [True: 87, False: 1.01k]
  ------------------
   99|     87|      return std::vector<uint8_t>(SHA_224_PKCS_ID, SHA_224_PKCS_ID + sizeof(SHA_224_PKCS_ID));
  100|     87|   }
  101|       |
  102|  1.01k|   if(name == "SHA-256") {
  ------------------
  |  Branch (102:7): [True: 353, False: 663]
  ------------------
  103|    353|      return std::vector<uint8_t>(SHA_256_PKCS_ID, SHA_256_PKCS_ID + sizeof(SHA_256_PKCS_ID));
  104|    353|   }
  105|       |
  106|    663|   if(name == "SHA-384") {
  ------------------
  |  Branch (106:7): [True: 59, False: 604]
  ------------------
  107|     59|      return std::vector<uint8_t>(SHA_384_PKCS_ID, SHA_384_PKCS_ID + sizeof(SHA_384_PKCS_ID));
  108|     59|   }
  109|       |
  110|    604|   if(name == "SHA-512") {
  ------------------
  |  Branch (110:7): [True: 74, False: 530]
  ------------------
  111|     74|      return std::vector<uint8_t>(SHA_512_PKCS_ID, SHA_512_PKCS_ID + sizeof(SHA_512_PKCS_ID));
  112|     74|   }
  113|       |
  114|    530|   if(name == "SHA-512-256") {
  ------------------
  |  Branch (114:7): [True: 530, False: 0]
  ------------------
  115|    530|      return std::vector<uint8_t>(SHA_512_256_PKCS_ID, SHA_512_256_PKCS_ID + sizeof(SHA_512_256_PKCS_ID));
  116|    530|   }
  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|}

_ZN5Botan9mgf1_maskERNS_12HashFunctionEPKhmPhm:
   15|     25|void mgf1_mask(HashFunction& hash, const uint8_t in[], size_t in_len, uint8_t out[], size_t out_len) {
   16|     25|   uint32_t counter = 0;
   17|       |
   18|     25|   std::vector<uint8_t> buffer(hash.output_length());
   19|    300|   while(out_len) {
  ------------------
  |  Branch (19:10): [True: 275, False: 25]
  ------------------
   20|    275|      hash.update(in, in_len);
   21|    275|      hash.update_be(counter);
   22|    275|      hash.final(buffer.data());
   23|       |
   24|    275|      const size_t xored = std::min<size_t>(buffer.size(), out_len);
   25|    275|      xor_buf(out, buffer.data(), xored);
   26|    275|      out += xored;
   27|    275|      out_len -= xored;
   28|       |
   29|    275|      ++counter;
   30|    275|   }
   31|     25|}

_ZN5Botan12DH_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   16|      6|DH_PublicKey::DH_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
   17|      6|   m_public_key = std::make_shared<DL_PublicKey>(alg_id, key_bits, DL_Group_Format::ANSI_X9_42);
   18|      6|}

_ZN5Botan12DL_PublicKeyC2ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEENS_15DL_Group_FormatE:
   44|     92|      m_group(alg_id.parameters(), format), m_public_key(decode_single_bigint(key_bits)) {}
dl_scheme.cpp:_ZN5Botan12_GLOBAL__N_120decode_single_bigintENSt3__14spanIKhLm18446744073709551615EEE:
   17|     55|BigInt decode_single_bigint(std::span<const uint8_t> key_bits) {
   18|     55|   BigInt x;
   19|     55|   BER_Decoder(key_bits).decode(x);
   20|     55|   return x;
   21|     55|}

_ZN5Botan8DL_Group19BER_decode_DL_groupEPKhmNS_15DL_Group_FormatENS_15DL_Group_SourceE:
  119|     92|                                                             DL_Group_Source source) {
  120|     92|   BigInt p, q, g;
  121|       |
  122|     92|   BER_Decoder decoder(data, data_len);
  123|     92|   BER_Decoder ber = decoder.start_sequence();
  124|       |
  125|     92|   if(format == DL_Group_Format::ANSI_X9_57) {
  ------------------
  |  Branch (125:7): [True: 83, False: 9]
  ------------------
  126|     83|      ber.decode(p).decode(q).decode(g).verify_end();
  127|     83|   } else if(format == DL_Group_Format::ANSI_X9_42) {
  ------------------
  |  Branch (127:14): [True: 3, False: 6]
  ------------------
  128|      3|      ber.decode(p).decode(g).decode(q).discard_remaining();
  129|      6|   } else if(format == DL_Group_Format::PKCS_3) {
  ------------------
  |  Branch (129:14): [True: 0, False: 6]
  ------------------
  130|       |      // q is left as zero
  131|      0|      ber.decode(p).decode(g).discard_remaining();
  132|      6|   } else {
  133|      6|      throw Invalid_Argument("Unknown DL_Group encoding");
  134|      6|   }
  135|       |
  136|     86|   return std::make_shared<DL_Group_Data>(p, q, g, source);
  137|     92|}
_ZNK5Botan8DL_Group4dataEv:
  316|     42|const DL_Group_Data& DL_Group::data() const {
  317|     42|   if(m_data) {
  ------------------
  |  Branch (317:7): [True: 42, False: 0]
  ------------------
  318|     42|      return *m_data;
  319|     42|   }
  320|       |
  321|      0|   throw Invalid_State("DL_Group uninitialized");
  322|     42|}
_ZNK5Botan8DL_Group5has_qEv:
  448|     42|bool DL_Group::has_q() const {
  449|     42|   return data().q_is_set();
  450|     42|}
_ZN5Botan8DL_GroupC2EPKhmNS_15DL_Group_FormatE:
  582|     92|DL_Group::DL_Group(const uint8_t ber[], size_t ber_len, DL_Group_Format format) {
  583|     92|   m_data = BER_decode_DL_group(ber, ber_len, format, DL_Group_Source::ExternalSource);
  584|     92|}
_ZNK5Botan13DL_Group_Data8q_is_setEv:
   90|     42|      bool q_is_set() const { return m_q_bits > 0; }
_ZN5Botan13DL_Group_DataC2ERKNS_6BigIntES3_S3_NS_15DL_Group_SourceE:
   39|     80|            m_source(source) {}
_ZN5Botan13DL_Group_DataD2Ev:
   41|     55|      ~DL_Group_Data() = default;

_ZN5Botan13DSA_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   55|     86|DSA_PublicKey::DSA_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
   56|     86|   m_public_key = std::make_shared<DL_PublicKey>(alg_id, key_bits, DL_Group_Format::ANSI_X9_57);
   57|       |
   58|     86|   BOTAN_ARG_CHECK(m_public_key->group().has_q(), "Q parameter must be set for DSA");
  ------------------
  |  |   30|     86|   do {                                                          \
  |  |   31|     86|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 9, False: 77]
  |  |  ------------------
  |  |   32|     86|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|     86|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   59|     86|}
_ZNK5Botan13DSA_PublicKey27create_x509_verification_opERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  260|     33|   const AlgorithmIdentifier& signature_algorithm, std::string_view provider) const {
  261|     33|   if(provider == "base" || provider.empty()) {
  ------------------
  |  Branch (261:7): [True: 0, False: 33]
  |  Branch (261:29): [True: 33, False: 0]
  ------------------
  262|     33|      return std::make_unique<DSA_Verification_Operation>(this->m_public_key, signature_algorithm);
  263|     33|   }
  264|       |
  265|      0|   throw Provider_Not_Found(algo_name(), provider);
  266|     33|}
dsa.cpp:_ZN5Botan12_GLOBAL__N_126DSA_Verification_OperationC2ERKNSt3__110shared_ptrIKNS_12DL_PublicKeyEEERKNS_19AlgorithmIdentifierE:
  209|     33|            PK_Ops::Verification_with_Hash(alg_id, "DSA"), m_key(key) {}

_ZN5Botan8CurveGFp11choose_reprERKNS_6BigIntES3_S3_:
  564|    827|std::shared_ptr<CurveGFp_Repr> CurveGFp::choose_repr(const BigInt& p, const BigInt& a, const BigInt& b) {
  565|    827|   if(p == prime_p192()) {
  ------------------
  |  Branch (565:7): [True: 3, False: 824]
  ------------------
  566|      3|      return std::make_shared<CurveGFp_P192>(a, b);
  567|      3|   }
  568|    824|   if(p == prime_p224()) {
  ------------------
  |  Branch (568:7): [True: 0, False: 824]
  ------------------
  569|      0|      return std::make_shared<CurveGFp_P224>(a, b);
  570|      0|   }
  571|    824|   if(p == prime_p256()) {
  ------------------
  |  Branch (571:7): [True: 1, False: 823]
  ------------------
  572|      1|      return std::make_shared<CurveGFp_P256>(a, b);
  573|      1|   }
  574|    823|   if(p == prime_p384()) {
  ------------------
  |  Branch (574:7): [True: 0, False: 823]
  ------------------
  575|      0|      return std::make_shared<CurveGFp_P384>(a, b);
  576|      0|   }
  577|    823|   if(p == prime_p521()) {
  ------------------
  |  Branch (577:7): [True: 0, False: 823]
  ------------------
  578|      0|      return std::make_shared<CurveGFp_P521>(a, b);
  579|      0|   }
  580|       |
  581|    823|   return std::make_shared<CurveGFp_Montgomery>(p, a, b);
  582|    823|}
curve_gfp.cpp:_ZN5Botan12_GLOBAL__N_113CurveGFp_P192C2ERKNS_6BigIntES4_:
  263|      3|      CurveGFp_P192(const BigInt& a, const BigInt& b) : CurveGFp_NIST(192, a, b) {}
curve_gfp.cpp:_ZN5Botan12_GLOBAL__N_113CurveGFp_NISTC2EmRKNS_6BigIntES4_:
  157|      4|            m_1(1), m_a(a), m_b(b), m_p_words((p_bits + BOTAN_MP_WORD_BITS - 1) / BOTAN_MP_WORD_BITS) {
  158|       |         // All Solinas prime curves are assumed a == -3
  159|      4|      }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_P1925get_pEv:
  265|  2.88k|      const BigInt& get_p() const override { return prime_p192(); }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST5get_aEv:
  165|    172|      const BigInt& get_a() const override { return m_a; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST5get_bEv:
  167|    172|      const BigInt& get_b() const override { return m_b; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST11get_p_wordsEv:
  171|  9.36k|      size_t get_p_words() const override { return m_p_words; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST11get_ws_sizeEv:
  173|   341k|      size_t get_ws_size() const override { return 2 * m_p_words; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST6is_oneERKNS_6BigIntE:
  179|     53|      bool is_one(const BigInt& x) const override { return x == 1; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST9a_is_zeroEv:
  161|  14.8k|      bool a_is_zero() const override { return false; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST12a_is_minus_3Ev:
  163|  14.8k|      bool a_is_minus_3() const override { return true; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST9get_a_repEv:
  175|    437|      const BigInt& get_a_rep() const override { return m_a; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST9get_b_repEv:
  177|    865|      const BigInt& get_b_rep() const override { return m_b; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST9get_1_repEv:
  169|    419|      const BigInt& get_1_rep() const override { return m_1; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST14invert_elementERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  211|     50|BigInt CurveGFp_NIST::invert_element(const BigInt& x, secure_vector<word>& ws) const {
  212|     50|   BOTAN_UNUSED(ws);
  ------------------
  |  |  118|     50|#define BOTAN_UNUSED Botan::ignore_params
  ------------------
  213|     50|   return inverse_mod(x, get_p());
  214|     50|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST12to_curve_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  181|    318|      void to_curve_rep(BigInt& x, secure_vector<word>& ws) const override { redc_mod_p(x, ws); }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST14from_curve_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  183|  1.35k|      void from_curve_rep(BigInt& x, secure_vector<word>& ws) const override { redc_mod_p(x, ws); }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST15curve_mul_wordsERNS_6BigIntEPKmmRKS2_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  217|   180k|   BigInt& z, const word x_w[], size_t x_size, const BigInt& y, secure_vector<word>& ws) const {
  218|   180k|   BOTAN_DEBUG_ASSERT(y.sig_words() <= m_p_words);
  ------------------
  |  |   99|   180k|      do {                          \
  |  |  100|   180k|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  219|       |
  220|   180k|   if(ws.size() < get_ws_size()) {
  ------------------
  |  Branch (220:7): [True: 0, False: 180k]
  ------------------
  221|      0|      ws.resize(get_ws_size());
  222|      0|   }
  223|       |
  224|   180k|   const size_t output_size = 2 * m_p_words;
  225|   180k|   if(z.size() < output_size) {
  ------------------
  |  Branch (225:7): [True: 23.2k, False: 157k]
  ------------------
  226|  23.2k|      z.grow_to(output_size);
  227|  23.2k|   }
  228|       |
  229|   180k|   bigint_mul(z.mutable_data(),
  230|   180k|              z.size(),
  231|   180k|              x_w,
  232|   180k|              x_size,
  233|   180k|              std::min(m_p_words, x_size),
  234|   180k|              y.data(),
  235|   180k|              y.size(),
  236|   180k|              std::min(m_p_words, y.size()),
  237|   180k|              ws.data(),
  238|   180k|              ws.size());
  239|       |
  240|   180k|   this->redc_mod_p(z, ws);
  241|   180k|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST15curve_sqr_wordsERNS_6BigIntEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
  243|   135k|void CurveGFp_NIST::curve_sqr_words(BigInt& z, const word x[], size_t x_size, secure_vector<word>& ws) const {
  244|   135k|   if(ws.size() < get_ws_size()) {
  ------------------
  |  Branch (244:7): [True: 490, False: 135k]
  ------------------
  245|    490|      ws.resize(get_ws_size());
  246|    490|   }
  247|       |
  248|   135k|   const size_t output_size = 2 * m_p_words;
  249|   135k|   if(z.size() < output_size) {
  ------------------
  |  Branch (249:7): [True: 17.5k, False: 118k]
  ------------------
  250|  17.5k|      z.grow_to(output_size);
  251|  17.5k|   }
  252|       |
  253|   135k|   bigint_sqr(z.mutable_data(), output_size, x, x_size, std::min(m_p_words, x_size), ws.data(), ws.size());
  254|       |
  255|   135k|   this->redc_mod_p(z, ws);
  256|   135k|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_P19210redc_mod_pERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  268|  55.6k|      void redc_mod_p(BigInt& x, secure_vector<word>& ws) const override { redc_p192(x, ws); }
curve_gfp.cpp:_ZN5Botan12_GLOBAL__N_113CurveGFp_P256C2ERKNS_6BigIntES4_:
  289|      1|      CurveGFp_P256(const BigInt& a, const BigInt& b) : CurveGFp_NIST(256, a, b) {}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_P2565get_pEv:
  291|  21.8k|      const BigInt& get_p() const override { return prime_p256(); }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_P25614invert_elementERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  299|    148|BigInt CurveGFp_P256::invert_element(const BigInt& x, secure_vector<word>& ws) const {
  300|    148|   BigInt r, p2, p4, p8, p16, p32, tmp;
  301|       |
  302|    148|   curve_sqr(r, x, ws);
  303|       |
  304|    148|   curve_mul(p2, r, x, ws);
  305|    148|   curve_sqr(r, p2, ws);
  306|    148|   curve_sqr_tmp(r, tmp, ws);
  307|       |
  308|    148|   curve_mul(p4, r, p2, ws);
  309|       |
  310|    148|   curve_sqr(r, p4, ws);
  311|    592|   for(size_t i = 0; i != 3; ++i) {
  ------------------
  |  Branch (311:22): [True: 444, False: 148]
  ------------------
  312|    444|      curve_sqr_tmp(r, tmp, ws);
  313|    444|   }
  314|    148|   curve_mul(p8, r, p4, ws);
  315|       |
  316|    148|   curve_sqr(r, p8, ws);
  317|  1.18k|   for(size_t i = 0; i != 7; ++i) {
  ------------------
  |  Branch (317:22): [True: 1.03k, False: 148]
  ------------------
  318|  1.03k|      curve_sqr_tmp(r, tmp, ws);
  319|  1.03k|   }
  320|    148|   curve_mul(p16, r, p8, ws);
  321|       |
  322|    148|   curve_sqr(r, p16, ws);
  323|  2.36k|   for(size_t i = 0; i != 15; ++i) {
  ------------------
  |  Branch (323:22): [True: 2.22k, False: 148]
  ------------------
  324|  2.22k|      curve_sqr_tmp(r, tmp, ws);
  325|  2.22k|   }
  326|    148|   curve_mul(p32, r, p16, ws);
  327|       |
  328|    148|   curve_sqr(r, p32, ws);
  329|  4.73k|   for(size_t i = 0; i != 31; ++i) {
  ------------------
  |  Branch (329:22): [True: 4.58k, False: 148]
  ------------------
  330|  4.58k|      curve_sqr_tmp(r, tmp, ws);
  331|  4.58k|   }
  332|    148|   curve_mul_tmp(r, x, tmp, ws);
  333|       |
  334|  19.0k|   for(size_t i = 0; i != 32 * 4; ++i) {
  ------------------
  |  Branch (334:22): [True: 18.9k, False: 148]
  ------------------
  335|  18.9k|      curve_sqr_tmp(r, tmp, ws);
  336|  18.9k|   }
  337|    148|   curve_mul_tmp(r, p32, tmp, ws);
  338|       |
  339|  4.88k|   for(size_t i = 0; i != 32; ++i) {
  ------------------
  |  Branch (339:22): [True: 4.73k, False: 148]
  ------------------
  340|  4.73k|      curve_sqr_tmp(r, tmp, ws);
  341|  4.73k|   }
  342|    148|   curve_mul_tmp(r, p32, tmp, ws);
  343|       |
  344|  2.51k|   for(size_t i = 0; i != 16; ++i) {
  ------------------
  |  Branch (344:22): [True: 2.36k, False: 148]
  ------------------
  345|  2.36k|      curve_sqr_tmp(r, tmp, ws);
  346|  2.36k|   }
  347|    148|   curve_mul_tmp(r, p16, tmp, ws);
  348|  1.33k|   for(size_t i = 0; i != 8; ++i) {
  ------------------
  |  Branch (348:22): [True: 1.18k, False: 148]
  ------------------
  349|  1.18k|      curve_sqr_tmp(r, tmp, ws);
  350|  1.18k|   }
  351|    148|   curve_mul_tmp(r, p8, tmp, ws);
  352|       |
  353|    740|   for(size_t i = 0; i != 4; ++i) {
  ------------------
  |  Branch (353:22): [True: 592, False: 148]
  ------------------
  354|    592|      curve_sqr_tmp(r, tmp, ws);
  355|    592|   }
  356|    148|   curve_mul_tmp(r, p4, tmp, ws);
  357|       |
  358|    444|   for(size_t i = 0; i != 2; ++i) {
  ------------------
  |  Branch (358:22): [True: 296, False: 148]
  ------------------
  359|    296|      curve_sqr_tmp(r, tmp, ws);
  360|    296|   }
  361|    148|   curve_mul_tmp(r, p2, tmp, ws);
  362|       |
  363|    444|   for(size_t i = 0; i != 2; ++i) {
  ------------------
  |  Branch (363:22): [True: 296, False: 148]
  ------------------
  364|    296|      curve_sqr_tmp(r, tmp, ws);
  365|    296|   }
  366|    148|   curve_mul_tmp(r, x, tmp, ws);
  367|       |
  368|    148|   return r;
  369|    148|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST13curve_sqr_tmpERNS_6BigIntES3_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  197|  36.8k|      void curve_sqr_tmp(BigInt& x, BigInt& tmp, secure_vector<word>& ws) const {
  198|  36.8k|         curve_sqr(tmp, x, ws);
  199|  36.8k|         x.swap(tmp);
  200|  36.8k|      }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_NIST13curve_mul_tmpERNS_6BigIntERKS2_S3_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  192|  1.18k|      void curve_mul_tmp(BigInt& x, const BigInt& y, BigInt& tmp, secure_vector<word>& ws) const {
  193|  1.18k|         curve_mul(tmp, x, y, ws);
  194|  1.18k|         x.swap(tmp);
  195|  1.18k|      }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_113CurveGFp_P25610redc_mod_pERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
  294|   262k|      void redc_mod_p(BigInt& x, secure_vector<word>& ws) const override { redc_p256(x, ws); }
curve_gfp.cpp:_ZN5Botan12_GLOBAL__N_119CurveGFp_MontgomeryC2ERKNS_6BigIntES4_S4_:
   24|    823|            m_p(p), m_a(a), m_b(b), m_p_words(m_p.sig_words()), m_p_dash(monty_inverse(m_p.word_at(0))) {
   25|    823|         Modular_Reducer mod_p(m_p);
   26|       |
   27|    823|         m_r.set_bit(m_p_words * BOTAN_MP_WORD_BITS);
  ------------------
  |  |   50|    823|#define BOTAN_MP_WORD_BITS 64
  ------------------
   28|    823|         m_r = mod_p.reduce(m_r);
   29|       |
   30|    823|         m_r2 = mod_p.square(m_r);
   31|    823|         m_r3 = mod_p.multiply(m_r, m_r2);
   32|    823|         m_a_r = mod_p.multiply(m_r, m_a);
   33|    823|         m_b_r = mod_p.multiply(m_r, m_b);
   34|       |
   35|    823|         m_a_is_zero = m_a.is_zero();
   36|    823|         m_a_is_minus_3 = (m_a + 3 == m_p);
   37|    823|      }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery5get_pEv:
   47|   849k|      const BigInt& get_p() const override { return m_p; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery5get_aEv:
   43|    518|      const BigInt& get_a() const override { return m_a; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery5get_bEv:
   45|    518|      const BigInt& get_b() const override { return m_b; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery11get_p_wordsEv:
   57|   459k|      size_t get_p_words() const override { return m_p_words; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery11get_ws_sizeEv:
   59|  16.3M|      size_t get_ws_size() const override { return 2 * m_p_words; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery6is_oneERKNS_6BigIntE:
   55|    259|      bool is_one(const BigInt& x) const override { return x == m_r; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery9a_is_zeroEv:
   39|   385k|      bool a_is_zero() const override { return m_a_is_zero; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery12a_is_minus_3Ev:
   41|   385k|      bool a_is_minus_3() const override { return m_a_is_minus_3; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery9get_a_repEv:
   49|  1.12k|      const BigInt& get_a_rep() const override { return m_a_r; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery9get_b_repEv:
   51|  2.06k|      const BigInt& get_b_rep() const override { return m_b_r; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery9get_1_repEv:
   53|  3.16k|      const BigInt& get_1_rep() const override { return m_r; }
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery14invert_elementERKNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
   86|  1.37k|BigInt CurveGFp_Montgomery::invert_element(const BigInt& x, secure_vector<word>& ws) const {
   87|       |   // Should we use Montgomery inverse instead?
   88|  1.37k|   const BigInt inv = inverse_mod(x, m_p);
   89|  1.37k|   BigInt res;
   90|  1.37k|   curve_mul(res, inv, m_r3, ws);
   91|  1.37k|   return res;
   92|  1.37k|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery12to_curve_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
   94|  2.71k|void CurveGFp_Montgomery::to_curve_rep(BigInt& x, secure_vector<word>& ws) const {
   95|  2.71k|   const BigInt tx = x;
   96|  2.71k|   curve_mul(x, tx, m_r2, ws);
   97|  2.71k|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery14from_curve_repERNS_6BigIntERNSt3__16vectorImNS_16secure_allocatorImEEEE:
   99|  3.44k|void CurveGFp_Montgomery::from_curve_rep(BigInt& z, secure_vector<word>& ws) const {
  100|  3.44k|   if(ws.size() < get_ws_size()) {
  ------------------
  |  Branch (100:7): [True: 0, False: 3.44k]
  ------------------
  101|      0|      ws.resize(get_ws_size());
  102|      0|   }
  103|       |
  104|  3.44k|   const size_t output_size = 2 * m_p_words;
  105|  3.44k|   if(z.size() < output_size) {
  ------------------
  |  Branch (105:7): [True: 0, False: 3.44k]
  ------------------
  106|      0|      z.grow_to(output_size);
  107|      0|   }
  108|       |
  109|  3.44k|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
  110|  3.44k|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery15curve_mul_wordsERNS_6BigIntEPKmmRKS2_RNSt3__16vectorImNS_16secure_allocatorImEEEE:
  113|  11.4M|   BigInt& z, const word x_w[], size_t x_size, const BigInt& y, secure_vector<word>& ws) const {
  114|  11.4M|   BOTAN_DEBUG_ASSERT(y.sig_words() <= m_p_words);
  ------------------
  |  |   99|  11.4M|      do {                          \
  |  |  100|  11.4M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded - Ignored]
  |  |  ------------------
  ------------------
  115|       |
  116|  11.4M|   if(ws.size() < get_ws_size()) {
  ------------------
  |  Branch (116:7): [True: 0, False: 11.4M]
  ------------------
  117|      0|      ws.resize(get_ws_size());
  118|      0|   }
  119|       |
  120|  11.4M|   const size_t output_size = 2 * m_p_words;
  121|  11.4M|   if(z.size() < output_size) {
  ------------------
  |  Branch (121:7): [True: 3.00M, False: 8.42M]
  ------------------
  122|  3.00M|      z.grow_to(output_size);
  123|  3.00M|   }
  124|       |
  125|  11.4M|   bigint_mul(z.mutable_data(),
  126|  11.4M|              z.size(),
  127|  11.4M|              x_w,
  128|  11.4M|              x_size,
  129|  11.4M|              std::min(m_p_words, x_size),
  130|  11.4M|              y.data(),
  131|  11.4M|              y.size(),
  132|  11.4M|              std::min(m_p_words, y.size()),
  133|  11.4M|              ws.data(),
  134|  11.4M|              ws.size());
  135|       |
  136|  11.4M|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
  137|  11.4M|}
curve_gfp.cpp:_ZNK5Botan12_GLOBAL__N_119CurveGFp_Montgomery15curve_sqr_wordsERNS_6BigIntEPKmmRNSt3__16vectorImNS_16secure_allocatorImEEEE:
  139|  4.09M|void CurveGFp_Montgomery::curve_sqr_words(BigInt& z, const word x[], size_t x_size, secure_vector<word>& ws) const {
  140|  4.09M|   if(ws.size() < get_ws_size()) {
  ------------------
  |  Branch (140:7): [True: 1.38k, False: 4.09M]
  ------------------
  141|  1.38k|      ws.resize(get_ws_size());
  142|  1.38k|   }
  143|       |
  144|  4.09M|   const size_t output_size = 2 * m_p_words;
  145|  4.09M|   if(z.size() < output_size) {
  ------------------
  |  Branch (145:7): [True: 391k, False: 3.70M]
  ------------------
  146|   391k|      z.grow_to(output_size);
  147|   391k|   }
  148|       |
  149|  4.09M|   bigint_sqr(z.mutable_data(), z.size(), x, x_size, std::min(m_p_words, x_size), ws.data(), ws.size());
  150|       |
  151|  4.09M|   bigint_monty_redc(z.mutable_data(), m_p.data(), m_p_words, m_p_dash, ws.data(), ws.size());
  152|  4.09M|}

_ZN5Botan8EC_Group13ec_group_dataEv:
  289|  1.26k|EC_Group_Data_Map& EC_Group::ec_group_data() {
  290|       |   /*
  291|       |   * This exists purely to ensure the allocator is constructed before g_ec_data,
  292|       |   * which ensures that its destructor runs after ~g_ec_data is complete.
  293|       |   */
  294|       |
  295|  1.26k|   static Allocator_Initializer g_init_allocator;
  296|  1.26k|   static EC_Group_Data_Map g_ec_data;
  297|  1.26k|   return g_ec_data;
  298|  1.26k|}
_ZN5Botan8EC_Group18load_EC_group_infoEPKcS2_S2_S2_S2_S2_RKNS_3OIDE:
  312|    827|                                                            const OID& oid) {
  313|    827|   const BigInt p(p_str);
  314|    827|   const BigInt a(a_str);
  315|    827|   const BigInt b(b_str);
  316|    827|   const BigInt g_x(g_x_str);
  317|    827|   const BigInt g_y(g_y_str);
  318|    827|   const BigInt order(order_str);
  319|    827|   const BigInt cofactor(1);  // implicit
  320|       |
  321|    827|   return std::make_shared<EC_Group_Data>(p, a, b, g_x, g_y, order, cofactor, oid, EC_Group_Source::Builtin);
  322|    827|}
_ZN5Botan8EC_Group19BER_decode_EC_groupEPKhmNS_15EC_Group_SourceE:
  327|    806|                                                                              EC_Group_Source source) {
  328|    806|   BER_Decoder ber(bits, len);
  329|    806|   BER_Object obj = ber.get_next_object();
  330|       |
  331|    806|   if(obj.type() == ASN1_Type::ObjectId) {
  ------------------
  |  Branch (331:7): [True: 707, False: 99]
  ------------------
  332|    707|      OID dom_par_oid;
  333|    707|      BER_Decoder(bits, len).decode(dom_par_oid);
  334|    707|      return std::make_pair(ec_group_data().lookup(dom_par_oid), false);
  335|    707|   }
  336|       |
  337|     99|   if(obj.type() == ASN1_Type::Sequence) {
  ------------------
  |  Branch (337:7): [True: 57, False: 42]
  ------------------
  338|     57|      BigInt p, a, b, order, cofactor;
  339|     57|      std::vector<uint8_t> base_pt;
  340|     57|      std::vector<uint8_t> seed;
  341|       |
  342|     57|      BER_Decoder(bits, len)
  343|     57|         .start_sequence()
  344|     57|         .decode_and_check<size_t>(1, "Unknown ECC param version code")
  345|     57|         .start_sequence()
  346|     57|         .decode_and_check(OID("1.2.840.10045.1.1"), "Only prime ECC fields supported")
  347|     57|         .decode(p)
  348|     57|         .end_cons()
  349|     57|         .start_sequence()
  350|     57|         .decode_octet_string_bigint(a)
  351|     57|         .decode_octet_string_bigint(b)
  352|     57|         .decode_optional_string(seed, ASN1_Type::BitString, ASN1_Type::BitString)
  353|     57|         .end_cons()
  354|     57|         .decode(base_pt, ASN1_Type::OctetString)
  355|     57|         .decode(order)
  356|     57|         .decode(cofactor)
  357|     57|         .end_cons()
  358|     57|         .verify_end();
  359|       |
  360|     57|      if(p.bits() < 112 || p.bits() > 1024) {
  ------------------
  |  Branch (360:10): [True: 57, False: 0]
  |  Branch (360:28): [True: 0, False: 0]
  ------------------
  361|      0|         throw Decoding_Error("ECC p parameter is invalid size");
  362|      0|      }
  363|       |
  364|     57|      if(p.is_negative() || !is_bailie_psw_probable_prime(p)) {
  ------------------
  |  Branch (364:10): [True: 57, False: 0]
  |  Branch (364:29): [True: 0, False: 0]
  ------------------
  365|      0|         throw Decoding_Error("ECC p parameter is not a prime");
  366|      0|      }
  367|       |
  368|     57|      if(a.is_negative() || a >= p) {
  ------------------
  |  Branch (368:10): [True: 57, False: 0]
  |  Branch (368:29): [True: 0, False: 0]
  ------------------
  369|      0|         throw Decoding_Error("Invalid ECC a parameter");
  370|      0|      }
  371|       |
  372|     57|      if(b <= 0 || b >= p) {
  ------------------
  |  Branch (372:10): [True: 57, False: 0]
  |  Branch (372:20): [True: 0, False: 0]
  ------------------
  373|      0|         throw Decoding_Error("Invalid ECC b parameter");
  374|      0|      }
  375|       |
  376|     57|      if(order <= 0 || !is_bailie_psw_probable_prime(order)) {
  ------------------
  |  Branch (376:10): [True: 57, False: 0]
  |  Branch (376:24): [True: 0, False: 0]
  ------------------
  377|      0|         throw Decoding_Error("Invalid ECC order parameter");
  378|      0|      }
  379|       |
  380|     57|      if(cofactor <= 0 || cofactor >= 16) {
  ------------------
  |  Branch (380:10): [True: 57, False: 0]
  |  Branch (380:27): [True: 0, False: 0]
  ------------------
  381|      0|         throw Decoding_Error("Invalid ECC cofactor parameter");
  382|      0|      }
  383|       |
  384|     57|      std::pair<BigInt, BigInt> base_xy = Botan::OS2ECP(base_pt.data(), base_pt.size(), p, a, b);
  385|       |
  386|     57|      auto data =
  387|     57|         ec_group_data().lookup_or_create(p, a, b, base_xy.first, base_xy.second, order, cofactor, OID(), source);
  388|     57|      return std::make_pair(data, true);
  389|     57|   }
  390|       |
  391|     42|   if(obj.type() == ASN1_Type::Null) {
  ------------------
  |  Branch (391:7): [True: 3, False: 39]
  ------------------
  392|      3|      throw Decoding_Error("Cannot handle ImplicitCA ECC parameters");
  393|     39|   } else {
  394|     39|      throw Decoding_Error(fmt("Unexpected tag {} while decoding ECC domain params", asn1_tag_to_string(obj.type())));
  395|     39|   }
  396|     42|}
_ZN5Botan8EC_GroupC2Ev:
  398|    571|EC_Group::EC_Group() = default;
_ZN5Botan8EC_GroupD2Ev:
  400|  2.21k|EC_Group::~EC_Group() = default;
_ZN5Botan8EC_GroupC2ERKNS_3OIDE:
  402|    558|EC_Group::EC_Group(const OID& domain_oid) {
  403|    558|   this->m_data = ec_group_data().lookup(domain_oid);
  404|    558|   if(!this->m_data) {
  ------------------
  |  Branch (404:7): [True: 60, False: 498]
  ------------------
  405|     60|      throw Invalid_Argument("Unknown EC_Group " + domain_oid.to_string());
  406|     60|   }
  407|    558|}
_ZN5Botan8EC_GroupC2EPKhm:
  455|    806|EC_Group::EC_Group(const uint8_t ber[], size_t ber_len) {
  456|    806|   auto data = BER_decode_EC_group(ber, ber_len, EC_Group_Source::ExternalSource);
  457|    806|   m_data = data.first;
  458|    806|   m_explicit_encoding = data.second;
  459|    806|}
_ZNK5Botan8EC_Group4dataEv:
  461|  4.97k|const EC_Group_Data& EC_Group::data() const {
  462|  4.97k|   if(m_data == nullptr) {
  ------------------
  |  Branch (462:7): [True: 14, False: 4.96k]
  ------------------
  463|     14|      throw Invalid_State("EC_Group uninitialized");
  464|     14|   }
  465|  4.96k|   return *m_data;
  466|  4.97k|}
_ZNK5Botan8EC_Group10get_p_bitsEv:
  476|    562|size_t EC_Group::get_p_bits() const {
  477|    562|   return data().p_bits();
  478|    562|}
_ZNK5Botan8EC_Group14get_order_bitsEv:
  484|     56|size_t EC_Group::get_order_bits() const {
  485|     56|   return data().order_bits();
  486|     56|}
_ZNK5Botan8EC_Group15get_order_bytesEv:
  488|    410|size_t EC_Group::get_order_bytes() const {
  489|    410|   return data().order_bytes();
  490|    410|}
_ZNK5Botan8EC_Group14get_base_pointEv:
  504|    438|const EC_Point& EC_Group::get_base_point() const {
  505|    438|   return data().base_point();
  506|    438|}
_ZNK5Botan8EC_Group9get_orderEv:
  508|    823|const BigInt& EC_Group::get_order() const {
  509|    823|   return data().order();
  510|    823|}
_ZNK5Botan8EC_Group9mod_orderERKNS_6BigIntE:
  524|    365|BigInt EC_Group::mod_order(const BigInt& k) const {
  525|    365|   return data().mod_order(k);
  526|    365|}
_ZNK5Botan8EC_Group18multiply_mod_orderERKNS_6BigIntES3_:
  532|    624|BigInt EC_Group::multiply_mod_order(const BigInt& x, const BigInt& y) const {
  533|    624|   return data().multiply_mod_order(x, y);
  534|    624|}
_ZNK5Botan8EC_Group17inverse_mod_orderERKNS_6BigIntE:
  540|    312|BigInt EC_Group::inverse_mod_order(const BigInt& x) const {
  541|    312|   return data().inverse_mod_order(x);
  542|    312|}
_ZNK5Botan8EC_Group13get_curve_oidEv:
  544|    211|const OID& EC_Group::get_curve_oid() const {
  545|    211|   return data().oid();
  546|    211|}
_ZNK5Botan8EC_Group6OS2ECPEPKhm:
  561|    704|EC_Point EC_Group::OS2ECP(const uint8_t bits[], size_t len) const {
  562|    704|   return Botan::OS2ECP(bits, len, data().curve());
  563|    704|}
_ZNK5Botan8EC_Group5pointERKNS_6BigIntES3_:
  565|    469|EC_Point EC_Group::point(const BigInt& x, const BigInt& y) const {
  566|       |   // TODO: randomize the representation?
  567|    469|   return EC_Point(data().curve(), x, y);
  568|    469|}
_ZN5Botan17EC_Group_Data_MapC2Ev:
  147|      1|      EC_Group_Data_Map() = default;
_ZN5Botan17EC_Group_Data_Map6lookupERKNS_3OIDE:
  156|  1.26k|      std::shared_ptr<EC_Group_Data> lookup(const OID& oid) {
  157|  1.26k|         lock_guard_type<mutex_type> lock(m_mutex);
  158|       |
  159|   467k|         for(auto i : m_registered_curves) {
  ------------------
  |  Branch (159:21): [True: 467k, False: 901]
  ------------------
  160|   467k|            if(i->oid() == oid) {
  ------------------
  |  Branch (160:16): [True: 361, False: 467k]
  ------------------
  161|    361|               return i;
  162|    361|            }
  163|   467k|         }
  164|       |
  165|       |         // Not found, check hardcoded data
  166|    901|         std::shared_ptr<EC_Group_Data> data = EC_Group::EC_group_info(oid);
  167|       |
  168|    901|         if(data) {
  ------------------
  |  Branch (168:13): [True: 827, False: 74]
  ------------------
  169|   341k|            for(auto curve : m_registered_curves) {
  ------------------
  |  Branch (169:28): [True: 341k, False: 827]
  ------------------
  170|   341k|               if(curve->oid().empty() == true && curve->params_match(*data)) {
  ------------------
  |  Branch (170:19): [True: 0, False: 341k]
  |  Branch (170:51): [True: 0, False: 0]
  ------------------
  171|      0|                  curve->set_oid(oid);
  172|      0|                  return curve;
  173|      0|               }
  174|   341k|            }
  175|       |
  176|    827|            m_registered_curves.push_back(data);
  177|    827|            return data;
  178|    827|         }
  179|       |
  180|       |         // Nope, unknown curve
  181|     74|         return std::shared_ptr<EC_Group_Data>();
  182|    901|      }
_ZN5Botan13EC_Group_DataC2ERKNS_6BigIntES3_S3_S3_S3_S3_S3_RKNS_3OIDENS_15EC_Group_SourceE:
   54|    827|            m_source(source) {}
_ZNK5Botan13EC_Group_Data6p_bitsEv:
   93|    562|      size_t p_bits() const { return m_p_bits; }
_ZNK5Botan13EC_Group_Data10order_bitsEv:
   97|     56|      size_t order_bits() const { return m_order_bits; }
_ZNK5Botan13EC_Group_Data11order_bytesEv:
   99|    410|      size_t order_bytes() const { return (m_order_bits + 7) / 8; }
_ZNK5Botan13EC_Group_Data10base_pointEv:
  103|    438|      const EC_Point& base_point() const { return m_base_point; }
_ZNK5Botan13EC_Group_Data5orderEv:
   85|    823|      const BigInt& order() const { return m_order; }
_ZNK5Botan13EC_Group_Data9mod_orderERKNS_6BigIntE:
  109|    365|      BigInt mod_order(const BigInt& x) const { return m_mod_order.reduce(x); }
_ZNK5Botan13EC_Group_Data18multiply_mod_orderERKNS_6BigIntES3_:
  113|    624|      BigInt multiply_mod_order(const BigInt& x, const BigInt& y) const { return m_mod_order.multiply(x, y); }
_ZNK5Botan13EC_Group_Data17inverse_mod_orderERKNS_6BigIntE:
  119|    312|      BigInt inverse_mod_order(const BigInt& x) const { return inverse_mod(x, m_order); }
_ZNK5Botan13EC_Group_Data3oidEv:
   77|   809k|      const OID& oid() const { return m_oid; }
_ZNK5Botan13EC_Group_Data5curveEv:
  101|  1.15k|      const CurveGFp& curve() const { return m_curve; }

_ZN5Botan8EC_Group13EC_group_infoERKNS_3OIDE:
   15|    901|std::shared_ptr<EC_Group_Data> EC_Group::EC_group_info(const OID& oid) {
   16|       |   // secp256r1
   17|    901|   if(oid == OID{1, 2, 840, 10045, 3, 1, 7}) {
  ------------------
  |  Branch (17:7): [True: 1, False: 900]
  ------------------
   18|      1|      return load_EC_group_info(
   19|      1|         "0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF",
   20|      1|         "0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC",
   21|      1|         "0x5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B",
   22|      1|         "0x6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296",
   23|      1|         "0x4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5",
   24|      1|         "0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551",
   25|      1|         oid);
   26|      1|   }
   27|       |
   28|       |   // secp384r1
   29|    900|   if(oid == OID{1, 3, 132, 0, 34}) {
  ------------------
  |  Branch (29:7): [True: 0, False: 900]
  ------------------
   30|      0|      return load_EC_group_info(
   31|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF",
   32|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC",
   33|      0|         "0xB3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF",
   34|      0|         "0xAA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7",
   35|      0|         "0x3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F",
   36|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973",
   37|      0|         oid);
   38|      0|   }
   39|       |
   40|       |   // secp521r1
   41|    900|   if(oid == OID{1, 3, 132, 0, 35}) {
  ------------------
  |  Branch (41:7): [True: 0, False: 900]
  ------------------
   42|      0|      return load_EC_group_info(
   43|      0|         "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
   44|      0|         "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC",
   45|      0|         "0x51953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00",
   46|      0|         "0xC6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66",
   47|      0|         "0x11839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650",
   48|      0|         "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409",
   49|      0|         oid);
   50|      0|   }
   51|       |
   52|       |   // brainpool160r1
   53|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 1}) {
  ------------------
  |  Branch (53:7): [True: 0, False: 900]
  ------------------
   54|      0|      return load_EC_group_info(
   55|      0|         "0xE95E4A5F737059DC60DFC7AD95B3D8139515620F",
   56|      0|         "0x340E7BE2A280EB74E2BE61BADA745D97E8F7C300",
   57|      0|         "0x1E589A8595423412134FAA2DBDEC95C8D8675E58",
   58|      0|         "0xBED5AF16EA3F6A4F62938C4631EB5AF7BDBCDBC3",
   59|      0|         "0x1667CB477A1A8EC338F94741669C976316DA6321",
   60|      0|         "0xE95E4A5F737059DC60DF5991D45029409E60FC09",
   61|      0|         oid);
   62|      0|   }
   63|       |
   64|       |   // brainpool192r1
   65|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 3}) {
  ------------------
  |  Branch (65:7): [True: 0, False: 900]
  ------------------
   66|      0|      return load_EC_group_info(
   67|      0|         "0xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86297",
   68|      0|         "0x6A91174076B1E0E19C39C031FE8685C1CAE040E5C69A28EF",
   69|      0|         "0x469A28EF7C28CCA3DC721D044F4496BCCA7EF4146FBF25C9",
   70|      0|         "0xC0A0647EAAB6A48753B033C56CB0F0900A2F5C4853375FD6",
   71|      0|         "0x14B690866ABD5BB88B5F4828C1490002E6773FA2FA299B8F",
   72|      0|         "0xC302F41D932A36CDA7A3462F9E9E916B5BE8F1029AC4ACC1",
   73|      0|         oid);
   74|      0|   }
   75|       |
   76|       |   // brainpool224r1
   77|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 5}) {
  ------------------
  |  Branch (77:7): [True: 0, False: 900]
  ------------------
   78|      0|      return load_EC_group_info(
   79|      0|         "0xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF",
   80|      0|         "0x68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43",
   81|      0|         "0x2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B",
   82|      0|         "0xD9029AD2C7E5CF4340823B2A87DC68C9E4CE3174C1E6EFDEE12C07D",
   83|      0|         "0x58AA56F772C0726F24C6B89E4ECDAC24354B9E99CAA3F6D3761402CD",
   84|      0|         "0xD7C134AA264366862A18302575D0FB98D116BC4B6DDEBCA3A5A7939F",
   85|      0|         oid);
   86|      0|   }
   87|       |
   88|       |   // brainpool256r1
   89|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 7}) {
  ------------------
  |  Branch (89:7): [True: 0, False: 900]
  ------------------
   90|      0|      return load_EC_group_info(
   91|      0|         "0xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377",
   92|      0|         "0x7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9",
   93|      0|         "0x26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6",
   94|      0|         "0x8BD2AEB9CB7E57CB2C4B482FFC81B7AFB9DE27E1E3BD23C23A4453BD9ACE3262",
   95|      0|         "0x547EF835C3DAC4FD97F8461A14611DC9C27745132DED8E545C1D54C72F046997",
   96|      0|         "0xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7",
   97|      0|         oid);
   98|      0|   }
   99|       |
  100|       |   // brainpool320r1
  101|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 9}) {
  ------------------
  |  Branch (101:7): [True: 0, False: 900]
  ------------------
  102|      0|      return load_EC_group_info(
  103|      0|         "0xD35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E27",
  104|      0|         "0x3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9F492F375A97D860EB4",
  105|      0|         "0x520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539816F5EB4AC8FB1F1A6",
  106|      0|         "0x43BD7E9AFB53D8B85289BCC48EE5BFE6F20137D10A087EB6E7871E2A10A599C710AF8D0D39E20611",
  107|      0|         "0x14FDD05545EC1CC8AB4093247F77275E0743FFED117182EAA9C77877AAAC6AC7D35245D1692E8EE1",
  108|      0|         "0xD35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658E98691555B44C59311",
  109|      0|         oid);
  110|      0|   }
  111|       |
  112|       |   // brainpool384r1
  113|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 11}) {
  ------------------
  |  Branch (113:7): [True: 0, False: 900]
  ------------------
  114|      0|      return load_EC_group_info(
  115|      0|         "0x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC53",
  116|      0|         "0x7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F90F8AA5814A503AD4EB04A8C7DD22CE2826",
  117|      0|         "0x4A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62D57CB4390295DBC9943AB78696FA504C11",
  118|      0|         "0x1D1C64F068CF45FFA2A63A81B7C13F6B8847A3E77EF14FE3DB7FCAFE0CBD10E8E826E03436D646AAEF87B2E247D4AF1E",
  119|      0|         "0x8ABE1D7520F9C2A45CB1EB8E95CFD55262B70B29FEEC5864E19C054FF99129280E4646217791811142820341263C5315",
  120|      0|         "0x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425A7CF3AB6AF6B7FC3103B883202E9046565",
  121|      0|         oid);
  122|      0|   }
  123|       |
  124|       |   // brainpool512r1
  125|    900|   if(oid == OID{1, 3, 36, 3, 3, 2, 8, 1, 1, 13}) {
  ------------------
  |  Branch (125:7): [True: 0, False: 900]
  ------------------
  126|      0|      return load_EC_group_info(
  127|      0|         "0xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3",
  128|      0|         "0x7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA",
  129|      0|         "0x3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723",
  130|      0|         "0x81AEE4BDD82ED9645A21322E9C4C6A9385ED9F70B5D916C1B43B62EEF4D0098EFF3B1F78E2D0D48D50D1687B93B97D5F7C6D5047406A5E688B352209BCB9F822",
  131|      0|         "0x7DDE385D566332ECC0EABFA9CF7822FDF209F70024A57B1AA000C55B881F8111B2DCDE494A5F485E5BCA4BD88A2763AED1CA2B2FA8F0540678CD1E0F3AD80892",
  132|      0|         "0xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA70330870553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069",
  133|      0|         oid);
  134|      0|   }
  135|       |
  136|       |   // frp256v1
  137|    900|   if(oid == OID{1, 2, 250, 1, 223, 101, 256, 1}) {
  ------------------
  |  Branch (137:7): [True: 0, False: 900]
  ------------------
  138|      0|      return load_EC_group_info(
  139|      0|         "0xF1FD178C0B3AD58F10126DE8CE42435B3961ADBCABC8CA6DE8FCF353D86E9C03",
  140|      0|         "0xF1FD178C0B3AD58F10126DE8CE42435B3961ADBCABC8CA6DE8FCF353D86E9C00",
  141|      0|         "0xEE353FCA5428A9300D4ABA754A44C00FDFEC0C9AE4B1A1803075ED967B7BB73F",
  142|      0|         "0xB6B3D4C356C139EB31183D4749D423958C27D2DCAF98B70164C97A2DD98F5CFF",
  143|      0|         "0x6142E0F7C8B204911F9271F0F3ECEF8C2701C307E8E4C9E183115A1554062CFB",
  144|      0|         "0xF1FD178C0B3AD58F10126DE8CE42435B53DC67E140D2BF941FFDD459C6D655E1",
  145|      0|         oid);
  146|      0|   }
  147|       |
  148|       |   // gost_256A
  149|    900|   if(oid == OID{1, 2, 643, 7, 1, 2, 1, 1, 1} || oid == OID{1, 2, 643, 2, 2, 35, 1} || oid == OID{1, 2, 643, 2, 2, 36, 0}) {
  ------------------
  |  Branch (149:7): [True: 1, False: 899]
  |  Branch (149:7): [True: 819, False: 81]
  |  Branch (149:50): [True: 19, False: 880]
  |  Branch (149:88): [True: 799, False: 81]
  ------------------
  150|    819|      return load_EC_group_info(
  151|    819|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD97",
  152|    819|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD94",
  153|    819|         "0xA6",
  154|    819|         "1",
  155|    819|         "0x8D91E471E0989CDA27DF505A453F2B7635294F2DDF23E3B122ACC99C9E9F1E14",
  156|    819|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6C611070995AD10045841B09B761B893",
  157|    819|         OID{1, 2, 643, 7, 1, 2, 1, 1, 1});
  158|    819|   }
  159|       |
  160|       |   // gost_512A
  161|     81|   if(oid == OID{1, 2, 643, 7, 1, 2, 1, 2, 1}) {
  ------------------
  |  Branch (161:7): [True: 1, False: 80]
  ------------------
  162|      1|      return load_EC_group_info(
  163|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC7",
  164|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDC4",
  165|      1|         "0xE8C2505DEDFC86DDC1BD0B2B6667F1DA34B82574761CB0E879BD081CFD0B6265EE3CB090F30D27614CB4574010DA90DD862EF9D4EBEE4761503190785A71C760",
  166|      1|         "3",
  167|      1|         "0x7503CFE87A836AE3A61B8816E25450E6CE5E1C93ACF1ABC1778064FDCBEFA921DF1626BE4FD036E93D75E6A50E3A41E98028FE5FC235F5B889A589CB5215F2A4",
  168|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF27E69532F48D89116FF22B8D4E0560609B4B38ABFAD2B85DCACDB1411F10B275",
  169|      1|         oid);
  170|      1|   }
  171|       |
  172|       |   // secp160k1
  173|     80|   if(oid == OID{1, 3, 132, 0, 9}) {
  ------------------
  |  Branch (173:7): [True: 0, False: 80]
  ------------------
  174|      0|      return load_EC_group_info(
  175|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73",
  176|      0|         "0",
  177|      0|         "7",
  178|      0|         "0x3B4C382CE37AA192A4019E763036F4F5DD4D7EBB",
  179|      0|         "0x938CF935318FDCED6BC28286531733C3F03C4FEE",
  180|      0|         "0x100000000000000000001B8FA16DFAB9ACA16B6B3",
  181|      0|         oid);
  182|      0|   }
  183|       |
  184|       |   // secp160r1
  185|     80|   if(oid == OID{1, 3, 132, 0, 8}) {
  ------------------
  |  Branch (185:7): [True: 0, False: 80]
  ------------------
  186|      0|      return load_EC_group_info(
  187|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF",
  188|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC",
  189|      0|         "0x1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45",
  190|      0|         "0x4A96B5688EF573284664698968C38BB913CBFC82",
  191|      0|         "0x23A628553168947D59DCC912042351377AC5FB32",
  192|      0|         "0x100000000000000000001F4C8F927AED3CA752257",
  193|      0|         oid);
  194|      0|   }
  195|       |
  196|       |   // secp160r2
  197|     80|   if(oid == OID{1, 3, 132, 0, 30}) {
  ------------------
  |  Branch (197:7): [True: 0, False: 80]
  ------------------
  198|      0|      return load_EC_group_info(
  199|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73",
  200|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC70",
  201|      0|         "0xB4E134D3FB59EB8BAB57274904664D5AF50388BA",
  202|      0|         "0x52DCB034293A117E1F4FF11B30F7199D3144CE6D",
  203|      0|         "0xFEAFFEF2E331F296E071FA0DF9982CFEA7D43F2E",
  204|      0|         "0x100000000000000000000351EE786A818F3A1A16B",
  205|      0|         oid);
  206|      0|   }
  207|       |
  208|       |   // secp192k1
  209|     80|   if(oid == OID{1, 3, 132, 0, 31}) {
  ------------------
  |  Branch (209:7): [True: 0, False: 80]
  ------------------
  210|      0|      return load_EC_group_info(
  211|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37",
  212|      0|         "0",
  213|      0|         "3",
  214|      0|         "0xDB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D",
  215|      0|         "0x9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D",
  216|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D",
  217|      0|         oid);
  218|      0|   }
  219|       |
  220|       |   // secp192r1
  221|     80|   if(oid == OID{1, 2, 840, 10045, 3, 1, 1}) {
  ------------------
  |  Branch (221:7): [True: 1, False: 79]
  ------------------
  222|      1|      return load_EC_group_info(
  223|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF",
  224|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
  225|      1|         "0x64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1",
  226|      1|         "0x188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012",
  227|      1|         "0x7192B95FFC8DA78631011ED6B24CDD573F977A11E794811",
  228|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831",
  229|      1|         oid);
  230|      1|   }
  231|       |
  232|       |   // secp224k1
  233|     79|   if(oid == OID{1, 3, 132, 0, 32}) {
  ------------------
  |  Branch (233:7): [True: 0, False: 79]
  ------------------
  234|      0|      return load_EC_group_info(
  235|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D",
  236|      0|         "0",
  237|      0|         "5",
  238|      0|         "0xA1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C",
  239|      0|         "0x7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5",
  240|      0|         "0x10000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7",
  241|      0|         oid);
  242|      0|   }
  243|       |
  244|       |   // secp224r1
  245|     79|   if(oid == OID{1, 3, 132, 0, 33}) {
  ------------------
  |  Branch (245:7): [True: 0, False: 79]
  ------------------
  246|      0|      return load_EC_group_info(
  247|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001",
  248|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE",
  249|      0|         "0xB4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4",
  250|      0|         "0xB70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21",
  251|      0|         "0xBD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34",
  252|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D",
  253|      0|         oid);
  254|      0|   }
  255|       |
  256|       |   // secp256k1
  257|     79|   if(oid == OID{1, 3, 132, 0, 10}) {
  ------------------
  |  Branch (257:7): [True: 0, False: 79]
  ------------------
  258|      0|      return load_EC_group_info(
  259|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F",
  260|      0|         "0",
  261|      0|         "7",
  262|      0|         "0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798",
  263|      0|         "0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8",
  264|      0|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141",
  265|      0|         oid);
  266|      0|   }
  267|       |
  268|       |   // sm2p256v1
  269|     79|   if(oid == OID{1, 2, 156, 10197, 1, 301}) {
  ------------------
  |  Branch (269:7): [True: 0, False: 79]
  ------------------
  270|      0|      return load_EC_group_info(
  271|      0|         "0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF",
  272|      0|         "0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC",
  273|      0|         "0x28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93",
  274|      0|         "0x32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7",
  275|      0|         "0xBC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0",
  276|      0|         "0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123",
  277|      0|         oid);
  278|      0|   }
  279|       |
  280|       |   // x962_p192v2
  281|     79|   if(oid == OID{1, 2, 840, 10045, 3, 1, 2}) {
  ------------------
  |  Branch (281:7): [True: 1, False: 78]
  ------------------
  282|      1|      return load_EC_group_info(
  283|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF",
  284|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
  285|      1|         "0xCC22D6DFB95C6B25E49C0D6364A4E5980C393AA21668D953",
  286|      1|         "0xEEA2BAE7E1497842F2DE7769CFE9C989C072AD696F48034A",
  287|      1|         "0x6574D11D69B6EC7A672BB82A083DF2F2B0847DE970B2DE15",
  288|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFE5FB1A724DC80418648D8DD31",
  289|      1|         oid);
  290|      1|   }
  291|       |
  292|       |   // x962_p192v3
  293|     78|   if(oid == OID{1, 2, 840, 10045, 3, 1, 3}) {
  ------------------
  |  Branch (293:7): [True: 1, False: 77]
  ------------------
  294|      1|      return load_EC_group_info(
  295|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF",
  296|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
  297|      1|         "0x22123DC2395A05CAA7423DAECCC94760A7D462256BD56916",
  298|      1|         "0x7D29778100C65A1DA1783716588DCE2B8B4AEE8E228F1896",
  299|      1|         "0x38A90F22637337334B49DCB66A6DC8F9978ACA7648A943B0",
  300|      1|         "0xFFFFFFFFFFFFFFFFFFFFFFFF7A62D031C83F4294F640EC13",
  301|      1|         oid);
  302|      1|   }
  303|       |
  304|       |   // x962_p239v1
  305|     77|   if(oid == OID{1, 2, 840, 10045, 3, 1, 4}) {
  ------------------
  |  Branch (305:7): [True: 1, False: 76]
  ------------------
  306|      1|      return load_EC_group_info(
  307|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFF",
  308|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
  309|      1|         "0x6B016C3BDCF18941D0D654921475CA71A9DB2FB27D1D37796185C2942C0A",
  310|      1|         "0xFFA963CDCA8816CCC33B8642BEDF905C3D358573D3F27FBBD3B3CB9AAAF",
  311|      1|         "0x7DEBE8E4E90A5DAE6E4054CA530BA04654B36818CE226B39FCCB7B02F1AE",
  312|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFF9E5E9A9F5D9071FBD1522688909D0B",
  313|      1|         oid);
  314|      1|   }
  315|       |
  316|       |   // x962_p239v2
  317|     76|   if(oid == OID{1, 2, 840, 10045, 3, 1, 5}) {
  ------------------
  |  Branch (317:7): [True: 1, False: 75]
  ------------------
  318|      1|      return load_EC_group_info(
  319|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFF",
  320|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
  321|      1|         "0x617FAB6832576CBBFED50D99F0249C3FEE58B94BA0038C7AE84C8C832F2C",
  322|      1|         "0x38AF09D98727705120C921BB5E9E26296A3CDCF2F35757A0EAFD87B830E7",
  323|      1|         "0x5B0125E4DBEA0EC7206DA0FC01D9B081329FB555DE6EF460237DFF8BE4BA",
  324|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF800000CFA7E8594377D414C03821BC582063",
  325|      1|         oid);
  326|      1|   }
  327|       |
  328|       |   // x962_p239v3
  329|     75|   if(oid == OID{1, 2, 840, 10045, 3, 1, 6}) {
  ------------------
  |  Branch (329:7): [True: 1, False: 74]
  ------------------
  330|      1|      return load_EC_group_info(
  331|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFF",
  332|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
  333|      1|         "0x255705FA2A306654B1F4CB03D6A750A30C250102D4988717D9BA15AB6D3E",
  334|      1|         "0x6768AE8E18BB92CFCF005C949AA2C6D94853D0E660BBF854B1C9505FE95A",
  335|      1|         "0x1607E6898F390C06BC1D552BAD226F3B6FCFE48B6E818499AF18E3ED6CF3",
  336|      1|         "0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFF975DEB41B3A6057C3C432146526551",
  337|      1|         oid);
  338|      1|   }
  339|       |
  340|     74|   return std::shared_ptr<EC_Group_Data>();
  341|     75|}

_ZN5Botan8EC_PointC2ERKNS_8CurveGFpE:
   18|    312|EC_Point::EC_Point(const CurveGFp& curve) : m_curve(curve), m_coord_x(0), m_coord_y(curve.get_1_rep()), m_coord_z(0) {
   19|       |   // Assumes Montgomery rep of zero is zero
   20|    312|}
_ZN5Botan8EC_PointC2ERKNS_8CurveGFpERKNS_6BigIntES6_:
   23|  1.69k|      m_curve(curve), m_coord_x(x), m_coord_y(y), m_coord_z(m_curve.get_1_rep()) {
   24|  1.69k|   if(x < 0 || x >= curve.get_p()) {
  ------------------
  |  Branch (24:7): [True: 0, False: 1.69k]
  |  Branch (24:16): [True: 179, False: 1.51k]
  ------------------
   25|    179|      throw Invalid_Argument("Invalid EC_Point affine x");
   26|    179|   }
   27|  1.51k|   if(y < 0 || y >= curve.get_p()) {
  ------------------
  |  Branch (27:7): [True: 0, False: 1.51k]
  |  Branch (27:16): [True: 3, False: 1.51k]
  ------------------
   28|      3|      throw Invalid_Argument("Invalid EC_Point affine y");
   29|      3|   }
   30|       |
   31|  1.51k|   secure_vector<word> monty_ws(m_curve.get_ws_size());
   32|  1.51k|   m_curve.to_rep(m_coord_x, monty_ws);
   33|  1.51k|   m_curve.to_rep(m_coord_y, monty_ws);
   34|  1.51k|}
_ZN5Botan8EC_Point10add_affineEPKmmS2_mRNSt3__16vectorINS_6BigIntENS3_9allocatorIS5_EEEE:
   74|  36.9k|   const word x_words[], size_t x_size, const word y_words[], size_t y_size, std::vector<BigInt>& ws_bn) {
   75|  36.9k|   if((CT::all_zeros(x_words, x_size) & CT::all_zeros(y_words, y_size)).as_bool()) {
  ------------------
  |  Branch (75:7): [True: 0, False: 36.9k]
  ------------------
   76|      0|      return;
   77|      0|   }
   78|       |
   79|  36.9k|   if(is_zero()) {
  ------------------
  |  Branch (79:7): [True: 312, False: 36.6k]
  ------------------
   80|    312|      m_coord_x.set_words(x_words, x_size);
   81|    312|      m_coord_y.set_words(y_words, y_size);
   82|    312|      m_coord_z = m_curve.get_1_rep();
   83|    312|      return;
   84|    312|   }
   85|       |
   86|  36.6k|   resize_ws(ws_bn, m_curve.get_ws_size());
   87|       |
   88|  36.6k|   secure_vector<word>& ws = ws_bn[0].get_word_vector();
   89|  36.6k|   secure_vector<word>& sub_ws = ws_bn[1].get_word_vector();
   90|       |
   91|  36.6k|   BigInt& T0 = ws_bn[2];
   92|  36.6k|   BigInt& T1 = ws_bn[3];
   93|  36.6k|   BigInt& T2 = ws_bn[4];
   94|  36.6k|   BigInt& T3 = ws_bn[5];
   95|  36.6k|   BigInt& T4 = ws_bn[6];
   96|       |
   97|       |   /*
   98|       |   https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-1998-cmo-2
   99|       |   simplified with Z2 = 1
  100|       |   */
  101|       |
  102|  36.6k|   const BigInt& p = m_curve.get_p();
  103|       |
  104|  36.6k|   m_curve.sqr(T3, m_coord_z, ws);            // z1^2
  105|  36.6k|   m_curve.mul(T4, x_words, x_size, T3, ws);  // x2*z1^2
  106|       |
  107|  36.6k|   m_curve.mul(T2, m_coord_z, T3, ws);        // z1^3
  108|  36.6k|   m_curve.mul(T0, y_words, y_size, T2, ws);  // y2*z1^3
  109|       |
  110|  36.6k|   T4.mod_sub(m_coord_x, p, sub_ws);  // x2*z1^2 - x1*z2^2
  111|       |
  112|  36.6k|   T0.mod_sub(m_coord_y, p, sub_ws);
  113|       |
  114|  36.6k|   if(T4.is_zero()) {
  ------------------
  |  Branch (114:7): [True: 0, False: 36.6k]
  ------------------
  115|      0|      if(T0.is_zero()) {
  ------------------
  |  Branch (115:10): [True: 0, False: 0]
  ------------------
  116|      0|         mult2(ws_bn);
  117|      0|         return;
  118|      0|      }
  119|       |
  120|       |      // setting to zero:
  121|      0|      m_coord_x.clear();
  122|      0|      m_coord_y = m_curve.get_1_rep();
  123|      0|      m_coord_z.clear();
  124|      0|      return;
  125|      0|   }
  126|       |
  127|  36.6k|   m_curve.sqr(T2, T4, ws);
  128|       |
  129|  36.6k|   m_curve.mul(T3, m_coord_x, T2, ws);
  130|       |
  131|  36.6k|   m_curve.mul(T1, T2, T4, ws);
  132|       |
  133|  36.6k|   m_curve.sqr(m_coord_x, T0, ws);
  134|  36.6k|   m_coord_x.mod_sub(T1, p, sub_ws);
  135|       |
  136|  36.6k|   m_coord_x.mod_sub(T3, p, sub_ws);
  137|  36.6k|   m_coord_x.mod_sub(T3, p, sub_ws);
  138|       |
  139|  36.6k|   T3.mod_sub(m_coord_x, p, sub_ws);
  140|       |
  141|  36.6k|   m_curve.mul(T2, T0, T3, ws);
  142|  36.6k|   m_curve.mul(T0, m_coord_y, T1, ws);
  143|  36.6k|   T2.mod_sub(T0, p, sub_ws);
  144|  36.6k|   m_coord_y.swap(T2);
  145|       |
  146|  36.6k|   m_curve.mul(T0, m_coord_z, T4, ws);
  147|  36.6k|   m_coord_z.swap(T0);
  148|  36.6k|}
_ZN5Botan8EC_Point3addEPKmmS2_mS2_mRNSt3__16vectorINS_6BigIntENS3_9allocatorIS5_EEEE:
  156|   431k|                   std::vector<BigInt>& ws_bn) {
  157|   431k|   if((CT::all_zeros(x_words, x_size) & CT::all_zeros(z_words, z_size)).as_bool()) {
  ------------------
  |  Branch (157:7): [True: 0, False: 431k]
  ------------------
  158|      0|      return;
  159|      0|   }
  160|       |
  161|   431k|   if(is_zero()) {
  ------------------
  |  Branch (161:7): [True: 0, False: 431k]
  ------------------
  162|      0|      m_coord_x.set_words(x_words, x_size);
  163|      0|      m_coord_y.set_words(y_words, y_size);
  164|      0|      m_coord_z.set_words(z_words, z_size);
  165|      0|      return;
  166|      0|   }
  167|       |
  168|   431k|   resize_ws(ws_bn, m_curve.get_ws_size());
  169|       |
  170|   431k|   secure_vector<word>& ws = ws_bn[0].get_word_vector();
  171|   431k|   secure_vector<word>& sub_ws = ws_bn[1].get_word_vector();
  172|       |
  173|   431k|   BigInt& T0 = ws_bn[2];
  174|   431k|   BigInt& T1 = ws_bn[3];
  175|   431k|   BigInt& T2 = ws_bn[4];
  176|   431k|   BigInt& T3 = ws_bn[5];
  177|   431k|   BigInt& T4 = ws_bn[6];
  178|   431k|   BigInt& T5 = ws_bn[7];
  179|       |
  180|       |   /*
  181|       |   https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-1998-cmo-2
  182|       |   */
  183|       |
  184|   431k|   const BigInt& p = m_curve.get_p();
  185|       |
  186|   431k|   m_curve.sqr(T0, z_words, z_size, ws);      // z2^2
  187|   431k|   m_curve.mul(T1, m_coord_x, T0, ws);        // x1*z2^2
  188|   431k|   m_curve.mul(T3, z_words, z_size, T0, ws);  // z2^3
  189|   431k|   m_curve.mul(T2, m_coord_y, T3, ws);        // y1*z2^3
  190|       |
  191|   431k|   m_curve.sqr(T3, m_coord_z, ws);            // z1^2
  192|   431k|   m_curve.mul(T4, x_words, x_size, T3, ws);  // x2*z1^2
  193|       |
  194|   431k|   m_curve.mul(T5, m_coord_z, T3, ws);        // z1^3
  195|   431k|   m_curve.mul(T0, y_words, y_size, T5, ws);  // y2*z1^3
  196|       |
  197|   431k|   T4.mod_sub(T1, p, sub_ws);  // x2*z1^2 - x1*z2^2
  198|       |
  199|   431k|   T0.mod_sub(T2, p, sub_ws);
  200|       |
  201|   431k|   if(T4.is_zero()) {
  ------------------
  |  Branch (201:7): [True: 0, False: 431k]
  ------------------
  202|      0|      if(T0.is_zero()) {
  ------------------
  |  Branch (202:10): [True: 0, False: 0]
  ------------------
  203|      0|         mult2(ws_bn);
  204|      0|         return;
  205|      0|      }
  206|       |
  207|       |      // setting to zero:
  208|      0|      m_coord_x.clear();
  209|      0|      m_coord_y = m_curve.get_1_rep();
  210|      0|      m_coord_z.clear();
  211|      0|      return;
  212|      0|   }
  213|       |
  214|   431k|   m_curve.sqr(T5, T4, ws);
  215|       |
  216|   431k|   m_curve.mul(T3, T1, T5, ws);
  217|       |
  218|   431k|   m_curve.mul(T1, T5, T4, ws);
  219|       |
  220|   431k|   m_curve.sqr(m_coord_x, T0, ws);
  221|   431k|   m_coord_x.mod_sub(T1, p, sub_ws);
  222|   431k|   m_coord_x.mod_sub(T3, p, sub_ws);
  223|   431k|   m_coord_x.mod_sub(T3, p, sub_ws);
  224|       |
  225|   431k|   T3.mod_sub(m_coord_x, p, sub_ws);
  226|       |
  227|   431k|   m_curve.mul(m_coord_y, T0, T3, ws);
  228|   431k|   m_curve.mul(T3, T2, T1, ws);
  229|       |
  230|   431k|   m_coord_y.mod_sub(T3, p, sub_ws);
  231|       |
  232|   431k|   m_curve.mul(T3, z_words, z_size, m_coord_z, ws);
  233|   431k|   m_curve.mul(m_coord_z, T3, T4, ws);
  234|   431k|}
_ZN5Botan8EC_Point6mult2iEmRNSt3__16vectorINS_6BigIntENS1_9allocatorIS3_EEEE:
  236|  39.4k|void EC_Point::mult2i(size_t iterations, std::vector<BigInt>& ws_bn) {
  237|  39.4k|   if(iterations == 0) {
  ------------------
  |  Branch (237:7): [True: 0, False: 39.4k]
  ------------------
  238|      0|      return;
  239|      0|   }
  240|       |
  241|  39.4k|   if(m_coord_y.is_zero()) {
  ------------------
  |  Branch (241:7): [True: 0, False: 39.4k]
  ------------------
  242|      0|      *this = EC_Point(m_curve);  // setting myself to zero
  243|      0|      return;
  244|      0|   }
  245|       |
  246|       |   /*
  247|       |   TODO we can save 2 squarings per iteration by computing
  248|       |   a*Z^4 using values cached from previous iteration
  249|       |   */
  250|   118k|   for(size_t i = 0; i != iterations; ++i) {
  ------------------
  |  Branch (250:22): [True: 78.9k, False: 39.4k]
  ------------------
  251|  78.9k|      mult2(ws_bn);
  252|  78.9k|   }
  253|  39.4k|}
_ZN5Botan8EC_Point5mult2ERNSt3__16vectorINS_6BigIntENS1_9allocatorIS3_EEEE:
  256|   399k|void EC_Point::mult2(std::vector<BigInt>& ws_bn) {
  257|   399k|   if(is_zero()) {
  ------------------
  |  Branch (257:7): [True: 0, False: 399k]
  ------------------
  258|      0|      return;
  259|      0|   }
  260|       |
  261|   399k|   if(m_coord_y.is_zero()) {
  ------------------
  |  Branch (261:7): [True: 0, False: 399k]
  ------------------
  262|      0|      *this = EC_Point(m_curve);  // setting myself to zero
  263|      0|      return;
  264|      0|   }
  265|       |
  266|   399k|   resize_ws(ws_bn, m_curve.get_ws_size());
  267|       |
  268|   399k|   secure_vector<word>& ws = ws_bn[0].get_word_vector();
  269|   399k|   secure_vector<word>& sub_ws = ws_bn[1].get_word_vector();
  270|       |
  271|   399k|   BigInt& T0 = ws_bn[2];
  272|   399k|   BigInt& T1 = ws_bn[3];
  273|   399k|   BigInt& T2 = ws_bn[4];
  274|   399k|   BigInt& T3 = ws_bn[5];
  275|   399k|   BigInt& T4 = ws_bn[6];
  276|       |
  277|       |   /*
  278|       |   https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-1986-cc
  279|       |   */
  280|   399k|   const BigInt& p = m_curve.get_p();
  281|       |
  282|   399k|   m_curve.sqr(T0, m_coord_y, ws);
  283|       |
  284|   399k|   m_curve.mul(T1, m_coord_x, T0, ws);
  285|   399k|   T1.mod_mul(4, p, sub_ws);
  286|       |
  287|   399k|   if(m_curve.a_is_zero()) {
  ------------------
  |  Branch (287:7): [True: 0, False: 399k]
  ------------------
  288|       |      // if a == 0 then 3*x^2 + a*z^4 is just 3*x^2
  289|      0|      m_curve.sqr(T4, m_coord_x, ws);  // x^2
  290|      0|      T4.mod_mul(3, p, sub_ws);        // 3*x^2
  291|   399k|   } else if(m_curve.a_is_minus_3()) {
  ------------------
  |  Branch (291:14): [True: 399k, False: 0]
  ------------------
  292|       |      /*
  293|       |      if a == -3 then
  294|       |        3*x^2 + a*z^4 == 3*x^2 - 3*z^4 == 3*(x^2-z^4) == 3*(x-z^2)*(x+z^2)
  295|       |      */
  296|   399k|      m_curve.sqr(T3, m_coord_z, ws);  // z^2
  297|       |
  298|       |      // (x-z^2)
  299|   399k|      T2 = m_coord_x;
  300|   399k|      T2.mod_sub(T3, p, sub_ws);
  301|       |
  302|       |      // (x+z^2)
  303|   399k|      T3.mod_add(m_coord_x, p, sub_ws);
  304|       |
  305|   399k|      m_curve.mul(T4, T2, T3, ws);  // (x-z^2)*(x+z^2)
  306|       |
  307|   399k|      T4.mod_mul(3, p, sub_ws);  // 3*(x-z^2)*(x+z^2)
  308|   399k|   } else {
  309|      0|      m_curve.sqr(T3, m_coord_z, ws);                // z^2
  310|      0|      m_curve.sqr(T4, T3, ws);                       // z^4
  311|      0|      m_curve.mul(T3, m_curve.get_a_rep(), T4, ws);  // a*z^4
  312|       |
  313|      0|      m_curve.sqr(T4, m_coord_x, ws);  // x^2
  314|      0|      T4.mod_mul(3, p, sub_ws);
  315|      0|      T4.mod_add(T3, p, sub_ws);  // 3*x^2 + a*z^4
  316|      0|   }
  317|       |
  318|   399k|   m_curve.sqr(T2, T4, ws);
  319|   399k|   T2.mod_sub(T1, p, sub_ws);
  320|   399k|   T2.mod_sub(T1, p, sub_ws);
  321|       |
  322|   399k|   m_curve.sqr(T3, T0, ws);
  323|   399k|   T3.mod_mul(8, p, sub_ws);
  324|       |
  325|   399k|   T1.mod_sub(T2, p, sub_ws);
  326|       |
  327|   399k|   m_curve.mul(T0, T4, T1, ws);
  328|   399k|   T0.mod_sub(T3, p, sub_ws);
  329|       |
  330|   399k|   m_coord_x.swap(T2);
  331|       |
  332|   399k|   m_curve.mul(T2, m_coord_y, m_coord_z, ws);
  333|   399k|   T2.mod_mul(2, p, sub_ws);
  334|       |
  335|   399k|   m_coord_y.swap(T0);
  336|   399k|   m_coord_z.swap(T2);
  337|   399k|}
_ZN5Botan8EC_Point16force_all_affineERNSt3__16vectorIS0_NS1_9allocatorIS0_EEEERNS2_ImNS_16secure_allocatorImEEEE:
  388|  1.26k|void EC_Point::force_all_affine(std::vector<EC_Point>& points, secure_vector<word>& ws) {
  389|  1.26k|   if(points.size() <= 1) {
  ------------------
  |  Branch (389:7): [True: 0, False: 1.26k]
  ------------------
  390|      0|      for(auto& point : points) {
  ------------------
  |  Branch (390:23): [True: 0, False: 0]
  ------------------
  391|      0|         point.force_affine();
  392|      0|      }
  393|      0|      return;
  394|      0|   }
  395|       |
  396|   753k|   for(auto& point : points) {
  ------------------
  |  Branch (396:20): [True: 753k, False: 1.26k]
  ------------------
  397|   753k|      if(point.is_zero()) {
  ------------------
  |  Branch (397:10): [True: 0, False: 753k]
  ------------------
  398|      0|         throw Invalid_State("Cannot convert zero ECC point to affine");
  399|      0|      }
  400|   753k|   }
  401|       |
  402|       |   /*
  403|       |   For >= 2 points use Montgomery's trick
  404|       |
  405|       |   See Algorithm 2.26 in "Guide to Elliptic Curve Cryptography"
  406|       |   (Hankerson, Menezes, Vanstone)
  407|       |
  408|       |   TODO is it really necessary to save all k points in c?
  409|       |   */
  410|       |
  411|  1.26k|   const CurveGFp& curve = points[0].m_curve;
  412|  1.26k|   const BigInt& rep_1 = curve.get_1_rep();
  413|       |
  414|  1.26k|   if(ws.size() < curve.get_ws_size()) {
  ------------------
  |  Branch (414:7): [True: 0, False: 1.26k]
  ------------------
  415|      0|      ws.resize(curve.get_ws_size());
  416|      0|   }
  417|       |
  418|  1.26k|   std::vector<BigInt> c(points.size());
  419|  1.26k|   c[0] = points[0].m_coord_z;
  420|       |
  421|   753k|   for(size_t i = 1; i != points.size(); ++i) {
  ------------------
  |  Branch (421:22): [True: 752k, False: 1.26k]
  ------------------
  422|   752k|      curve.mul(c[i], c[i - 1], points[i].m_coord_z, ws);
  423|   752k|   }
  424|       |
  425|  1.26k|   BigInt s_inv = curve.invert_element(c[c.size() - 1], ws);
  426|       |
  427|  1.26k|   BigInt z_inv, z2_inv, z3_inv;
  428|       |
  429|   753k|   for(size_t i = points.size() - 1; i != 0; i--) {
  ------------------
  |  Branch (429:38): [True: 752k, False: 1.26k]
  ------------------
  430|   752k|      EC_Point& point = points[i];
  431|       |
  432|   752k|      curve.mul(z_inv, s_inv, c[i - 1], ws);
  433|       |
  434|   752k|      s_inv = curve.mul_to_tmp(s_inv, point.m_coord_z, ws);
  435|       |
  436|   752k|      curve.sqr(z2_inv, z_inv, ws);
  437|   752k|      curve.mul(z3_inv, z2_inv, z_inv, ws);
  438|   752k|      point.m_coord_x = curve.mul_to_tmp(point.m_coord_x, z2_inv, ws);
  439|   752k|      point.m_coord_y = curve.mul_to_tmp(point.m_coord_y, z3_inv, ws);
  440|   752k|      point.m_coord_z = rep_1;
  441|   752k|   }
  442|       |
  443|  1.26k|   curve.sqr(z2_inv, s_inv, ws);
  444|  1.26k|   curve.mul(z3_inv, z2_inv, s_inv, ws);
  445|  1.26k|   points[0].m_coord_x = curve.mul_to_tmp(points[0].m_coord_x, z2_inv, ws);
  446|  1.26k|   points[0].m_coord_y = curve.mul_to_tmp(points[0].m_coord_y, z3_inv, ws);
  447|  1.26k|   points[0].m_coord_z = rep_1;
  448|  1.26k|}
_ZNK5Botan8EC_Point9is_affineEv:
  465|    312|bool EC_Point::is_affine() const {
  466|    312|   return m_curve.is_one(m_coord_z);
  467|    312|}
_ZNK5Botan8EC_Point12get_affine_xEv:
  469|    312|BigInt EC_Point::get_affine_x() const {
  470|    312|   if(is_zero()) {
  ------------------
  |  Branch (470:7): [True: 0, False: 312]
  ------------------
  471|      0|      throw Invalid_State("Cannot convert zero point to affine");
  472|      0|   }
  473|       |
  474|    312|   secure_vector<word> monty_ws;
  475|       |
  476|    312|   if(is_affine()) {
  ------------------
  |  Branch (476:7): [True: 0, False: 312]
  ------------------
  477|      0|      return m_curve.from_rep_to_tmp(m_coord_x, monty_ws);
  478|      0|   }
  479|       |
  480|    312|   BigInt z2 = m_curve.sqr_to_tmp(m_coord_z, monty_ws);
  481|    312|   z2 = m_curve.invert_element(z2, monty_ws);
  482|       |
  483|    312|   BigInt r;
  484|    312|   m_curve.mul(r, m_coord_x, z2, monty_ws);
  485|    312|   m_curve.from_rep(r, monty_ws);
  486|    312|   return r;
  487|    312|}
_ZNK5Botan8EC_Point12on_the_curveEv:
  510|  1.56k|bool EC_Point::on_the_curve() const {
  511|       |   /*
  512|       |   Is the point still on the curve?? (If everything is correct, the
  513|       |   point is always on its curve; then the function will return true.
  514|       |   If somehow the state is corrupted, which suggests a fault attack
  515|       |   (or internal computational error), then return false.
  516|       |   */
  517|  1.56k|   if(is_zero()) {
  ------------------
  |  Branch (517:7): [True: 0, False: 1.56k]
  ------------------
  518|      0|      return true;
  519|      0|   }
  520|       |
  521|  1.56k|   secure_vector<word> monty_ws;
  522|       |
  523|  1.56k|   const BigInt y2 = m_curve.from_rep_to_tmp(m_curve.sqr_to_tmp(m_coord_y, monty_ws), monty_ws);
  524|  1.56k|   const BigInt x3 = m_curve.mul_to_tmp(m_coord_x, m_curve.sqr_to_tmp(m_coord_x, monty_ws), monty_ws);
  525|  1.56k|   const BigInt ax = m_curve.mul_to_tmp(m_coord_x, m_curve.get_a_rep(), monty_ws);
  526|  1.56k|   const BigInt z2 = m_curve.sqr_to_tmp(m_coord_z, monty_ws);
  527|       |
  528|  1.56k|   if(m_coord_z == z2)  // Is z equal to 1 (in Montgomery form)?
  ------------------
  |  Branch (528:7): [True: 1.56k, False: 0]
  ------------------
  529|  1.56k|   {
  530|  1.56k|      if(y2 != m_curve.from_rep_to_tmp(x3 + ax + m_curve.get_b_rep(), monty_ws)) {
  ------------------
  |  Branch (530:10): [True: 203, False: 1.36k]
  ------------------
  531|    203|         return false;
  532|    203|      }
  533|  1.56k|   }
  534|       |
  535|  1.36k|   const BigInt z3 = m_curve.mul_to_tmp(m_coord_z, z2, monty_ws);
  536|  1.36k|   const BigInt ax_z4 = m_curve.mul_to_tmp(ax, m_curve.sqr_to_tmp(z2, monty_ws), monty_ws);
  537|  1.36k|   const BigInt b_z6 = m_curve.mul_to_tmp(m_curve.get_b_rep(), m_curve.sqr_to_tmp(z3, monty_ws), monty_ws);
  538|       |
  539|  1.36k|   if(y2 != m_curve.from_rep_to_tmp(x3 + ax_z4 + b_z6, monty_ws)) {
  ------------------
  |  Branch (539:7): [True: 0, False: 1.36k]
  ------------------
  540|      0|      return false;
  541|      0|   }
  542|       |
  543|  1.36k|   return true;
  544|  1.36k|}
_ZN5Botan8EC_Point4swapERS0_:
  547|   645k|void EC_Point::swap(EC_Point& other) {
  548|   645k|   m_curve.swap(other.m_curve);
  549|   645k|   m_coord_x.swap(other.m_coord_x);
  550|   645k|   m_coord_y.swap(other.m_coord_y);
  551|   645k|   m_coord_z.swap(other.m_coord_z);
  552|   645k|}
_ZN5Botan6OS2ECPEPKhmRKNS_8CurveGFpE:
  627|    690|EC_Point OS2ECP(const uint8_t data[], size_t data_len, const CurveGFp& curve) {
  628|       |   // Should we really be doing this?
  629|    690|   if(data_len <= 1) {
  ------------------
  |  Branch (629:7): [True: 0, False: 690]
  ------------------
  630|      0|      return EC_Point(curve);  // return zero
  631|      0|   }
  632|       |
  633|    690|   std::pair<BigInt, BigInt> xy = OS2ECP(data, data_len, curve.get_p(), curve.get_a(), curve.get_b());
  634|       |
  635|    690|   EC_Point point(curve, xy.first, xy.second);
  636|       |
  637|    690|   if(!point.on_the_curve()) {
  ------------------
  |  Branch (637:7): [True: 14, False: 676]
  ------------------
  638|     14|      throw Decoding_Error("OS2ECP: Decoded point was not on the curve");
  639|     14|   }
  640|       |
  641|    676|   return point;
  642|    690|}
_ZN5Botan6OS2ECPEPKhmRKNS_6BigIntES4_S4_:
  645|    690|   const uint8_t data[], size_t data_len, const BigInt& curve_p, const BigInt& curve_a, const BigInt& curve_b) {
  646|    690|   if(data_len <= 1) {
  ------------------
  |  Branch (646:7): [True: 0, False: 690]
  ------------------
  647|      0|      throw Decoding_Error("OS2ECP invalid point");
  648|      0|   }
  649|       |
  650|    690|   const uint8_t pc = data[0];
  651|       |
  652|    690|   BigInt x, y;
  653|       |
  654|    690|   if(pc == 2 || pc == 3) {
  ------------------
  |  Branch (654:7): [True: 396, False: 294]
  |  Branch (654:18): [True: 64, False: 230]
  ------------------
  655|       |      //compressed form
  656|    460|      x = BigInt::decode(&data[1], data_len - 1);
  657|       |
  658|    460|      const bool y_mod_2 = ((pc & 0x01) == 1);
  659|    460|      y = decompress_point(y_mod_2, x, curve_p, curve_a, curve_b);
  660|    460|   } else if(pc == 4) {
  ------------------
  |  Branch (660:14): [True: 17, False: 213]
  ------------------
  661|     17|      const size_t l = (data_len - 1) / 2;
  662|       |
  663|       |      // uncompressed form
  664|     17|      x = BigInt::decode(&data[1], l);
  665|     17|      y = BigInt::decode(&data[l + 1], l);
  666|    213|   } else if(pc == 6 || pc == 7) {
  ------------------
  |  Branch (666:14): [True: 189, False: 24]
  |  Branch (666:25): [True: 14, False: 10]
  ------------------
  667|    203|      const size_t l = (data_len - 1) / 2;
  668|       |
  669|       |      // hybrid form
  670|    203|      x = BigInt::decode(&data[1], l);
  671|    203|      y = BigInt::decode(&data[l + 1], l);
  672|       |
  673|    203|      const bool y_mod_2 = ((pc & 0x01) == 1);
  674|       |
  675|    203|      if(decompress_point(y_mod_2, x, curve_p, curve_a, curve_b) != y) {
  ------------------
  |  Branch (675:10): [True: 111, False: 92]
  ------------------
  676|    111|         throw Decoding_Error("OS2ECP: Decoding error in hybrid format");
  677|    111|      }
  678|    203|   } else {
  679|     10|      throw Invalid_Argument("OS2ECP: Unknown format type " + std::to_string(pc));
  680|     10|   }
  681|       |
  682|    569|   return std::make_pair(x, y);
  683|    690|}
ec_point.cpp:_ZN5Botan12_GLOBAL__N_19resize_wsERNSt3__16vectorINS_6BigIntENS1_9allocatorIS3_EEEEm:
   61|   868k|inline void resize_ws(std::vector<BigInt>& ws_bn, size_t cap_size) {
   62|   868k|   BOTAN_ASSERT(ws_bn.size() >= EC_Point::WORKSPACE_SIZE, "Expected size for EC_Point workspace");
  ------------------
  |  |   51|   868k|   do {                                                                                 \
  |  |   52|   868k|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 0, False: 868k]
  |  |  ------------------
  |  |   53|   868k|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|   868k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   63|       |
   64|  6.94M|   for(auto& ws : ws_bn) {
  ------------------
  |  Branch (64:17): [True: 6.94M, False: 868k]
  ------------------
   65|  6.94M|      if(ws.size() < cap_size) {
  ------------------
  |  Branch (65:10): [True: 12.9k, False: 6.93M]
  ------------------
   66|  12.9k|         ws.get_word_vector().resize(cap_size);
   67|  12.9k|      }
   68|  6.94M|   }
   69|   868k|}
ec_point.cpp:_ZN5Botan12_GLOBAL__N_116decompress_pointEbRKNS_6BigIntES3_S3_S3_:
  604|    663|   bool yMod2, const BigInt& x, const BigInt& curve_p, const BigInt& curve_a, const BigInt& curve_b) {
  605|    663|   BigInt xpow3 = x * x * x;
  606|       |
  607|    663|   BigInt g = curve_a * x;
  608|    663|   g += xpow3;
  609|    663|   g += curve_b;
  610|    663|   g = g % curve_p;
  611|       |
  612|    663|   BigInt z = sqrt_modulo_prime(g, curve_p);
  613|       |
  614|    663|   if(z < 0) {
  ------------------
  |  Branch (614:7): [True: 167, False: 496]
  ------------------
  615|    167|      throw Decoding_Error("Error during EC point decompression");
  616|    167|   }
  617|       |
  618|    496|   if(z.get_bit(0) != yMod2) {
  ------------------
  |  Branch (618:7): [True: 260, False: 236]
  ------------------
  619|    260|      z = curve_p - z;
  620|    260|   }
  621|       |
  622|    496|   return z;
  623|    663|}

_ZN5Botan30EC_Point_Base_Point_PrecomputeC2ERKNS_8EC_PointERKNS_15Modular_ReducerE:
   30|    827|      m_base_point(base), m_mod_order(mod_order), m_p_words(base.get_curve().get_p().sig_words()) {
   31|    827|   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
   32|       |
   33|    827|   const size_t p_bits = base.get_curve().get_p().bits();
   34|       |
   35|       |   /*
   36|       |   * Some of the curves (eg secp160k1) have an order slightly larger than
   37|       |   * the size of the prime modulus. In all cases they are at most 1 bit
   38|       |   * longer. The +1 compensates for this.
   39|       |   */
   40|    827|   const size_t T_bits = round_up(p_bits + blinding_size(mod_order.get_modulus()) + 1, WINDOW_BITS) / WINDOW_BITS;
   41|       |
   42|    827|   std::vector<EC_Point> T(WINDOW_SIZE * T_bits);
   43|       |
   44|    827|   EC_Point g = base;
   45|    827|   EC_Point g2, g4;
   46|       |
   47|   107k|   for(size_t i = 0; i != T_bits; i++) {
  ------------------
  |  Branch (47:22): [True: 106k, False: 827]
  ------------------
   48|   106k|      g2 = g;
   49|   106k|      g2.mult2(ws);
   50|   106k|      g4 = g2;
   51|   106k|      g4.mult2(ws);
   52|       |
   53|   106k|      T[7 * i + 0] = g;
   54|   106k|      T[7 * i + 1] = std::move(g2);
   55|   106k|      T[7 * i + 2] = T[7 * i + 1].plus(T[7 * i + 0], ws);  // g2+g
   56|   106k|      T[7 * i + 3] = g4;
   57|   106k|      T[7 * i + 4] = T[7 * i + 3].plus(T[7 * i + 0], ws);  // g4+g
   58|   106k|      T[7 * i + 5] = T[7 * i + 3].plus(T[7 * i + 1], ws);  // g4+g2
   59|   106k|      T[7 * i + 6] = T[7 * i + 3].plus(T[7 * i + 2], ws);  // g4+g2+g
   60|       |
   61|   106k|      g.swap(g4);
   62|   106k|      g.mult2(ws);
   63|   106k|   }
   64|       |
   65|    827|   EC_Point::force_all_affine(T, ws[0].get_word_vector());
   66|       |
   67|    827|   m_W.resize(T.size() * 2 * m_p_words);
   68|       |
   69|    827|   word* p = &m_W[0];
   70|   747k|   for(size_t i = 0; i != T.size(); ++i) {
  ------------------
  |  Branch (70:22): [True: 746k, False: 827]
  ------------------
   71|   746k|      T[i].get_x().encode_words(p, m_p_words);
   72|   746k|      p += m_p_words;
   73|   746k|      T[i].get_y().encode_words(p, m_p_words);
   74|   746k|      p += m_p_words;
   75|   746k|   }
   76|    827|}
_ZN5Botan31EC_Point_Multi_Point_PrecomputeC2ERKNS_8EC_PointES3_:
  295|    438|EC_Point_Multi_Point_Precompute::EC_Point_Multi_Point_Precompute(const EC_Point& x, const EC_Point& y) {
  296|    438|   if(x.on_the_curve() == false || y.on_the_curve() == false) {
  ------------------
  |  Branch (296:7): [True: 0, False: 438]
  |  Branch (296:36): [True: 0, False: 438]
  ------------------
  297|      0|      m_M.push_back(x.zero());
  298|      0|      return;
  299|      0|   }
  300|       |
  301|    438|   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
  302|       |
  303|    438|   EC_Point x2 = x;
  304|    438|   x2.mult2(ws);
  305|       |
  306|    438|   const EC_Point x3(x2.plus(x, ws));
  307|       |
  308|    438|   EC_Point y2 = y;
  309|    438|   y2.mult2(ws);
  310|       |
  311|    438|   const EC_Point y3(y2.plus(y, ws));
  312|       |
  313|    438|   m_M.reserve(15);
  314|       |
  315|    438|   m_M.push_back(x);
  316|    438|   m_M.push_back(x2);
  317|    438|   m_M.push_back(x3);
  318|       |
  319|    438|   m_M.push_back(y);
  320|    438|   m_M.push_back(y.plus(x, ws));
  321|    438|   m_M.push_back(y.plus(x2, ws));
  322|    438|   m_M.push_back(y.plus(x3, ws));
  323|       |
  324|    438|   m_M.push_back(y2);
  325|    438|   m_M.push_back(y2.plus(x, ws));
  326|    438|   m_M.push_back(y2.plus(x2, ws));
  327|    438|   m_M.push_back(y2.plus(x3, ws));
  328|       |
  329|    438|   m_M.push_back(y3);
  330|    438|   m_M.push_back(y3.plus(x, ws));
  331|    438|   m_M.push_back(y3.plus(x2, ws));
  332|    438|   m_M.push_back(y3.plus(x3, ws));
  333|       |
  334|    438|   bool no_infinity = true;
  335|  6.57k|   for(auto& pt : m_M) {
  ------------------
  |  Branch (335:17): [True: 6.57k, False: 438]
  ------------------
  336|  6.57k|      if(pt.is_zero()) {
  ------------------
  |  Branch (336:10): [True: 0, False: 6.57k]
  ------------------
  337|      0|         no_infinity = false;
  338|      0|      }
  339|  6.57k|   }
  340|       |
  341|    438|   if(no_infinity) {
  ------------------
  |  Branch (341:7): [True: 438, False: 0]
  ------------------
  342|    438|      EC_Point::force_all_affine(m_M, ws[0].get_word_vector());
  343|    438|   }
  344|       |
  345|    438|   m_no_infinity = no_infinity;
  346|    438|}
_ZNK5Botan31EC_Point_Multi_Point_Precompute9multi_expERKNS_6BigIntES3_:
  348|    312|EC_Point EC_Point_Multi_Point_Precompute::multi_exp(const BigInt& z1, const BigInt& z2) const {
  349|    312|   if(m_M.size() == 1) {
  ------------------
  |  Branch (349:7): [True: 0, False: 312]
  ------------------
  350|      0|      return m_M[0];
  351|      0|   }
  352|       |
  353|    312|   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
  354|       |
  355|    312|   const size_t z_bits = round_up(std::max(z1.bits(), z2.bits()), 2);
  356|       |
  357|    312|   EC_Point H = m_M[0].zero();
  358|       |
  359|  40.1k|   for(size_t i = 0; i != z_bits; i += 2) {
  ------------------
  |  Branch (359:22): [True: 39.8k, False: 312]
  ------------------
  360|  39.8k|      if(i > 0) {
  ------------------
  |  Branch (360:10): [True: 39.4k, False: 312]
  ------------------
  361|  39.4k|         H.mult2i(2, ws);
  362|  39.4k|      }
  363|       |
  364|  39.8k|      const uint32_t z1_b = z1.get_substring(z_bits - i - 2, 2);
  365|  39.8k|      const uint32_t z2_b = z2.get_substring(z_bits - i - 2, 2);
  366|       |
  367|  39.8k|      const uint32_t z12 = (4 * z2_b) + z1_b;
  368|       |
  369|       |      // This function is not intended to be const time
  370|  39.8k|      if(z12) {
  ------------------
  |  Branch (370:10): [True: 36.9k, False: 2.84k]
  ------------------
  371|  36.9k|         if(m_no_infinity) {
  ------------------
  |  Branch (371:13): [True: 36.9k, False: 0]
  ------------------
  372|  36.9k|            H.add_affine(m_M[z12 - 1], ws);
  373|  36.9k|         } else {
  374|      0|            H.add(m_M[z12 - 1], ws);
  375|      0|         }
  376|  36.9k|      }
  377|  39.8k|   }
  378|       |
  379|    312|   if(z1.is_negative() != z2.is_negative()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 312]
  ------------------
  380|      0|      H.negate();
  381|      0|   }
  382|       |
  383|    312|   return H;
  384|    312|}
point_mul.cpp:_ZN5Botan12_GLOBAL__N_113blinding_sizeERKNS_6BigIntE:
   18|    827|size_t blinding_size(const BigInt& group_order) {
   19|    827|   return (group_order.bits() + 1) / 2;
   20|    827|}

_ZNK5Botan12EC_PublicKey10key_lengthEv:
   21|     64|size_t EC_PublicKey::key_length() const {
   22|     64|   return domain().get_p_bits();
   23|     64|}
_ZNK5Botan12EC_PublicKey18estimated_strengthEv:
   25|     64|size_t EC_PublicKey::estimated_strength() const {
   26|     64|   return ecp_work_factor(key_length());
   27|     64|}
_ZN5Botan12EC_PublicKeyC2ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   47|    806|      m_domain_encoding(default_encoding_for(m_domain_params)) {}
ecc_key.cpp:_ZN5Botan12_GLOBAL__N_120default_encoding_forERNS_8EC_GroupE:
   31|    211|EC_Group_Encoding default_encoding_for(EC_Group& group) {
   32|    211|   if(group.get_curve_oid().empty()) {
  ------------------
  |  Branch (32:7): [True: 0, False: 211]
  ------------------
   33|      0|      return EC_Group_Encoding::Explicit;
   34|    211|   } else {
   35|    211|      return EC_Group_Encoding::NamedCurve;
   36|    211|   }
   37|    211|}

_ZNK5Botan15ECDSA_PublicKey27create_x509_verification_opERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  259|    211|   const AlgorithmIdentifier& signature_algorithm, std::string_view provider) const {
  260|    211|   if(provider == "base" || provider.empty()) {
  ------------------
  |  Branch (260:7): [True: 0, False: 211]
  |  Branch (260:29): [True: 211, False: 0]
  ------------------
  261|    211|      return std::make_unique<ECDSA_Verification_Operation>(*this, signature_algorithm);
  262|    211|   }
  263|       |
  264|      0|   throw Provider_Not_Found(algo_name(), provider);
  265|    211|}
ecdsa.cpp:_ZN5Botan12_GLOBAL__N_128ECDSA_Verification_Operation6verifyEPKhmS3_m:
  214|    136|bool ECDSA_Verification_Operation::verify(const uint8_t msg[], size_t msg_len, const uint8_t sig[], size_t sig_len) {
  215|    136|   if(sig_len != m_group.get_order_bytes() * 2) {
  ------------------
  |  Branch (215:7): [True: 80, False: 56]
  ------------------
  216|     80|      return false;
  217|     80|   }
  218|       |
  219|     56|   const BigInt e = BigInt::from_bytes_with_max_bits(msg, msg_len, m_group.get_order_bits());
  220|       |
  221|     56|   const BigInt r(sig, sig_len / 2);
  222|     56|   const BigInt s(sig + sig_len / 2, sig_len / 2);
  223|       |
  224|       |   // Cannot be negative here since we just decoded from binary
  225|     56|   if(r.is_zero() || s.is_zero()) {
  ------------------
  |  Branch (225:7): [True: 0, False: 56]
  |  Branch (225:22): [True: 0, False: 56]
  ------------------
  226|      0|      return false;
  227|      0|   }
  228|       |
  229|     56|   if(r >= m_group.get_order() || s >= m_group.get_order()) {
  ------------------
  |  Branch (229:7): [True: 0, False: 56]
  |  Branch (229:35): [True: 3, False: 53]
  ------------------
  230|      3|      return false;
  231|      3|   }
  232|       |
  233|     53|   const BigInt w = m_group.inverse_mod_order(s);
  234|       |
  235|     53|   const BigInt u1 = m_group.multiply_mod_order(m_group.mod_order(e), w);
  236|     53|   const BigInt u2 = m_group.multiply_mod_order(r, w);
  237|     53|   const EC_Point R = m_gy_mul.multi_exp(u1, u2);
  238|       |
  239|     53|   if(R.is_zero()) {
  ------------------
  |  Branch (239:7): [True: 0, False: 53]
  ------------------
  240|      0|      return false;
  241|      0|   }
  242|       |
  243|     53|   const BigInt v = m_group.mod_order(R.get_affine_x());
  244|     53|   return (v == r);
  245|     53|}
ecdsa.cpp:_ZN5Botan12_GLOBAL__N_128ECDSA_Verification_OperationC2ERKNS_15ECDSA_PublicKeyERKNS_19AlgorithmIdentifierE:
  205|    211|            m_gy_mul(m_group.get_base_point(), ecdsa.public_point()) {}

_ZN5Botan19GOST_3410_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
   64|    571|GOST_3410_PublicKey::GOST_3410_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
   65|    571|   OID ecc_param_id;
   66|       |
   67|       |   // The parameters also includes hash and cipher OIDs
   68|    571|   BER_Decoder(alg_id.parameters()).start_sequence().decode(ecc_param_id);
   69|       |
   70|    571|   m_domain_params = EC_Group(ecc_param_id);
   71|       |
   72|    571|   const size_t p_bits = m_domain_params.get_p_bits();
   73|    571|   if(p_bits != 256 && p_bits != 512) {
  ------------------
  |  Branch (73:7): [True: 3, False: 568]
  |  Branch (73:24): [True: 0, False: 3]
  ------------------
   74|      0|      throw Decoding_Error(fmt("GOST-34.10-2012 is not defined for parameters of size {}", p_bits));
   75|      0|   }
   76|       |
   77|    571|   secure_vector<uint8_t> bits;
   78|    571|   BER_Decoder(key_bits).decode(bits, ASN1_Type::OctetString);
   79|       |
   80|    571|   if(bits.size() != 2 * (p_bits / 8)) {
  ------------------
  |  Branch (80:7): [True: 9, False: 562]
  ------------------
   81|      9|      throw Decoding_Error("GOST-34.10-2020 invalid encoding of public key");
   82|      9|   }
   83|       |
   84|    562|   const size_t part_size = bits.size() / 2;
   85|       |
   86|       |   // Keys are stored in little endian format (WTF)
   87|  8.06k|   for(size_t i = 0; i != part_size / 2; ++i) {
  ------------------
  |  Branch (87:22): [True: 7.50k, False: 562]
  ------------------
   88|  7.50k|      std::swap(bits[i], bits[part_size - 1 - i]);
   89|  7.50k|      std::swap(bits[part_size + i], bits[2 * part_size - 1 - i]);
   90|  7.50k|   }
   91|       |
   92|    562|   BigInt x(bits.data(), part_size);
   93|    562|   BigInt y(&bits[part_size], part_size);
   94|       |
   95|    562|   m_public_key = domain().point(x, y);
   96|       |
   97|    562|   BOTAN_ASSERT(m_public_key.on_the_curve(), "Loaded GOST 34.10 public key is on the curve");
  ------------------
  |  |   51|    562|   do {                                                                                 \
  |  |   52|    562|      if(!(expr))                                                                       \
  |  |  ------------------
  |  |  |  Branch (52:10): [True: 189, False: 373]
  |  |  ------------------
  |  |   53|    562|         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \
  |  |   54|    562|   } while(0)
  |  |  ------------------
  |  |  |  Branch (54:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|    562|}
_ZNK5Botan19GOST_3410_PublicKey27create_x509_verification_opERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  286|    275|   const AlgorithmIdentifier& signature_algorithm, std::string_view provider) const {
  287|    275|   if(provider == "base" || provider.empty()) {
  ------------------
  |  Branch (287:7): [True: 0, False: 275]
  |  Branch (287:29): [True: 275, False: 0]
  ------------------
  288|    275|      return std::make_unique<GOST_3410_Verification_Operation>(*this, signature_algorithm);
  289|    275|   }
  290|       |
  291|      0|   throw Provider_Not_Found(algo_name(), provider);
  292|    275|}
gost_3410.cpp:_ZN5Botan12_GLOBAL__N_132GOST_3410_Verification_Operation6verifyEPKhmS3_m:
  237|    274|                                              size_t sig_len) {
  238|    274|   if(sig_len != m_group.get_order_bytes() * 2) {
  ------------------
  |  Branch (238:7): [True: 1, False: 273]
  ------------------
  239|      1|      return false;
  240|      1|   }
  241|       |
  242|    273|   const BigInt s(sig, sig_len / 2);
  243|    273|   const BigInt r(sig + sig_len / 2, sig_len / 2);
  244|       |
  245|    273|   const BigInt& order = m_group.get_order();
  246|       |
  247|    273|   if(r <= 0 || r >= order || s <= 0 || s >= order) {
  ------------------
  |  Branch (247:7): [True: 1, False: 272]
  |  Branch (247:17): [True: 11, False: 261]
  |  Branch (247:31): [True: 1, False: 260]
  |  Branch (247:41): [True: 1, False: 259]
  ------------------
  248|     14|      return false;
  249|     14|   }
  250|       |
  251|    259|   BigInt e = decode_le(msg, msg_len);
  252|    259|   e = m_group.mod_order(e);
  253|    259|   if(e.is_zero()) {
  ------------------
  |  Branch (253:7): [True: 0, False: 259]
  ------------------
  254|      0|      e = BigInt::one();
  255|      0|   }
  256|       |
  257|    259|   const BigInt v = m_group.inverse_mod_order(e);
  258|       |
  259|    259|   const BigInt z1 = m_group.multiply_mod_order(s, v);
  260|    259|   const BigInt z2 = m_group.multiply_mod_order(-r, v);
  261|       |
  262|    259|   const EC_Point R = m_gy_mul.multi_exp(z1, z2);
  263|       |
  264|    259|   if(R.is_zero()) {
  ------------------
  |  Branch (264:7): [True: 0, False: 259]
  ------------------
  265|      0|      return false;
  266|      0|   }
  267|       |
  268|    259|   return (R.get_affine_x() == r);
  269|    259|}
gost_3410.cpp:_ZN5Botan12_GLOBAL__N_19decode_leEPKhm:
  114|    259|BigInt decode_le(const uint8_t msg[], size_t msg_len) {
  115|    259|   secure_vector<uint8_t> msg_le(msg, msg + msg_len);
  116|       |
  117|  4.40k|   for(size_t i = 0; i != msg_le.size() / 2; ++i) {
  ------------------
  |  Branch (117:22): [True: 4.14k, False: 259]
  ------------------
  118|  4.14k|      std::swap(msg_le[i], msg_le[msg_le.size() - 1 - i]);
  119|  4.14k|   }
  120|       |
  121|    259|   return BigInt(msg_le.data(), msg_le.size());
  122|    259|}
gost_3410.cpp:_ZN5Botan12_GLOBAL__N_132GOST_3410_Verification_OperationC2ERKNS_19GOST_3410_PublicKeyERKNS_19AlgorithmIdentifierE:
  225|    275|            m_gy_mul(m_group.get_base_point(), gost.public_point()) {}
gost_3410.cpp:_ZN5Botan12_GLOBAL__N_120gost_hash_from_algidERKNS_19AlgorithmIdentifierE:
  190|    275|std::string gost_hash_from_algid(const AlgorithmIdentifier& alg_id) {
  191|    275|   if(!alg_id.parameters_are_empty()) {
  ------------------
  |  Branch (191:7): [True: 0, False: 275]
  ------------------
  192|      0|      throw Decoding_Error("Unexpected non-empty AlgorithmIdentifier parameters for GOST 34.10 signature");
  193|      0|   }
  194|       |
  195|    275|   const std::string oid_str = alg_id.oid().to_formatted_string();
  196|    275|   if(oid_str == "GOST-34.10/GOST-R-34.11-94") {
  ------------------
  |  Branch (196:7): [True: 123, False: 152]
  ------------------
  197|    123|      return "GOST-R-34.11-94";
  198|    123|   }
  199|    152|   if(oid_str == "GOST-34.10-2012-256/Streebog-256") {
  ------------------
  |  Branch (199:7): [True: 151, False: 1]
  ------------------
  200|    151|      return "Streebog-256";
  201|    151|   }
  202|      1|   if(oid_str == "GOST-34.10-2012-512/Streebog-512") {
  ------------------
  |  Branch (202:7): [True: 0, False: 1]
  ------------------
  203|      0|      return "Streebog-512";
  204|      0|   }
  205|      1|   if(oid_str == "GOST-34.10-2012-256/SHA-256") {
  ------------------
  |  Branch (205:7): [True: 0, False: 1]
  ------------------
  206|      0|      return "SHA-256";
  207|      0|   }
  208|       |
  209|      1|   throw Decoding_Error(fmt("Unknown OID ({}) for GOST 34.10 signatures", alg_id.oid()));
  210|      1|}

_ZN5Botan8PEM_Code18decode_check_labelERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   49|      3|secure_vector<uint8_t> decode_check_label(DataSource& source, std::string_view label_want) {
   50|      3|   std::string label_got;
   51|      3|   secure_vector<uint8_t> ber = decode(source, label_got);
   52|      3|   if(label_got != label_want) {
  ------------------
  |  Branch (52:7): [True: 1, False: 2]
  ------------------
   53|      1|      throw Decoding_Error(fmt("PEM: Label mismatch, wanted '{}' got '{}'", label_want, label_got));
   54|      1|   }
   55|       |
   56|      2|   return ber;
   57|      3|}
_ZN5Botan8PEM_Code6decodeERNS_10DataSourceERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   62|    913|secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   63|    913|   const size_t RANDOM_CHAR_LIMIT = 8;
   64|       |
   65|    913|   label.clear();
   66|       |
   67|    913|   const std::string PEM_HEADER1 = "-----BEGIN ";
   68|    913|   const std::string PEM_HEADER2 = "-----";
   69|    913|   size_t position = 0;
   70|       |
   71|  14.2k|   while(position != PEM_HEADER1.length()) {
  ------------------
  |  Branch (71:10): [True: 13.5k, False: 742]
  ------------------
   72|  13.5k|      uint8_t b;
   73|  13.5k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (73:10): [True: 170, False: 13.3k]
  ------------------
   74|    170|         throw Decoding_Error("PEM: No PEM header found");
   75|    170|      }
   76|  13.3k|      if(static_cast<char>(b) == PEM_HEADER1[position]) {
  ------------------
  |  Branch (76:10): [True: 8.43k, False: 4.93k]
  ------------------
   77|  8.43k|         ++position;
   78|  8.43k|      } else if(position >= RANDOM_CHAR_LIMIT) {
  ------------------
  |  Branch (78:17): [True: 1, False: 4.93k]
  ------------------
   79|      1|         throw Decoding_Error("PEM: Malformed PEM header");
   80|  4.93k|      } else {
   81|  4.93k|         position = 0;
   82|  4.93k|      }
   83|  13.3k|   }
   84|    742|   position = 0;
   85|  58.8k|   while(position != PEM_HEADER2.length()) {
  ------------------
  |  Branch (85:10): [True: 58.1k, False: 710]
  ------------------
   86|  58.1k|      uint8_t b;
   87|  58.1k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (87:10): [True: 28, False: 58.1k]
  ------------------
   88|     28|         throw Decoding_Error("PEM: No PEM header found");
   89|     28|      }
   90|  58.1k|      if(static_cast<char>(b) == PEM_HEADER2[position]) {
  ------------------
  |  Branch (90:10): [True: 3.56k, False: 54.5k]
  ------------------
   91|  3.56k|         ++position;
   92|  54.5k|      } else if(position) {
  ------------------
  |  Branch (92:17): [True: 4, False: 54.5k]
  ------------------
   93|      4|         throw Decoding_Error("PEM: Malformed PEM header");
   94|      4|      }
   95|       |
   96|  58.1k|      if(position == 0) {
  ------------------
  |  Branch (96:10): [True: 54.5k, False: 3.56k]
  ------------------
   97|  54.5k|         label += static_cast<char>(b);
   98|  54.5k|      }
   99|  58.1k|   }
  100|       |
  101|    710|   std::vector<char> b64;
  102|       |
  103|    710|   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
  104|    710|   position = 0;
  105|   653k|   while(position != PEM_TRAILER.length()) {
  ------------------
  |  Branch (105:10): [True: 652k, False: 625]
  ------------------
  106|   652k|      uint8_t b;
  107|   652k|      if(!source.read_byte(b)) {
  ------------------
  |  Branch (107:10): [True: 73, False: 652k]
  ------------------
  108|     73|         throw Decoding_Error("PEM: No PEM trailer found");
  109|     73|      }
  110|   652k|      if(static_cast<char>(b) == PEM_TRAILER[position]) {
  ------------------
  |  Branch (110:10): [True: 23.6k, False: 628k]
  ------------------
  111|  23.6k|         ++position;
  112|   628k|      } else if(position) {
  ------------------
  |  Branch (112:17): [True: 12, False: 628k]
  ------------------
  113|     12|         throw Decoding_Error("PEM: Malformed PEM trailer");
  114|     12|      }
  115|       |
  116|   652k|      if(position == 0) {
  ------------------
  |  Branch (116:10): [True: 628k, False: 23.6k]
  ------------------
  117|   628k|         b64.push_back(b);
  118|   628k|      }
  119|   652k|   }
  120|       |
  121|    625|   return base64_decode(b64.data(), b64.size());
  122|    710|}
_ZN5Botan8PEM_Code7matchesERNS_10DataSourceENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
  137|  10.5k|bool matches(DataSource& source, std::string_view extra, size_t search_range) {
  138|  10.5k|   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
  139|       |
  140|  10.5k|   secure_vector<uint8_t> search_buf(search_range);
  141|  10.5k|   const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);
  142|       |
  143|  10.5k|   if(got < PEM_HEADER.length()) {
  ------------------
  |  Branch (143:7): [True: 474, False: 10.0k]
  ------------------
  144|    474|      return false;
  145|    474|   }
  146|       |
  147|  10.0k|   size_t index = 0;
  148|       |
  149|  4.31M|   for(size_t j = 0; j != got; ++j) {
  ------------------
  |  Branch (149:22): [True: 4.30M, False: 9.96k]
  ------------------
  150|  4.30M|      if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
  ------------------
  |  Branch (150:10): [True: 18.4k, False: 4.28M]
  ------------------
  151|  18.4k|         ++index;
  152|  4.28M|      } else {
  153|  4.28M|         index = 0;
  154|  4.28M|      }
  155|       |
  156|  4.30M|      if(index == PEM_HEADER.size()) {
  ------------------
  |  Branch (156:10): [True: 80, False: 4.30M]
  ------------------
  157|     80|         return true;
  158|     80|      }
  159|  4.30M|   }
  160|       |
  161|  9.96k|   return false;
  162|  10.0k|}

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

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

_ZN5Botan6PK_Ops22Verification_with_HashC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  127|    274|      Verification(), m_hash(create_signature_hash(padding)) {}
_ZN5Botan6PK_Ops22Verification_with_HashC2ERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEb:
  131|    244|                                                       bool allow_null_parameters) {
  132|    244|   const auto oid_info = split_on(alg_id.oid().to_formatted_string(), '/');
  133|       |
  134|    244|   if(oid_info.size() != 2 || oid_info[0] != pk_algo) {
  ------------------
  |  Branch (134:7): [True: 7, False: 237]
  |  Branch (134:31): [True: 41, False: 196]
  ------------------
  135|     48|      throw Decoding_Error(
  136|     48|         fmt("Unexpected AlgorithmIdentifier OID {} in association with {} key", alg_id.oid(), pk_algo));
  137|     48|   }
  138|       |
  139|    196|   if(!alg_id.parameters_are_empty()) {
  ------------------
  |  Branch (139:7): [True: 32, False: 164]
  ------------------
  140|     32|      if(alg_id.parameters_are_null()) {
  ------------------
  |  Branch (140:10): [True: 31, False: 1]
  ------------------
  141|     31|         if(!allow_null_parameters) {
  ------------------
  |  Branch (141:13): [True: 31, False: 0]
  ------------------
  142|     31|            throw Decoding_Error(fmt("Unexpected NULL AlgorithmIdentifier parameters for {}", pk_algo));
  143|     31|         }
  144|     31|      } else {
  145|      1|         throw Decoding_Error(fmt("Unexpected AlgorithmIdentifier parameters for {}", pk_algo));
  146|      1|      }
  147|     32|   }
  148|       |
  149|    164|   m_hash = HashFunction::create_or_throw(oid_info[1]);
  150|    164|}
_ZN5Botan6PK_Ops22Verification_with_Hash6updateEPKhm:
  152|    438|void PK_Ops::Verification_with_Hash::update(const uint8_t msg[], size_t msg_len) {
  153|    438|   m_hash->update(msg, msg_len);
  154|    438|}
_ZN5Botan6PK_Ops22Verification_with_Hash18is_valid_signatureEPKhm:
  156|    410|bool PK_Ops::Verification_with_Hash::is_valid_signature(const uint8_t sig[], size_t sig_len) {
  157|    410|   const secure_vector<uint8_t> msg = m_hash->final();
  158|    410|   return verify(msg.data(), msg.size(), sig, sig_len);
  159|    410|}
pk_ops.cpp:_ZN5Botan12_GLOBAL__N_121create_signature_hashENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   72|    274|std::unique_ptr<HashFunction> create_signature_hash(std::string_view padding) {
   73|    274|   if(auto hash = HashFunction::create(padding)) {
  ------------------
  |  Branch (73:12): [True: 274, False: 0]
  ------------------
   74|    274|      return hash;
   75|    274|   }
   76|       |
   77|      0|   SCAN_Name req(padding);
   78|       |
   79|      0|   if(req.algo_name() == "EMSA1" && req.arg_count() == 1) {
  ------------------
  |  Branch (79:7): [True: 0, False: 0]
  |  Branch (79:37): [True: 0, False: 0]
  ------------------
   80|      0|      if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (80:15): [True: 0, False: 0]
  ------------------
   81|      0|         return hash;
   82|      0|      }
   83|      0|   }
   84|       |
   85|      0|#if defined(BOTAN_HAS_RAW_HASH_FN)
   86|      0|   if(req.algo_name() == "Raw") {
  ------------------
  |  Branch (86:7): [True: 0, False: 0]
  ------------------
   87|      0|      if(req.arg_count() == 0) {
  ------------------
  |  Branch (87:10): [True: 0, False: 0]
  ------------------
   88|      0|         return std::make_unique<RawHashFunction>("Raw", 0);
   89|      0|      }
   90|       |
   91|      0|      if(req.arg_count() == 1) {
  ------------------
  |  Branch (91:10): [True: 0, False: 0]
  ------------------
   92|      0|         if(auto hash = HashFunction::create(req.arg(0))) {
  ------------------
  |  Branch (92:18): [True: 0, False: 0]
  ------------------
   93|      0|            return std::make_unique<RawHashFunction>(std::move(hash));
   94|      0|         }
   95|      0|      }
   96|      0|   }
   97|      0|#endif
   98|       |
   99|      0|   throw Algorithm_Not_Found(padding);
  100|      0|}

_ZN5Botan11PK_VerifierC2ERKNS_10Public_KeyERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  341|  2.04k|                         std::string_view provider) {
  342|  2.04k|   m_op = key.create_x509_verification_op(signature_algorithm, provider);
  343|       |
  344|  2.04k|   if(!m_op) {
  ------------------
  |  Branch (344:7): [True: 0, False: 2.04k]
  ------------------
  345|      0|      throw Invalid_Argument(fmt("Key type {} does not support X.509 signature verification", key.algo_name()));
  346|      0|   }
  347|       |
  348|  2.04k|   m_sig_format = key.default_x509_signature_format();
  349|  2.04k|   m_parts = key.message_parts();
  350|  2.04k|   m_part_size = key.message_part_size();
  351|  2.04k|   check_der_format_supported(m_sig_format, m_parts);
  352|  2.04k|}
_ZN5Botan11PK_VerifierD2Ev:
  354|  1.73k|PK_Verifier::~PK_Verifier() = default;
_ZNK5Botan11PK_Verifier13hash_functionEv:
  359|     22|std::string PK_Verifier::hash_function() const {
  360|     22|   return m_op->hash_function();
  361|     22|}
_ZN5Botan11PK_Verifier14verify_messageEPKhmS2_m:
  368|  1.73k|bool PK_Verifier::verify_message(const uint8_t msg[], size_t msg_length, const uint8_t sig[], size_t sig_length) {
  369|  1.73k|   update(msg, msg_length);
  370|  1.73k|   return check_signature(sig, sig_length);
  371|  1.73k|}
_ZN5Botan11PK_Verifier6updateEPKhm:
  377|  1.73k|void PK_Verifier::update(const uint8_t in[], size_t length) {
  378|  1.73k|   m_op->update(in, length);
  379|  1.73k|}
_ZN5Botan11PK_Verifier15check_signatureEPKhm:
  413|  1.73k|bool PK_Verifier::check_signature(const uint8_t sig[], size_t length) {
  414|  1.73k|   try {
  415|  1.73k|      if(m_sig_format == Signature_Format::Standard) {
  ------------------
  |  Branch (415:10): [True: 1.56k, False: 164]
  ------------------
  416|  1.56k|         return m_op->is_valid_signature(sig, length);
  417|  1.56k|      } else if(m_sig_format == Signature_Format::DerSequence) {
  ------------------
  |  Branch (417:17): [True: 164, False: 0]
  ------------------
  418|    164|         bool decoding_success = false;
  419|    164|         std::vector<uint8_t> real_sig;
  420|       |
  421|    164|         try {
  422|    164|            real_sig = decode_der_signature(sig, length, m_parts, m_part_size);
  423|    164|            decoding_success = true;
  424|    164|         } catch(Decoding_Error&) {}
  425|       |
  426|    164|         bool accept = m_op->is_valid_signature(real_sig.data(), real_sig.size());
  427|       |
  428|    136|         return accept && decoding_success;
  ------------------
  |  Branch (428:17): [True: 0, False: 136]
  |  Branch (428:27): [True: 0, False: 0]
  ------------------
  429|    164|      } else {
  430|      0|         throw Internal_Error("PK_Verifier: Invalid signature format enum");
  431|      0|      }
  432|  1.73k|   } catch(Invalid_Argument&) {
  433|      0|      return false;
  434|     35|   } catch(Decoding_Error&) {
  435|     35|      return false;
  436|     35|   } catch(Encoding_Error&) {
  437|     28|      return false;
  438|     28|   }
  439|  1.73k|}
pubkey.cpp:_ZN5Botan12_GLOBAL__N_126check_der_format_supportedENS_16Signature_FormatEm:
  238|  1.73k|void check_der_format_supported(Signature_Format format, size_t parts) {
  239|  1.73k|   if(format != Signature_Format::Standard && parts == 1) {
  ------------------
  |  Branch (239:7): [True: 164, False: 1.56k]
  |  Branch (239:47): [True: 0, False: 164]
  ------------------
  240|      0|      throw Invalid_Argument("This algorithm does not support DER encoding");
  241|      0|   }
  242|  1.73k|}
pubkey.cpp:_ZN5Botan12_GLOBAL__N_120der_encode_signatureERKNSt3__16vectorIhNS1_9allocatorIhEEEEmm:
  284|     71|std::vector<uint8_t> der_encode_signature(const std::vector<uint8_t>& sig, size_t parts, size_t part_size) {
  285|     71|   if(sig.size() % parts != 0 || sig.size() != parts * part_size) {
  ------------------
  |  Branch (285:7): [True: 0, False: 71]
  |  Branch (285:34): [True: 0, False: 71]
  ------------------
  286|      0|      throw Encoding_Error("Unexpected size for DER signature");
  287|      0|   }
  288|       |
  289|     71|   std::vector<BigInt> sig_parts(parts);
  290|    213|   for(size_t i = 0; i != sig_parts.size(); ++i) {
  ------------------
  |  Branch (290:22): [True: 142, False: 71]
  ------------------
  291|    142|      sig_parts[i].binary_decode(&sig[part_size * i], part_size);
  292|    142|   }
  293|       |
  294|     71|   std::vector<uint8_t> output;
  295|     71|   DER_Encoder(output).start_sequence().encode_list(sig_parts).end_cons();
  296|     71|   return output;
  297|     71|}
pubkey.cpp:_ZN5Botan12_GLOBAL__N_120decode_der_signatureEPKhmmm:
  383|    164|std::vector<uint8_t> decode_der_signature(const uint8_t sig[], size_t length, size_t sig_parts, size_t sig_part_size) {
  384|    164|   std::vector<uint8_t> real_sig;
  385|    164|   BER_Decoder decoder(sig, length);
  386|    164|   BER_Decoder ber_sig = decoder.start_sequence();
  387|       |
  388|    164|   BOTAN_ASSERT_NOMSG(sig_parts != 0 && sig_part_size != 0);
  ------------------
  |  |   60|    164|   do {                                                                     \
  |  |   61|    317|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:12): [True: 153, False: 11]
  |  |  |  Branch (61:12): [True: 153, False: 0]
  |  |  ------------------
  |  |   62|    164|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|    164|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  389|       |
  390|    164|   size_t count = 0;
  391|       |
  392|    732|   while(ber_sig.more_items()) {
  ------------------
  |  Branch (392:10): [True: 568, False: 164]
  ------------------
  393|    568|      BigInt sig_part;
  394|    568|      ber_sig.decode(sig_part);
  395|    568|      real_sig += BigInt::encode_1363(sig_part, sig_part_size);
  396|    568|      ++count;
  397|    568|   }
  398|       |
  399|    164|   if(count != sig_parts) {
  ------------------
  |  Branch (399:7): [True: 9, False: 155]
  ------------------
  400|      9|      throw Decoding_Error("PK_Verifier: signature size invalid");
  401|      9|   }
  402|       |
  403|    155|   const std::vector<uint8_t> reencoded = der_encode_signature(real_sig, sig_parts, sig_part_size);
  404|       |
  405|    155|   if(reencoded.size() != length || CT::is_equal(reencoded.data(), sig, reencoded.size()).as_bool() == false) {
  ------------------
  |  Branch (405:7): [True: 96, False: 59]
  |  Branch (405:7): [True: 15, False: 140]
  |  Branch (405:37): [True: 3, False: 56]
  ------------------
  406|     15|      throw Decoding_Error("PK_Verifier: signature is not the canonical DER encoding");
  407|     15|   }
  408|    140|   return real_sig;
  409|    155|}

_ZNK5Botan13RSA_PublicKey11public_dataEv:
  118|  1.48k|std::shared_ptr<const RSA_Public_Data> RSA_PublicKey::public_data() const {
  119|  1.48k|   return m_public;
  120|  1.48k|}
_ZN5Botan13RSA_PublicKey4initEONS_6BigIntES2_:
  144|  1.56k|void RSA_PublicKey::init(BigInt&& n, BigInt&& e) {
  145|  1.56k|   if(n.is_negative() || n.is_even() || n.bits() < 5 /* n >= 3*5 */ || e.is_negative() || e.is_even()) {
  ------------------
  |  Branch (145:7): [True: 5, False: 1.55k]
  |  Branch (145:26): [True: 8, False: 1.55k]
  |  Branch (145:41): [True: 4, False: 1.54k]
  |  Branch (145:72): [True: 5, False: 1.54k]
  |  Branch (145:91): [True: 8, False: 1.53k]
  ------------------
  146|     30|      throw Decoding_Error("Invalid RSA public key parameters");
  147|     30|   }
  148|  1.53k|   m_public = std::make_shared<RSA_Public_Data>(std::move(n), std::move(e));
  149|  1.53k|}
_ZN5Botan13RSA_PublicKeyC1ERKNS_19AlgorithmIdentifierENSt3__14spanIKhLm18446744073709551615EEE:
  151|  1.70k|RSA_PublicKey::RSA_PublicKey(const AlgorithmIdentifier& /*unused*/, std::span<const uint8_t> key_bits) {
  152|  1.70k|   BigInt n, e;
  153|  1.70k|   BER_Decoder(key_bits).start_sequence().decode(n).decode(e).end_cons();
  154|       |
  155|  1.70k|   init(std::move(n), std::move(e));
  156|  1.70k|}
_ZNK5Botan13RSA_PublicKey10key_lengthEv:
  169|    214|size_t RSA_PublicKey::key_length() const {
  170|    214|   return m_public->public_modulus_bits();
  171|    214|}
_ZNK5Botan13RSA_PublicKey18estimated_strengthEv:
  173|    214|size_t RSA_PublicKey::estimated_strength() const {
  174|    214|   return if_work_factor(key_length());
  175|    214|}
_ZNK5Botan13RSA_PublicKey27create_x509_verification_opERKNS_19AlgorithmIdentifierENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  791|  1.52k|                                                                                 std::string_view provider) const {
  792|  1.52k|   if(provider == "base" || provider.empty()) {
  ------------------
  |  Branch (792:7): [True: 0, False: 1.52k]
  |  Branch (792:29): [True: 1.52k, False: 0]
  ------------------
  793|  1.52k|      return std::make_unique<RSA_Verify_Operation>(*this, parse_rsa_signature_algorithm(alg_id));
  794|  1.52k|   }
  795|       |
  796|      0|   throw Provider_Not_Found(algo_name(), provider);
  797|  1.52k|}
_ZNK5Botan15RSA_Public_Data5get_nEv:
   46|  1.27k|      const BigInt& get_n() const { return m_n; }
_ZNK5Botan15RSA_Public_Data19public_modulus_bitsEv:
   50|  1.47k|      size_t public_modulus_bits() const { return m_public_modulus_bits; }
rsa.cpp:_ZN5Botan12_GLOBAL__N_129parse_rsa_signature_algorithmERKNS_19AlgorithmIdentifierE:
  742|  1.52k|std::string parse_rsa_signature_algorithm(const AlgorithmIdentifier& alg_id) {
  743|  1.52k|   const auto sig_info = split_on(alg_id.oid().to_formatted_string(), '/');
  744|       |
  745|  1.52k|   if(sig_info.empty() || sig_info.size() != 2 || sig_info[0] != "RSA") {
  ------------------
  |  Branch (745:7): [True: 0, False: 1.52k]
  |  Branch (745:27): [True: 21, False: 1.50k]
  |  Branch (745:51): [True: 0, False: 1.50k]
  ------------------
  746|     21|      throw Decoding_Error("Unknown AlgorithmIdentifier for RSA X.509 signatures");
  747|     21|   }
  748|       |
  749|  1.50k|   std::string padding = sig_info[1];
  750|       |
  751|  1.50k|   if(padding == "EMSA4") {
  ------------------
  |  Branch (751:7): [True: 71, False: 1.43k]
  ------------------
  752|       |      // "MUST contain RSASSA-PSS-params"
  753|     71|      if(alg_id.parameters().empty()) {
  ------------------
  |  Branch (753:10): [True: 0, False: 71]
  ------------------
  754|      0|         throw Decoding_Error("PSS params must be provided");
  755|      0|      }
  756|       |
  757|     71|      PSS_Params pss_params(alg_id.parameters());
  758|       |
  759|       |      // hash_algo must be SHA1, SHA2-224, SHA2-256, SHA2-384 or SHA2-512
  760|     71|      const std::string hash_algo = pss_params.hash_function();
  761|     71|      if(hash_algo != "SHA-1" && hash_algo != "SHA-224" && hash_algo != "SHA-256" && hash_algo != "SHA-384" &&
  ------------------
  |  Branch (761:10): [True: 60, False: 11]
  |  Branch (761:34): [True: 60, False: 0]
  |  Branch (761:60): [True: 2, False: 58]
  |  Branch (761:86): [True: 2, False: 0]
  ------------------
  762|     71|         hash_algo != "SHA-512") {
  ------------------
  |  Branch (762:10): [True: 2, False: 0]
  ------------------
  763|      2|         throw Decoding_Error("Unacceptable hash for PSS signatures");
  764|      2|      }
  765|       |
  766|     69|      if(pss_params.mgf_function() != "MGF1") {
  ------------------
  |  Branch (766:10): [True: 1, False: 68]
  ------------------
  767|      1|         throw Decoding_Error("Unacceptable MGF for PSS signatures");
  768|      1|      }
  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|     68|      if(pss_params.hash_algid() != pss_params.mgf_hash_algid()) {
  ------------------
  |  Branch (774:10): [True: 1, False: 67]
  ------------------
  775|      1|         throw Decoding_Error("Unacceptable MGF hash for PSS signatures");
  776|      1|      }
  777|       |
  778|     67|      if(pss_params.trailer_field() != 1) {
  ------------------
  |  Branch (778:10): [True: 0, False: 67]
  ------------------
  779|      0|         throw Decoding_Error("Unacceptable trailer field for PSS signatures");
  780|      0|      }
  781|       |
  782|     67|      padding += fmt("({},MGF1,{})", hash_algo, pss_params.salt_length());
  783|     67|   }
  784|       |
  785|  1.49k|   return padding;
  786|  1.50k|}
_ZN5Botan15RSA_Public_DataC2EONS_6BigIntES2_:
   38|  1.53k|            m_public_modulus_bytes(m_n.bytes()) {}
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Public_OperationC2ERKNS_13RSA_PublicKeyE:
  623|  1.48k|      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.29k|      size_t public_modulus_bytes() const { return m_public->public_modulus_bytes(); }
_ZNK5Botan15RSA_Public_Data20public_modulus_bytesEv:
   52|  1.29k|      size_t public_modulus_bytes() const { return m_public_modulus_bytes; }
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Public_Operation19public_modulus_bitsEv:
  625|  1.25k|      size_t public_modulus_bits() const { return m_public->public_modulus_bits(); }
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Public_Operation9public_opERKNS_6BigIntE:
  628|  1.27k|      BigInt public_op(const BigInt& m) const {
  629|  1.27k|         if(m >= m_public->get_n()) {
  ------------------
  |  Branch (629:13): [True: 16, False: 1.25k]
  ------------------
  630|     16|            throw Decoding_Error("RSA public op - input is too large");
  631|     16|         }
  632|       |
  633|  1.25k|         return m_public->public_op(m);
  634|  1.27k|      }
_ZNK5Botan15RSA_Public_Data9public_opERKNS_6BigIntE:
   40|  1.25k|      BigInt public_op(const BigInt& m) const {
   41|  1.25k|         const size_t powm_window = 1;
   42|  1.25k|         auto powm_m_n = monty_precompute(m_monty_n, m, powm_window, false);
   43|  1.25k|         return monty_execute_vartime(*powm_m_n, m_e);
   44|  1.25k|      }
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_OperationC2ERKNS_13RSA_PublicKeyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  674|  1.48k|            RSA_Public_Operation(rsa), m_emsa(EMSA::create_or_throw(padding)) {}
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_Operation6updateEPKhm:
  665|  1.29k|      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.29k|      bool is_valid_signature(const uint8_t sig[], size_t sig_len) override {
  668|  1.29k|         const auto msg = m_emsa->raw_data();
  669|  1.29k|         const auto message_repr = recover_message_repr(sig, sig_len);
  670|  1.29k|         return m_emsa->verify(message_repr, msg, public_modulus_bits() - 1);
  671|  1.29k|      }
rsa.cpp:_ZN5Botan12_GLOBAL__N_120RSA_Verify_Operation20recover_message_reprEPKhm:
  679|  1.29k|      std::vector<uint8_t> recover_message_repr(const uint8_t input[], size_t input_len) {
  680|  1.29k|         if(input_len > public_modulus_bytes()) {
  ------------------
  |  Branch (680:13): [True: 19, False: 1.27k]
  ------------------
  681|     19|            throw Decoding_Error("RSA signature too large to be valid for this key");
  682|     19|         }
  683|  1.27k|         BigInt input_bn(input, input_len);
  684|  1.27k|         return BigInt::encode(public_op(input_bn));
  685|  1.29k|      }
rsa.cpp:_ZNK5Botan12_GLOBAL__N_120RSA_Verify_Operation13hash_functionEv:
  676|     14|      std::string hash_function() const override { return m_emsa->hash_function(); }

_ZN5Botan15ecp_work_factorEm:
   14|     64|size_t ecp_work_factor(size_t bits) {
   15|     64|   return bits / 2;
   16|     64|}
_ZN5Botan14if_work_factorEm:
   36|    269|size_t if_work_factor(size_t bits) {
   37|    269|   if(bits < 512) {
  ------------------
  |  Branch (37:7): [True: 123, False: 146]
  ------------------
   38|    123|      return 0;
   39|    123|   }
   40|       |
   41|       |   // RFC 3766 estimates k at .02 and o(1) to be effectively zero for sizes of interest
   42|       |
   43|    146|   const double log2_k = -5.6438;  // log2(.02)
   44|    146|   return nfs_workfactor(bits, log2_k);
   45|    269|}
_ZN5Botan14dl_work_factorEm:
   47|     55|size_t dl_work_factor(size_t bits) {
   48|       |   // Lacking better estimates...
   49|     55|   return if_work_factor(bits);
   50|     55|}
_ZN5Botan16dl_exponent_sizeEm:
   52|     55|size_t dl_exponent_size(size_t bits) {
   53|     55|   if(bits == 0) {
  ------------------
  |  Branch (53:7): [True: 0, False: 55]
  ------------------
   54|      0|      return 0;
   55|      0|   }
   56|     55|   if(bits <= 256) {
  ------------------
  |  Branch (56:7): [True: 10, False: 45]
  ------------------
   57|     10|      return bits - 1;
   58|     10|   }
   59|     45|   if(bits <= 1024) {
  ------------------
  |  Branch (59:7): [True: 28, False: 17]
  ------------------
   60|     28|      return 192;
   61|     28|   }
   62|     17|   if(bits <= 1536) {
  ------------------
  |  Branch (62:7): [True: 17, False: 0]
  ------------------
   63|     17|      return 224;
   64|     17|   }
   65|      0|   if(bits <= 2048) {
  ------------------
  |  Branch (65:7): [True: 0, False: 0]
  ------------------
   66|      0|      return 256;
   67|      0|   }
   68|      0|   if(bits <= 4096) {
  ------------------
  |  Branch (68:7): [True: 0, False: 0]
  ------------------
   69|      0|      return 384;
   70|      0|   }
   71|      0|   return 512;
   72|      0|}
workfactor.cpp:_ZN5Botan12_GLOBAL__N_114nfs_workfactorEmd:
   20|    146|size_t nfs_workfactor(size_t bits, double log2_k) {
   21|       |   // approximates natural logarithm of an integer of given bitsize
   22|    146|   const double log2_e = 1.44269504088896340736;
   23|    146|   const double log_p = bits / log2_e;
   24|       |
   25|    146|   const double log_log_p = std::log(log_p);
   26|       |
   27|       |   // RFC 3766: k * e^((1.92 + o(1)) * cubrt(ln(n) * (ln(ln(n)))^2))
   28|    146|   const double est = 1.92 * std::pow(log_p * log_log_p * log_log_p, 1.0 / 3.0);
   29|       |
   30|       |   // return log2 of the workfactor
   31|    146|   return static_cast<size_t>(log2_k + log2_e * est);
   32|    146|}

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

_ZN5Botan15allocate_memoryEmm:
   20|  6.55M|BOTAN_MALLOC_FN void* allocate_memory(size_t elems, size_t elem_size) {
   21|  6.55M|   if(elems == 0 || elem_size == 0) {
  ------------------
  |  Branch (21:7): [True: 0, False: 6.55M]
  |  Branch (21:21): [True: 0, False: 6.55M]
  ------------------
   22|      0|      return nullptr;
   23|      0|   }
   24|       |
   25|       |   // Some calloc implementations do not check for overflow (?!?)
   26|       |
   27|  6.55M|   if(!BOTAN_CHECKED_MUL(elems, elem_size).has_value()) {
  ------------------
  |  |   74|  6.55M|#define BOTAN_CHECKED_MUL(x, y) checked_mul(x, y)
  ------------------
  |  Branch (27:7): [True: 0, False: 6.55M]
  ------------------
   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|  6.55M|   void* ptr = std::calloc(elems, elem_size);  // NOLINT(*-no-malloc)
   41|  6.55M|#endif
   42|  6.55M|   if(!ptr) {
  ------------------
  |  Branch (42:7): [True: 0, False: 6.55M]
  ------------------
   43|      0|      [[unlikely]] throw std::bad_alloc();
   44|      0|   }
   45|  6.55M|   return ptr;
   46|  6.55M|}
_ZN5Botan17deallocate_memoryEPvmm:
   48|  6.55M|void deallocate_memory(void* p, size_t elems, size_t elem_size) {
   49|  6.55M|   if(p == nullptr) {
  ------------------
  |  Branch (49:7): [True: 0, False: 6.55M]
  ------------------
   50|      0|      [[unlikely]] return;
   51|      0|   }
   52|       |
   53|  6.55M|   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|  6.55M|   std::free(p);  // NOLINT(*-no-malloc)
   62|  6.55M|}
_ZN5Botan20initialize_allocatorEv:
   64|      1|void initialize_allocator() {
   65|       |#if defined(BOTAN_HAS_LOCKING_ALLOCATOR)
   66|       |   mlock_allocator::instance();
   67|       |#endif
   68|      1|}

_ZN5Botan22throw_invalid_argumentEPKcS1_S1_:
   21|    108|void throw_invalid_argument(const char* message, const char* func, const char* file) {
   22|    108|   throw Invalid_Argument(fmt("{} in {}:{}", message, func, file));
   23|    108|}
_ZN5Botan17assertion_failureEPKcS1_S1_S1_i:
   29|    189|void assertion_failure(const char* expr_str, const char* assertion_made, const char* func, const char* file, int line) {
   30|    189|   std::ostringstream format;
   31|       |
   32|    189|   format << "False assertion ";
   33|       |
   34|    189|   if(assertion_made && assertion_made[0] != 0) {
  ------------------
  |  Branch (34:7): [True: 189, False: 0]
  |  Branch (34:25): [True: 189, False: 0]
  ------------------
   35|    189|      format << "'" << assertion_made << "' (expression " << expr_str << ") ";
   36|    189|   } else {
   37|      0|      format << expr_str << " ";
   38|      0|   }
   39|       |
   40|    189|   if(func) {
  ------------------
  |  Branch (40:7): [True: 189, False: 0]
  ------------------
   41|    189|      format << "in " << func << " ";
   42|    189|   }
   43|       |
   44|    189|   format << "@" << file << ":" << line;
   45|       |
   46|       |#if defined(BOTAN_TERMINATE_ON_ASSERTS)
   47|       |   std::cerr << format.str() << '\n';
   48|       |   std::abort();
   49|       |#else
   50|    189|   throw Internal_Error(format.str());
   51|    189|#endif
   52|    189|}

_ZN5Botan14calendar_pointC2ERKNSt3__16chrono10time_pointINS2_12system_clockENS2_8durationIxNS1_5ratioILl1ELl1000000EEEEEEE:
  100|    510|calendar_point::calendar_point(const std::chrono::system_clock::time_point& time_point) {
  101|    510|   std::tm tm = do_gmtime(std::chrono::system_clock::to_time_t(time_point));
  102|       |
  103|    510|   m_year = tm.tm_year + 1900;
  104|    510|   m_month = tm.tm_mon + 1;
  105|    510|   m_day = tm.tm_mday;
  106|    510|   m_hour = tm.tm_hour;
  107|    510|   m_minutes = tm.tm_min;
  108|    510|   m_seconds = tm.tm_sec;
  109|    510|}
calendar.cpp:_ZN5Botan12_GLOBAL__N_19do_gmtimeEl:
   20|    510|std::tm do_gmtime(std::time_t time_val) {
   21|    510|   std::tm tm;
   22|       |
   23|       |#if defined(BOTAN_TARGET_OS_HAS_WIN32)
   24|       |   ::gmtime_s(&tm, &time_val);  // Windows
   25|       |#elif defined(BOTAN_TARGET_OS_HAS_POSIX1)
   26|    510|   ::gmtime_r(&time_val, &tm);  // Unix/SUSv2
   27|       |#else
   28|       |   std::tm* tm_p = std::gmtime(&time_val);
   29|       |   if(tm_p == nullptr)
   30|       |      throw Encoding_Error("time_t_to_tm could not convert");
   31|       |   tm = *tm_p;
   32|       |#endif
   33|       |
   34|    510|   return tm;
   35|    510|}

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

_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|  5.77M|size_t DataSource::read_byte(uint8_t& out) {
   27|  5.77M|   return read(&out, 1);
   28|  5.77M|}
_ZNK5Botan10DataSource9peek_byteERh:
   33|  13.9k|size_t DataSource::peek_byte(uint8_t& out) const {
   34|  13.9k|   return peek(&out, 1, 0);
   35|  13.9k|}
_ZN5Botan10DataSource12discard_nextEm:
   40|  65.2k|size_t DataSource::discard_next(size_t n) {
   41|  65.2k|   uint8_t buf[64] = {0};
   42|  65.2k|   size_t discarded = 0;
   43|       |
   44|   177k|   while(n) {
  ------------------
  |  Branch (44:10): [True: 112k, False: 64.9k]
  ------------------
   45|   112k|      const size_t got = this->read(buf, std::min(n, sizeof(buf)));
   46|   112k|      discarded += got;
   47|   112k|      n -= got;
   48|       |
   49|   112k|      if(got == 0) {
  ------------------
  |  Branch (49:10): [True: 222, False: 111k]
  ------------------
   50|    222|         break;
   51|    222|      }
   52|   112k|   }
   53|       |
   54|  65.2k|   return discarded;
   55|  65.2k|}
_ZN5Botan17DataSource_Memory4readEPhm:
   60|  1.32M|size_t DataSource_Memory::read(uint8_t out[], size_t length) {
   61|  1.32M|   const size_t got = std::min<size_t>(m_source.size() - m_offset, length);
   62|  1.32M|   copy_mem(out, m_source.data() + m_offset, got);
   63|  1.32M|   m_offset += got;
   64|  1.32M|   return got;
   65|  1.32M|}
_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|  43.7k|size_t DataSource_Memory::peek(uint8_t out[], size_t length, size_t peek_offset) const {
   75|  43.7k|   const size_t bytes_left = m_source.size() - m_offset;
   76|  43.7k|   if(peek_offset >= bytes_left) {
  ------------------
  |  Branch (76:7): [True: 12.1k, False: 31.6k]
  ------------------
   77|  12.1k|      return 0;
   78|  12.1k|   }
   79|       |
   80|  31.6k|   const size_t got = std::min(bytes_left - peek_offset, length);
   81|  31.6k|   copy_mem(out, &m_source[m_offset + peek_offset], got);
   82|  31.6k|   return got;
   83|  43.7k|}
_ZNK5Botan17DataSource_Memory11end_of_dataEv:
   88|  45.2k|bool DataSource_Memory::end_of_data() const {
   89|  45.2k|   return (m_offset == m_source.size());
   90|  45.2k|}

_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   71|  9.15k|Exception::Exception(std::string_view msg) : m_msg(msg) {}
_ZN5Botan9ExceptionC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
   73|  4.34k|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|  3.67k|Exception::Exception(const char* prefix, std::string_view msg) : m_msg(fmt("{} {}", prefix, msg)) {}
_ZN5Botan16Invalid_ArgumentC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   77|    499|Invalid_Argument::Invalid_Argument(std::string_view msg) : Exception(msg) {}
_ZN5Botan14Internal_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   99|    195|Internal_Error::Internal_Error(std::string_view err) : Exception("Internal error:", err) {}
_ZN5Botan19Algorithm_Not_FoundC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  115|    194|      Lookup_Error(fmt("Could not find any algorithm named '{}'", name)) {}
_ZN5Botan14Encoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  123|    876|Encoding_Error::Encoding_Error(std::string_view name) : Exception("Encoding error:", name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  125|  8.44k|Decoding_Error::Decoding_Error(std::string_view name) : Exception(name) {}
_ZN5Botan14Decoding_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKSt9exception:
  130|  4.34k|Decoding_Error::Decoding_Error(std::string_view msg, const std::exception& e) : Exception(msg, e) {}
_ZN5Botan15Stream_IO_ErrorC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  135|  2.60k|Stream_IO_Error::Stream_IO_Error(std::string_view err) : Exception("I/O error:", err) {}

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

_ZN5Botan9SCAN_NameC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   58|  1.48k|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.48k|   if(algo_spec.empty()) {
  ------------------
  |  Branch (59:7): [True: 0, False: 1.48k]
  ------------------
   60|      0|      throw Invalid_Argument("Expected algorithm name, got empty string");
   61|      0|   }
   62|       |
   63|  1.48k|   std::vector<std::pair<size_t, std::string>> name;
   64|  1.48k|   size_t level = 0;
   65|  1.48k|   std::pair<size_t, std::string> accum = std::make_pair(level, "");
   66|       |
   67|  1.48k|   const std::string decoding_error = "Bad SCAN name '" + m_orig_algo_spec + "': ";
   68|       |
   69|  20.9k|   for(char c : algo_spec) {
  ------------------
  |  Branch (69:15): [True: 20.9k, False: 1.48k]
  ------------------
   70|  20.9k|      if(c == '/' || c == ',' || c == '(' || c == ')') {
  ------------------
  |  Branch (70:10): [True: 0, False: 20.9k]
  |  Branch (70:22): [True: 112, False: 20.8k]
  |  Branch (70:34): [True: 1.29k, False: 19.5k]
  |  Branch (70:46): [True: 1.29k, False: 18.2k]
  ------------------
   71|  2.69k|         if(c == '(') {
  ------------------
  |  Branch (71:13): [True: 1.29k, False: 1.40k]
  ------------------
   72|  1.29k|            ++level;
   73|  1.40k|         } else if(c == ')') {
  ------------------
  |  Branch (73:20): [True: 1.29k, False: 112]
  ------------------
   74|  1.29k|            if(level == 0) {
  ------------------
  |  Branch (74:16): [True: 0, False: 1.29k]
  ------------------
   75|      0|               throw Decoding_Error(decoding_error + "Mismatched parens");
   76|      0|            }
   77|  1.29k|            --level;
   78|  1.29k|         }
   79|       |
   80|  2.69k|         if(c == '/' && level > 0) {
  ------------------
  |  Branch (80:13): [True: 0, False: 2.69k]
  |  Branch (80:25): [True: 0, False: 0]
  ------------------
   81|      0|            accum.second.push_back(c);
   82|  2.69k|         } else {
   83|  2.69k|            if(!accum.second.empty()) {
  ------------------
  |  Branch (83:16): [True: 2.69k, False: 0]
  ------------------
   84|  2.69k|               name.push_back(accum);
   85|  2.69k|            }
   86|  2.69k|            accum = std::make_pair(level, "");
   87|  2.69k|         }
   88|  18.2k|      } else {
   89|  18.2k|         accum.second.push_back(c);
   90|  18.2k|      }
   91|  20.9k|   }
   92|       |
   93|  1.48k|   if(!accum.second.empty()) {
  ------------------
  |  Branch (93:7): [True: 194, False: 1.29k]
  ------------------
   94|    194|      name.push_back(accum);
   95|    194|   }
   96|       |
   97|  1.48k|   if(level != 0) {
  ------------------
  |  Branch (97:7): [True: 0, False: 1.48k]
  ------------------
   98|      0|      throw Decoding_Error(decoding_error + "Missing close paren");
   99|      0|   }
  100|       |
  101|  1.48k|   if(name.empty()) {
  ------------------
  |  Branch (101:7): [True: 0, False: 1.48k]
  ------------------
  102|      0|      throw Decoding_Error(decoding_error + "Empty name");
  103|      0|   }
  104|       |
  105|  1.48k|   m_alg_name = name[0].second;
  106|       |
  107|  1.48k|   bool in_modes = false;
  108|       |
  109|  2.89k|   for(size_t i = 1; i != name.size(); ++i) {
  ------------------
  |  Branch (109:22): [True: 1.40k, False: 1.48k]
  ------------------
  110|  1.40k|      if(name[i].first == 0) {
  ------------------
  |  Branch (110:10): [True: 0, False: 1.40k]
  ------------------
  111|      0|         m_mode_info.push_back(make_arg(name, i));
  112|      0|         in_modes = true;
  113|  1.40k|      } else if(name[i].first == 1 && !in_modes) {
  ------------------
  |  Branch (113:17): [True: 1.40k, False: 0]
  |  Branch (113:39): [True: 1.40k, False: 0]
  ------------------
  114|  1.40k|         m_args.push_back(make_arg(name, i));
  115|  1.40k|      }
  116|  1.40k|   }
  117|  1.48k|}
_ZNK5Botan9SCAN_Name3argEm:
  119|  2.52k|std::string SCAN_Name::arg(size_t i) const {
  120|  2.52k|   if(i >= arg_count()) {
  ------------------
  |  Branch (120:7): [True: 0, False: 2.52k]
  ------------------
  121|      0|      throw Invalid_Argument("SCAN_Name::arg " + std::to_string(i) + " out of range for '" + to_string() + "'");
  122|      0|   }
  123|  2.52k|   return m_args[i];
  124|  2.52k|}
_ZNK5Botan9SCAN_Name3argEmNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  126|     56|std::string SCAN_Name::arg(size_t i, std::string_view def_value) const {
  127|     56|   if(i >= arg_count()) {
  ------------------
  |  Branch (127:7): [True: 0, False: 56]
  ------------------
  128|      0|      return std::string(def_value);
  129|      0|   }
  130|     56|   return m_args[i];
  131|     56|}
_ZNK5Botan9SCAN_Name14arg_as_integerEmm:
  133|     56|size_t SCAN_Name::arg_as_integer(size_t i, size_t def_value) const {
  134|     56|   if(i >= arg_count()) {
  ------------------
  |  Branch (134:7): [True: 0, False: 56]
  ------------------
  135|      0|      return def_value;
  136|      0|   }
  137|     56|   return to_u32bit(m_args[i]);
  138|     56|}
scan_name.cpp:_ZN5Botan12_GLOBAL__N_18make_argERKNSt3__16vectorINS1_4pairImNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEm:
   17|  1.40k|std::string make_arg(const std::vector<std::pair<size_t, std::string>>& name, size_t start) {
   18|  1.40k|   std::string output = name[start].second;
   19|  1.40k|   size_t level = name[start].first;
   20|       |
   21|  1.40k|   size_t paren_depth = 0;
   22|       |
   23|  1.40k|   for(size_t i = start + 1; i != name.size(); ++i) {
  ------------------
  |  Branch (23:30): [True: 112, False: 1.29k]
  ------------------
   24|    112|      if(name[i].first <= name[start].first) {
  ------------------
  |  Branch (24:10): [True: 112, False: 0]
  ------------------
   25|    112|         break;
   26|    112|      }
   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.40k|   for(size_t i = 0; i != paren_depth; ++i) {
  ------------------
  |  Branch (47:22): [True: 0, False: 1.40k]
  ------------------
   48|      0|      output += ")";
   49|      0|   }
   50|       |
   51|  1.40k|   return output;
   52|  1.40k|}

_ZN5Botan15AlternativeNameC2ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_S5_S5_:
   27|  14.6k|                                 std::string_view ip) {
   28|  14.6k|   add_attribute("RFC822", email_addr);
   29|  14.6k|   add_attribute("DNS", dns);
   30|  14.6k|   add_attribute("URI", uri);
   31|  14.6k|   add_attribute("IP", ip);
   32|  14.6k|}
_ZN5Botan15AlternativeName13add_attributeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   37|  68.8k|void AlternativeName::add_attribute(std::string_view type, std::string_view value) {
   38|  68.8k|   if(type.empty() || value.empty()) {
  ------------------
  |  Branch (38:7): [True: 0, False: 68.8k]
  |  Branch (38:23): [True: 60.9k, False: 7.89k]
  ------------------
   39|  60.9k|      return;
   40|  60.9k|   }
   41|       |
   42|  7.89k|   auto range = m_alt_info.equal_range(type);
   43|  84.6k|   for(auto j = range.first; j != range.second; ++j) {
  ------------------
  |  Branch (43:30): [True: 79.5k, False: 5.05k]
  ------------------
   44|  79.5k|      if(j->second == value) {
  ------------------
  |  Branch (44:10): [True: 2.83k, False: 76.7k]
  ------------------
   45|  2.83k|         return;
   46|  2.83k|      }
   47|  79.5k|   }
   48|       |
   49|  5.05k|   m_alt_info.emplace(type, value);
   50|  5.05k|}
_ZN5Botan15AlternativeName13add_othernameERKNS_3OIDENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS_9ASN1_TypeE:
   55|    661|void AlternativeName::add_othername(const OID& oid, std::string_view value, ASN1_Type type) {
   56|    661|   if(value.empty()) {
  ------------------
  |  Branch (56:7): [True: 51, False: 610]
  ------------------
   57|     51|      return;
   58|     51|   }
   59|    610|   multimap_insert(m_othernames, oid, ASN1_String(value, type));
   60|    610|}
_ZNK5Botan15AlternativeName8contentsEv:
   65|    231|std::multimap<std::string, std::string> AlternativeName::contents() const {
   66|    231|   std::multimap<std::string, std::string> names;
   67|       |
   68|    927|   for(const auto& name : m_alt_info) {
  ------------------
  |  Branch (68:25): [True: 927, False: 231]
  ------------------
   69|    927|      names.emplace(name.first, name.second);
   70|    927|   }
   71|       |
   72|    231|   for(const auto& othername : m_othernames) {
  ------------------
  |  Branch (72:30): [True: 172, False: 231]
  ------------------
   73|    172|      multimap_insert(names, othername.first.to_formatted_string(), othername.second.value());
   74|    172|   }
   75|       |
   76|    231|   return names;
   77|    231|}
_ZN5Botan15AlternativeName11decode_fromERNS_11BER_DecoderE:
  179|  1.59k|void AlternativeName::decode_from(BER_Decoder& source) {
  180|  1.59k|   BER_Decoder names = source.start_sequence();
  181|       |
  182|       |   // FIXME this is largely a duplication of GeneralName::decode_from
  183|       |
  184|  23.2k|   while(names.more_items()) {
  ------------------
  |  Branch (184:10): [True: 21.6k, False: 1.57k]
  ------------------
  185|  21.6k|      BER_Object obj = names.get_next_object();
  186|       |
  187|  21.6k|      if(obj.is_a(0, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (187:10): [True: 1.04k, False: 20.5k]
  ------------------
  188|  1.04k|         BER_Decoder othername(obj);
  189|       |
  190|  1.04k|         OID oid;
  191|  1.04k|         othername.decode(oid);
  192|  1.04k|         if(othername.more_items()) {
  ------------------
  |  Branch (192:13): [True: 871, False: 176]
  ------------------
  193|    871|            BER_Object othername_value_outer = othername.get_next_object();
  194|    871|            othername.verify_end();
  195|       |
  196|    871|            if(othername_value_outer.is_a(0, ASN1_Class::ExplicitContextSpecific) == false) {
  ------------------
  |  Branch (196:16): [True: 15, False: 856]
  ------------------
  197|     15|               throw Decoding_Error("Invalid tags on otherName value");
  198|     15|            }
  199|       |
  200|    856|            BER_Decoder othername_value_inner(othername_value_outer);
  201|       |
  202|    856|            BER_Object value = othername_value_inner.get_next_object();
  203|    856|            othername_value_inner.verify_end();
  204|       |
  205|    856|            if(ASN1_String::is_string_type(value.type()) && value.get_class() == ASN1_Class::Universal) {
  ------------------
  |  Branch (205:16): [True: 711, False: 145]
  |  Branch (205:61): [True: 661, False: 50]
  ------------------
  206|    661|               add_othername(oid, ASN1::to_string(value), value.type());
  207|    661|            }
  208|    856|         }
  209|  1.04k|      }
  210|  21.6k|      if(obj.is_a(1, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (210:10): [True: 4.23k, False: 17.3k]
  ------------------
  211|  4.23k|         add_attribute("RFC822", ASN1::to_string(obj));
  212|  17.3k|      } else if(obj.is_a(2, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (212:17): [True: 1.69k, False: 15.6k]
  ------------------
  213|  1.69k|         add_attribute("DNS", ASN1::to_string(obj));
  214|  15.6k|      } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (214:17): [True: 1.04k, False: 14.6k]
  ------------------
  215|  1.04k|         add_attribute("URI", ASN1::to_string(obj));
  216|  14.6k|      } else if(obj.is_a(4, ASN1_Class::ContextSpecific | ASN1_Class::Constructed)) {
  ------------------
  |  Branch (216:17): [True: 1.06k, False: 13.5k]
  ------------------
  217|  1.06k|         BER_Decoder dec(obj);
  218|  1.06k|         X509_DN dn;
  219|  1.06k|         std::stringstream ss;
  220|       |
  221|  1.06k|         dec.decode(dn);
  222|  1.06k|         ss << dn;
  223|       |
  224|  1.06k|         add_attribute("DN", ss.str());
  225|  13.5k|      } else if(obj.is_a(7, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (225:17): [True: 2.76k, False: 10.8k]
  ------------------
  226|  2.76k|         if(obj.length() == 4) {
  ------------------
  |  Branch (226:13): [True: 2.41k, False: 352]
  ------------------
  227|  2.41k|            const uint32_t ip = load_be<uint32_t>(obj.bits(), 0);
  228|  2.41k|            add_attribute("IP", ipv4_to_string(ip));
  229|  2.41k|         }
  230|  2.76k|      }
  231|  21.6k|   }
  232|  1.59k|}

_ZN5Botan17Certificate_StoreD2Ev:
   18|  2.16k|Certificate_Store::~Certificate_Store() = default;
_ZN5Botan27Certificate_Store_In_Memory15add_certificateERKNS_16X509_CertificateE:
   36|    762|void Certificate_Store_In_Memory::add_certificate(const X509_Certificate& cert) {
   37|    762|   for(const auto& c : m_certs) {
  ------------------
  |  Branch (37:22): [True: 0, False: 762]
  ------------------
   38|      0|      if(c == cert) {
  ------------------
  |  Branch (38:10): [True: 0, False: 0]
  ------------------
   39|      0|         return;
   40|      0|      }
   41|      0|   }
   42|       |
   43|    762|   m_certs.push_back(cert);
   44|    762|}
_ZNK5Botan27Certificate_Store_In_Memory14find_all_certsERKNS_7X509_DNERKNSt3__16vectorIhNS4_9allocatorIhEEEE:
   76|  1.53k|                                                                          const std::vector<uint8_t>& key_id) const {
   77|  1.53k|   std::vector<X509_Certificate> matches;
   78|       |
   79|  1.53k|   for(const auto& cert : m_certs) {
  ------------------
  |  Branch (79:25): [True: 768, False: 1.53k]
  ------------------
   80|    768|      if(!key_id.empty()) {
  ------------------
  |  Branch (80:10): [True: 29, False: 739]
  ------------------
   81|     29|         const std::vector<uint8_t>& skid = cert.subject_key_id();
   82|       |
   83|     29|         if(!skid.empty() && skid != key_id) {  // no match
  ------------------
  |  Branch (83:13): [True: 23, False: 6]
  |  Branch (83:30): [True: 19, False: 4]
  ------------------
   84|     19|            continue;
   85|     19|         }
   86|     29|      }
   87|       |
   88|    749|      if(cert.subject_dn() == subject_dn) {
  ------------------
  |  Branch (88:10): [True: 602, False: 147]
  ------------------
   89|    602|         matches.push_back(cert);
   90|    602|      }
   91|    749|   }
   92|       |
   93|  1.53k|   return matches;
   94|  1.53k|}
_ZNK5Botan27Certificate_Store_In_Memory12find_crl_forERKNS_16X509_CertificateE:
  149|    290|std::optional<X509_CRL> Certificate_Store_In_Memory::find_crl_for(const X509_Certificate& subject) const {
  150|    290|   const std::vector<uint8_t>& key_id = subject.authority_key_id();
  151|       |
  152|    290|   for(const auto& c : m_crls) {
  ------------------
  |  Branch (152:22): [True: 0, False: 290]
  ------------------
  153|       |      // Only compare key ids if set in both call and in the CRL
  154|      0|      if(!key_id.empty()) {
  ------------------
  |  Branch (154:10): [True: 0, False: 0]
  ------------------
  155|      0|         const std::vector<uint8_t>& akid = c.authority_key_id();
  156|       |
  157|      0|         if(!akid.empty() && akid != key_id) {  // no match
  ------------------
  |  Branch (157:13): [True: 0, False: 0]
  |  Branch (157:30): [True: 0, False: 0]
  ------------------
  158|      0|            continue;
  159|      0|         }
  160|      0|      }
  161|       |
  162|      0|      if(c.issuer_dn() == subject.issuer_dn()) {
  ------------------
  |  Branch (162:10): [True: 0, False: 0]
  ------------------
  163|      0|         return c;
  164|      0|      }
  165|      0|   }
  166|       |
  167|    290|   return {};
  168|    290|}
_ZN5Botan27Certificate_Store_In_MemoryC2ERKNS_16X509_CertificateE:
  170|    762|Certificate_Store_In_Memory::Certificate_Store_In_Memory(const X509_Certificate& cert) {
  171|    762|   add_certificate(cert);
  172|    762|}

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

_ZN5Botan7X509_DN13add_attributeERKNS_3OIDERKNS_11ASN1_StringE:
  100|  23.0k|void X509_DN::add_attribute(const OID& oid, const ASN1_String& str) {
  101|  23.0k|   if(str.empty()) {
  ------------------
  |  Branch (101:7): [True: 209, False: 22.8k]
  ------------------
  102|    209|      return;
  103|    209|   }
  104|       |
  105|  22.8k|   m_rdn.push_back(std::make_pair(oid, str));
  106|  22.8k|   m_dn_bits.clear();
  107|  22.8k|}
_ZNK5Botan7X509_DN14get_attributesEv:
  112|  11.7k|std::multimap<OID, std::string> X509_DN::get_attributes() const {
  113|  11.7k|   std::multimap<OID, std::string> retval;
  114|       |
  115|  22.4k|   for(auto& i : m_rdn) {
  ------------------
  |  Branch (115:16): [True: 22.4k, False: 11.7k]
  ------------------
  116|  22.4k|      multimap_insert(retval, i.first, i.second.value());
  117|  22.4k|   }
  118|  11.7k|   return retval;
  119|  11.7k|}
_ZN5BotaneqERKNS_7X509_DNES2_:
  220|  5.86k|bool operator==(const X509_DN& dn1, const X509_DN& dn2) {
  221|  5.86k|   auto attr1 = dn1.get_attributes();
  222|  5.86k|   auto attr2 = dn2.get_attributes();
  223|       |
  224|  5.86k|   if(attr1.size() != attr2.size()) {
  ------------------
  |  Branch (224:7): [True: 332, False: 5.53k]
  ------------------
  225|    332|      return false;
  226|    332|   }
  227|       |
  228|  5.53k|   auto p1 = attr1.begin();
  229|  5.53k|   auto p2 = attr2.begin();
  230|       |
  231|  13.6k|   while(true) {
  ------------------
  |  Branch (231:10): [Folded - Ignored]
  ------------------
  232|  13.6k|      if(p1 == attr1.end() && p2 == attr2.end()) {
  ------------------
  |  Branch (232:10): [True: 4.70k, False: 8.96k]
  |  Branch (232:10): [True: 4.70k, False: 8.96k]
  |  Branch (232:31): [True: 4.70k, False: 0]
  ------------------
  233|  4.70k|         break;
  234|  4.70k|      }
  235|  8.96k|      if(p1 == attr1.end()) {
  ------------------
  |  Branch (235:10): [True: 0, False: 8.96k]
  ------------------
  236|      0|         return false;
  237|      0|      }
  238|  8.96k|      if(p2 == attr2.end()) {
  ------------------
  |  Branch (238:10): [True: 0, False: 8.96k]
  ------------------
  239|      0|         return false;
  240|      0|      }
  241|  8.96k|      if(p1->first != p2->first) {
  ------------------
  |  Branch (241:10): [True: 560, False: 8.40k]
  ------------------
  242|    560|         return false;
  243|    560|      }
  244|  8.40k|      if(!x500_name_cmp(p1->second, p2->second)) {
  ------------------
  |  Branch (244:10): [True: 266, False: 8.14k]
  ------------------
  245|    266|         return false;
  246|    266|      }
  247|  8.14k|      ++p1;
  248|  8.14k|      ++p2;
  249|  8.14k|   }
  250|  4.70k|   return true;
  251|  5.53k|}
_ZN5BotanneERKNS_7X509_DNES2_:
  256|    655|bool operator!=(const X509_DN& dn1, const X509_DN& dn2) {
  257|    655|   return !(dn1 == dn2);
  258|    655|}
_ZN5Botan7X509_DN11decode_fromERNS_11BER_DecoderE:
  347|  12.1k|void X509_DN::decode_from(BER_Decoder& source) {
  348|  12.1k|   std::vector<uint8_t> bits;
  349|       |
  350|  12.1k|   source.start_sequence().raw_bytes(bits).end_cons();
  351|       |
  352|  12.1k|   BER_Decoder sequence(bits);
  353|       |
  354|  12.1k|   m_rdn.clear();
  355|       |
  356|  35.4k|   while(sequence.more_items()) {
  ------------------
  |  Branch (356:10): [True: 23.2k, False: 12.1k]
  ------------------
  357|  23.2k|      BER_Decoder rdn = sequence.start_set();
  358|       |
  359|  46.6k|      while(rdn.more_items()) {
  ------------------
  |  Branch (359:13): [True: 23.3k, False: 23.2k]
  ------------------
  360|  23.3k|         OID oid;
  361|  23.3k|         ASN1_String str;
  362|       |
  363|  23.3k|         rdn.start_sequence()
  364|  23.3k|            .decode(oid)
  365|  23.3k|            .decode(str)  // TODO support Any
  366|  23.3k|            .end_cons();
  367|       |
  368|  23.3k|         add_attribute(oid, str);
  369|  23.3k|      }
  370|  23.2k|   }
  371|       |
  372|       |   // Have to assign last as add_attribute zaps m_dn_bits
  373|  12.1k|   m_dn_bits = bits;
  374|  12.1k|}
_ZN5BotanlsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_7X509_DNE:
  408|    959|std::ostream& operator<<(std::ostream& out, const X509_DN& dn) {
  409|    959|   auto info = dn.dn_info();
  410|       |
  411|  2.66k|   for(size_t i = 0; i != info.size(); ++i) {
  ------------------
  |  Branch (411:22): [True: 1.70k, False: 959]
  ------------------
  412|  1.70k|      out << to_short_form(info[i].first) << "=\"";
  413|  14.1k|      for(char c : info[i].second.value()) {
  ------------------
  |  Branch (413:18): [True: 14.1k, False: 1.70k]
  ------------------
  414|  14.1k|         if(c == '\\' || c == '\"') {
  ------------------
  |  Branch (414:13): [True: 118, False: 14.0k]
  |  Branch (414:26): [True: 158, False: 13.9k]
  ------------------
  415|    276|            out << "\\";
  416|    276|         }
  417|  14.1k|         out << c;
  418|  14.1k|      }
  419|  1.70k|      out << "\"";
  420|       |
  421|  1.70k|      if(i + 1 < info.size()) {
  ------------------
  |  Branch (421:10): [True: 1.00k, False: 708]
  ------------------
  422|  1.00k|         out << ",";
  423|  1.00k|      }
  424|  1.70k|   }
  425|    959|   return out;
  426|    959|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_113x500_name_cmpENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   36|  8.40k|bool x500_name_cmp(std::string_view name1, std::string_view name2) {
   37|  8.40k|   auto p1 = name1.begin();
   38|  8.40k|   auto p2 = name2.begin();
   39|       |
   40|  8.72k|   while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (40:10): [True: 8.70k, False: 18]
  |  Branch (40:33): [True: 318, False: 8.39k]
  ------------------
   41|    318|      ++p1;
   42|    318|   }
   43|  8.68k|   while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (43:10): [True: 8.66k, False: 18]
  |  Branch (43:33): [True: 277, False: 8.39k]
  ------------------
   44|    277|      ++p2;
   45|    277|   }
   46|       |
   47|  96.7k|   while(p1 != name1.end() && p2 != name2.end()) {
  ------------------
  |  Branch (47:10): [True: 88.5k, False: 8.13k]
  |  Branch (47:31): [True: 88.5k, False: 32]
  ------------------
   48|  88.5k|      if(is_space(*p1)) {
  ------------------
  |  Branch (48:10): [True: 2.64k, False: 85.9k]
  ------------------
   49|  2.64k|         if(!is_space(*p2)) {
  ------------------
  |  Branch (49:13): [True: 7, False: 2.63k]
  ------------------
   50|      7|            return false;
   51|      7|         }
   52|       |
   53|  5.49k|         while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (53:16): [True: 5.48k, False: 13]
  |  Branch (53:39): [True: 2.86k, False: 2.62k]
  ------------------
   54|  2.86k|            ++p1;
   55|  2.86k|         }
   56|  5.50k|         while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (56:16): [True: 5.48k, False: 16]
  |  Branch (56:39): [True: 2.86k, False: 2.61k]
  ------------------
   57|  2.86k|            ++p2;
   58|  2.86k|         }
   59|       |
   60|  2.63k|         if(p1 == name1.end() && p2 == name2.end()) {
  ------------------
  |  Branch (60:13): [True: 13, False: 2.62k]
  |  Branch (60:34): [True: 10, False: 3]
  ------------------
   61|     10|            return true;
   62|     10|         }
   63|  2.62k|         if(p1 == name1.end() || p2 == name2.end()) {
  ------------------
  |  Branch (63:13): [True: 3, False: 2.62k]
  |  Branch (63:34): [True: 6, False: 2.61k]
  ------------------
   64|      9|            return false;
   65|      9|         }
   66|  2.62k|      }
   67|       |
   68|  88.5k|      if(!caseless_cmp(*p1, *p2)) {
  ------------------
  |  Branch (68:10): [True: 219, False: 88.3k]
  ------------------
   69|    219|         return false;
   70|    219|      }
   71|  88.3k|      ++p1;
   72|  88.3k|      ++p2;
   73|  88.3k|   }
   74|       |
   75|  8.20k|   while((p1 != name1.end()) && is_space(*p1)) {
  ------------------
  |  Branch (75:10): [True: 58, False: 8.14k]
  |  Branch (75:33): [True: 42, False: 16]
  ------------------
   76|     42|      ++p1;
   77|     42|   }
   78|  8.19k|   while((p2 != name2.end()) && is_space(*p2)) {
  ------------------
  |  Branch (78:10): [True: 42, False: 8.14k]
  |  Branch (78:33): [True: 27, False: 15]
  ------------------
   79|     27|      ++p2;
   80|     27|   }
   81|       |
   82|  8.16k|   if((p1 != name1.end()) || (p2 != name2.end())) {
  ------------------
  |  Branch (82:7): [True: 16, False: 8.14k]
  |  Branch (82:30): [True: 15, False: 8.13k]
  ------------------
   83|     31|      return false;
   84|     31|   }
   85|  8.13k|   return true;
   86|  8.16k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_112_GLOBAL__N_18is_spaceEc:
   27|   119k|bool is_space(char c) {
   28|   119k|   return std::isspace(static_cast<unsigned char>(c));
   29|   119k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_112_GLOBAL__N_112caseless_cmpEcc:
   23|  88.5k|bool caseless_cmp(char a, char b) {
   24|  88.5k|   return (std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b)));
   25|  88.5k|}
x509_dn.cpp:_ZN5Botan12_GLOBAL__N_113to_short_formERKNS_3OIDE:
  378|  1.70k|std::string to_short_form(const OID& oid) {
  379|  1.70k|   std::string long_id = oid.to_formatted_string();
  380|       |
  381|  1.70k|   if(long_id == "X520.CommonName") {
  ------------------
  |  Branch (381:7): [True: 107, False: 1.60k]
  ------------------
  382|    107|      return "CN";
  383|    107|   }
  384|       |
  385|  1.60k|   if(long_id == "X520.Country") {
  ------------------
  |  Branch (385:7): [True: 78, False: 1.52k]
  ------------------
  386|     78|      return "C";
  387|     78|   }
  388|       |
  389|  1.52k|   if(long_id == "X520.Organization") {
  ------------------
  |  Branch (389:7): [True: 81, False: 1.44k]
  ------------------
  390|     81|      return "O";
  391|     81|   }
  392|       |
  393|  1.44k|   if(long_id == "X520.OrganizationalUnit") {
  ------------------
  |  Branch (393:7): [True: 100, False: 1.34k]
  ------------------
  394|    100|      return "OU";
  395|    100|   }
  396|       |
  397|  1.34k|   return long_id;
  398|  1.44k|}

_ZN5Botan7X509_DN9lookup_ubERKNS_3OIDE:
   48|  1.01k|size_t X509_DN::lookup_ub(const OID& oid) {
   49|  1.01k|   auto ub_entry = DN_UB.find(oid);
   50|  1.01k|   if(ub_entry != DN_UB.end()) {
  ------------------
  |  Branch (50:7): [True: 634, False: 379]
  ------------------
   51|    634|      return ub_entry->second;
   52|    634|   } else {
   53|    379|      return 0;
   54|    379|   }
   55|  1.01k|}

_ZN5Botan10Extensions15create_extn_objERKNS_3OIDEbRKNSt3__16vectorIhNS4_9allocatorIhEEEE:
   93|  11.3k|                                                                   const std::vector<uint8_t>& body) {
   94|  11.3k|   const std::string oid_str = oid.to_string();
   95|       |
   96|  11.3k|   auto extn = extension_from_oid(oid);
   97|       |
   98|  11.3k|   if(!extn) {
  ------------------
  |  Branch (98:7): [True: 5.10k, False: 6.26k]
  ------------------
   99|       |      // some other unknown extension type
  100|  5.10k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  101|  5.10k|   }
  102|       |
  103|  11.3k|   try {
  104|  11.3k|      extn->decode_inner(body);
  105|  11.3k|   } catch(Decoding_Error&) {
  106|  4.08k|      extn = std::make_unique<Cert_Extension::Unknown_Extension>(oid, critical);
  107|  4.08k|      extn->decode_inner(body);
  108|  4.08k|   }
  109|  11.3k|   return extn;
  110|  11.3k|}
_ZN5Botan21Certificate_Extension8validateERKNS_16X509_CertificateES3_RKNSt3__16vectorIS1_NS4_9allocatorIS1_EEEERNS5_INS4_3setINS_23Certificate_Status_CodeENS4_4lessISC_EENS6_ISC_EEEENS6_ISG_EEEEm:
  119|    216|                                     size_t /*unused*/) {}
_ZNK5Botan10Extensions20get_extension_objectERKNS_3OIDE:
  190|  49.0k|const Certificate_Extension* Extensions::get_extension_object(const OID& oid) const {
  191|  49.0k|   auto extn = m_extension_info.find(oid);
  192|  49.0k|   if(extn == m_extension_info.end()) {
  ------------------
  |  Branch (192:7): [True: 46.3k, False: 2.68k]
  ------------------
  193|  46.3k|      return nullptr;
  194|  46.3k|   }
  195|       |
  196|  2.68k|   return &extn->second.obj();
  197|  49.0k|}
_ZNK5Botan10Extensions10extensionsEv:
  206|    290|std::vector<std::pair<std::unique_ptr<Certificate_Extension>, bool>> Extensions::extensions() const {
  207|    290|   std::vector<std::pair<std::unique_ptr<Certificate_Extension>, bool>> exts;
  208|    290|   exts.reserve(m_extension_info.size());
  209|    645|   for(auto&& ext : m_extension_info) {
  ------------------
  |  Branch (209:19): [True: 645, False: 290]
  ------------------
  210|    645|      exts.push_back(std::make_pair(ext.second.obj().copy(), ext.second.is_critical()));
  211|    645|   }
  212|    290|   return exts;
  213|    290|}
_ZN5Botan10Extensions11decode_fromERNS_11BER_DecoderE:
  247|  2.22k|void Extensions::decode_from(BER_Decoder& from_source) {
  248|  2.22k|   m_extension_oids.clear();
  249|  2.22k|   m_extension_info.clear();
  250|       |
  251|  2.22k|   BER_Decoder sequence = from_source.start_sequence();
  252|       |
  253|  14.1k|   while(sequence.more_items()) {
  ------------------
  |  Branch (253:10): [True: 11.9k, False: 2.22k]
  ------------------
  254|  11.9k|      OID oid;
  255|  11.9k|      bool critical;
  256|  11.9k|      std::vector<uint8_t> bits;
  257|       |
  258|  11.9k|      sequence.start_sequence()
  259|  11.9k|         .decode(oid)
  260|  11.9k|         .decode_optional(critical, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  261|  11.9k|         .decode(bits, ASN1_Type::OctetString)
  262|  11.9k|         .end_cons();
  263|       |
  264|  11.9k|      auto obj = create_extn_obj(oid, critical, bits);
  265|  11.9k|      Extensions_Info info(critical, bits, std::move(obj));
  266|       |
  267|  11.9k|      m_extension_oids.push_back(oid);
  268|  11.9k|      m_extension_info.emplace(oid, info);
  269|  11.9k|   }
  270|  2.22k|   sequence.verify_end();
  271|  2.22k|}
_ZNK5Botan14Cert_Extension17Basic_Constraints14get_path_limitEv:
  278|    161|size_t Basic_Constraints::get_path_limit() const {
  279|    161|   if(!m_is_ca) {
  ------------------
  |  Branch (279:7): [True: 0, False: 161]
  ------------------
  280|      0|      throw Invalid_State("Basic_Constraints::get_path_limit: Not a CA");
  281|      0|   }
  282|    161|   return m_path_limit;
  283|    161|}
_ZN5Botan14Cert_Extension17Basic_Constraints12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  300|    770|void Basic_Constraints::decode_inner(const std::vector<uint8_t>& in) {
  301|    770|   BER_Decoder(in)
  302|    770|      .start_sequence()
  303|    770|      .decode_optional(m_is_ca, ASN1_Type::Boolean, ASN1_Class::Universal, false)
  304|    770|      .decode_optional(m_path_limit, ASN1_Type::Integer, ASN1_Class::Universal, NO_CERT_PATH_LIMIT)
  305|    770|      .end_cons();
  306|       |
  307|    770|   if(m_is_ca == false) {
  ------------------
  |  Branch (307:7): [True: 155, False: 615]
  ------------------
  308|    155|      m_path_limit = 0;
  309|    155|   }
  310|    770|}
_ZN5Botan14Cert_Extension9Key_Usage12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  338|    715|void Key_Usage::decode_inner(const std::vector<uint8_t>& in) {
  339|    715|   BER_Decoder ber(in);
  340|       |
  341|    715|   BER_Object obj = ber.get_next_object();
  342|       |
  343|    715|   obj.assert_is_a(ASN1_Type::BitString, ASN1_Class::Universal, "usage constraint");
  344|       |
  345|    715|   if(obj.length() != 2 && obj.length() != 3) {
  ------------------
  |  Branch (345:7): [True: 79, False: 636]
  |  Branch (345:28): [True: 30, False: 49]
  ------------------
  346|     30|      throw BER_Decoding_Error("Bad size for BITSTRING in usage constraint");
  347|     30|   }
  348|       |
  349|    685|   uint16_t usage = 0;
  350|       |
  351|    685|   const uint8_t* bits = obj.bits();
  352|       |
  353|    685|   if(bits[0] >= 8) {
  ------------------
  |  Branch (353:7): [True: 62, False: 623]
  ------------------
  354|     62|      throw BER_Decoding_Error("Invalid unused bits in usage constraint");
  355|     62|   }
  356|       |
  357|    623|   const uint8_t mask = static_cast<uint8_t>(0xFF << bits[0]);
  358|       |
  359|    623|   if(obj.length() == 2) {
  ------------------
  |  Branch (359:7): [True: 311, False: 312]
  ------------------
  360|    311|      usage = make_uint16(bits[1] & mask, 0);
  361|    312|   } else if(obj.length() == 3) {
  ------------------
  |  Branch (361:14): [True: 43, False: 269]
  ------------------
  362|     43|      usage = make_uint16(bits[1], bits[2] & mask);
  363|     43|   }
  364|       |
  365|    623|   m_constraints = Key_Constraints(usage);
  366|    623|}
_ZN5Botan14Cert_Extension14Subject_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  380|    657|void Subject_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  381|    657|   BER_Decoder(in).decode(m_key_id, ASN1_Type::OctetString).verify_end();
  382|    657|}
_ZN5Botan14Cert_Extension16Authority_Key_ID12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  417|    455|void Authority_Key_ID::decode_inner(const std::vector<uint8_t>& in) {
  418|    455|   BER_Decoder(in).start_sequence().decode_optional_string(m_key_id, ASN1_Type::OctetString, 0);
  419|    455|}
_ZN5Botan14Cert_Extension24Subject_Alternative_Name12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  442|    948|void Subject_Alternative_Name::decode_inner(const std::vector<uint8_t>& in) {
  443|    948|   BER_Decoder(in).decode(m_alt_name);
  444|    948|}
_ZN5Botan14Cert_Extension23Issuer_Alternative_Name12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  449|    336|void Issuer_Alternative_Name::decode_inner(const std::vector<uint8_t>& in) {
  450|    336|   BER_Decoder(in).decode(m_alt_name);
  451|    336|}
_ZN5Botan14Cert_Extension18Extended_Key_Usage12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  465|    385|void Extended_Key_Usage::decode_inner(const std::vector<uint8_t>& in) {
  466|    385|   BER_Decoder(in).decode_list(m_oids);
  467|    385|}
_ZN5Botan14Cert_Extension16Name_Constraints12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  479|    578|void Name_Constraints::decode_inner(const std::vector<uint8_t>& in) {
  480|    578|   std::vector<GeneralSubtree> permit, exclude;
  481|    578|   BER_Decoder ber(in);
  482|    578|   BER_Decoder ext = ber.start_sequence();
  483|    578|   BER_Object per = ext.get_next_object();
  484|       |
  485|    578|   ext.push_back(per);
  486|    578|   if(per.is_a(0, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (486:7): [True: 259, False: 319]
  ------------------
  487|    259|      ext.decode_list(permit, ASN1_Type(0), ASN1_Class::Constructed | ASN1_Class::ContextSpecific);
  488|    259|      if(permit.empty()) {
  ------------------
  |  Branch (488:10): [True: 1, False: 258]
  ------------------
  489|      1|         throw Encoding_Error("Empty Name Contraint list");
  490|      1|      }
  491|    259|   }
  492|       |
  493|    577|   BER_Object exc = ext.get_next_object();
  494|    577|   ext.push_back(exc);
  495|    577|   if(per.is_a(1, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (495:7): [True: 76, False: 501]
  ------------------
  496|     76|      ext.decode_list(exclude, ASN1_Type(1), ASN1_Class::Constructed | ASN1_Class::ContextSpecific);
  497|     76|      if(exclude.empty()) {
  ------------------
  |  Branch (497:10): [True: 1, False: 75]
  ------------------
  498|      1|         throw Encoding_Error("Empty Name Contraint list");
  499|      1|      }
  500|     76|   }
  501|       |
  502|    576|   ext.end_cons();
  503|       |
  504|    576|   if(permit.empty() && exclude.empty()) {
  ------------------
  |  Branch (504:7): [True: 11, False: 565]
  |  Branch (504:25): [True: 4, False: 7]
  ------------------
  505|      4|      throw Encoding_Error("Empty Name Contraint extension");
  506|      4|   }
  507|       |
  508|    572|   m_name_constraints = NameConstraints(std::move(permit), std::move(exclude));
  509|    572|}
_ZN5Botan14Cert_Extension20Certificate_Policies12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  608|    329|void Certificate_Policies::decode_inner(const std::vector<uint8_t>& in) {
  609|    329|   std::vector<Policy_Information> policies;
  610|       |
  611|    329|   BER_Decoder(in).decode_list(policies);
  612|    329|   m_oids.clear();
  613|    329|   for(const auto& policy : policies) {
  ------------------
  |  Branch (613:27): [True: 193, False: 329]
  ------------------
  614|    193|      m_oids.push_back(policy.oid());
  615|    193|   }
  616|    329|}
_ZN5Botan14Cert_Extension20Certificate_Policies8validateERKNS_16X509_CertificateES4_RKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEERNS6_INS5_3setINS_23Certificate_Status_CodeENS5_4lessISD_EENS7_ISD_EEEENS7_ISH_EEEEm:
  622|      4|                                    size_t pos) {
  623|      4|   std::set<OID> oid_set(m_oids.begin(), m_oids.end());
  624|      4|   if(oid_set.size() != m_oids.size()) {
  ------------------
  |  Branch (624:7): [True: 0, False: 4]
  ------------------
  625|      0|      cert_status.at(pos).insert(Certificate_Status_Code::DUPLICATE_CERT_POLICY);
  626|      0|   }
  627|      4|}
_ZN5Botan14Cert_Extension28Authority_Information_Access12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  656|    203|void Authority_Information_Access::decode_inner(const std::vector<uint8_t>& in) {
  657|    203|   BER_Decoder ber = BER_Decoder(in).start_sequence();
  658|       |
  659|    525|   while(ber.more_items()) {
  ------------------
  |  Branch (659:10): [True: 322, False: 203]
  ------------------
  660|    322|      OID oid;
  661|       |
  662|    322|      BER_Decoder info = ber.start_sequence();
  663|       |
  664|    322|      info.decode(oid);
  665|       |
  666|    322|      if(oid == OID::from_string("PKIX.OCSP")) {
  ------------------
  |  Branch (666:10): [True: 43, False: 279]
  ------------------
  667|     43|         BER_Object name = info.get_next_object();
  668|       |
  669|     43|         if(name.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (669:13): [True: 28, False: 15]
  ------------------
  670|     28|            m_ocsp_responder = ASN1::to_string(name);
  671|     28|         }
  672|     43|      }
  673|    322|      if(oid == OID::from_string("PKIX.CertificateAuthorityIssuers")) {
  ------------------
  |  Branch (673:10): [True: 83, False: 239]
  ------------------
  674|     83|         BER_Object name = info.get_next_object();
  675|       |
  676|     83|         if(name.is_a(6, ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (676:13): [True: 62, False: 21]
  ------------------
  677|     62|            m_ca_issuers.push_back(ASN1::to_string(name));
  678|     62|         }
  679|     83|      }
  680|    322|   }
  681|    203|}
_ZNK5Botan14Cert_Extension10CRL_Number4copyEv:
  696|      3|std::unique_ptr<Certificate_Extension> CRL_Number::copy() const {
  697|      3|   if(!m_has_value) {
  ------------------
  |  Branch (697:7): [True: 0, False: 3]
  ------------------
  698|      0|      throw Invalid_State("CRL_Number::copy: Not set");
  699|      0|   }
  700|      3|   return std::make_unique<CRL_Number>(m_crl_number);
  701|      3|}
_ZN5Botan14Cert_Extension10CRL_Number12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  715|     75|void CRL_Number::decode_inner(const std::vector<uint8_t>& in) {
  716|     75|   BER_Decoder(in).decode(m_crl_number);
  717|     75|   m_has_value = true;
  718|     75|}
_ZN5Botan14Cert_Extension14CRL_ReasonCode12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  732|    169|void CRL_ReasonCode::decode_inner(const std::vector<uint8_t>& in) {
  733|    169|   size_t reason_code = 0;
  734|    169|   BER_Decoder(in).decode(reason_code, ASN1_Type::Enumerated, ASN1_Class::Universal);
  735|    169|   m_reason = static_cast<CRL_Code>(reason_code);
  736|    169|}
_ZN5Botan14Cert_Extension23CRL_Distribution_Points12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  744|    513|void CRL_Distribution_Points::decode_inner(const std::vector<uint8_t>& buf) {
  745|    513|   BER_Decoder(buf).decode_list(m_distribution_points).verify_end();
  746|       |
  747|    513|   std::stringstream ss;
  748|       |
  749|    513|   for(const auto& distribution_point : m_distribution_points) {
  ------------------
  |  Branch (749:39): [True: 231, False: 513]
  ------------------
  750|    231|      auto contents = distribution_point.point().contents();
  751|       |
  752|  1.09k|      for(const auto& pair : contents) {
  ------------------
  |  Branch (752:28): [True: 1.09k, False: 231]
  ------------------
  753|  1.09k|         ss << pair.first << ": " << pair.second << " ";
  754|  1.09k|      }
  755|    231|   }
  756|       |
  757|    513|   m_crl_distribution_urls.push_back(ss.str());
  758|    513|}
_ZN5Botan14Cert_Extension23CRL_Distribution_Points18Distribution_Point11decode_fromERNS_11BER_DecoderE:
  778|    586|void CRL_Distribution_Points::Distribution_Point::decode_from(BER_Decoder& ber) {
  779|    586|   ber.start_sequence()
  780|    586|      .start_context_specific(0)
  781|    586|      .decode_optional_implicit(m_point,
  782|    586|                                ASN1_Type(0),
  783|    586|                                ASN1_Class::ContextSpecific | ASN1_Class::Constructed,
  784|    586|                                ASN1_Type::Sequence,
  785|    586|                                ASN1_Class::Constructed)
  786|    586|      .end_cons()
  787|    586|      .end_cons();
  788|    586|}
_ZN5Botan14Cert_Extension30CRL_Issuing_Distribution_Point12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  794|    132|void CRL_Issuing_Distribution_Point::decode_inner(const std::vector<uint8_t>& buf) {
  795|    132|   BER_Decoder(buf).decode(m_distribution_point).verify_end();
  796|    132|}
_ZN5Botan14Cert_Extension17Unknown_Extension12decode_innerERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  806|  9.19k|void Unknown_Extension::decode_inner(const std::vector<uint8_t>& bytes) {
  807|       |   // Just treat as an opaque blob at this level
  808|  9.19k|   m_bytes = bytes;
  809|  9.19k|}
x509_ext.cpp:_ZN5Botan12_GLOBAL__N_118extension_from_oidERKNS_3OIDE:
   26|  11.3k|std::unique_ptr<Certificate_Extension> extension_from_oid(const OID& oid) {
   27|  11.3k|   if(oid == Cert_Extension::Subject_Key_ID::static_oid()) {
  ------------------
  |  Branch (27:7): [True: 657, False: 10.7k]
  ------------------
   28|    657|      return std::make_unique<Cert_Extension::Subject_Key_ID>();
   29|    657|   }
   30|       |
   31|  10.7k|   if(oid == Cert_Extension::Key_Usage::static_oid()) {
  ------------------
  |  Branch (31:7): [True: 715, False: 9.99k]
  ------------------
   32|    715|      return std::make_unique<Cert_Extension::Key_Usage>();
   33|    715|   }
   34|       |
   35|  9.99k|   if(oid == Cert_Extension::Subject_Alternative_Name::static_oid()) {
  ------------------
  |  Branch (35:7): [True: 948, False: 9.05k]
  ------------------
   36|    948|      return std::make_unique<Cert_Extension::Subject_Alternative_Name>();
   37|    948|   }
   38|       |
   39|  9.05k|   if(oid == Cert_Extension::Issuer_Alternative_Name::static_oid()) {
  ------------------
  |  Branch (39:7): [True: 336, False: 8.71k]
  ------------------
   40|    336|      return std::make_unique<Cert_Extension::Issuer_Alternative_Name>();
   41|    336|   }
   42|       |
   43|  8.71k|   if(oid == Cert_Extension::Basic_Constraints::static_oid()) {
  ------------------
  |  Branch (43:7): [True: 770, False: 7.94k]
  ------------------
   44|    770|      return std::make_unique<Cert_Extension::Basic_Constraints>();
   45|    770|   }
   46|       |
   47|  7.94k|   if(oid == Cert_Extension::CRL_Number::static_oid()) {
  ------------------
  |  Branch (47:7): [True: 75, False: 7.87k]
  ------------------
   48|     75|      return std::make_unique<Cert_Extension::CRL_Number>();
   49|     75|   }
   50|       |
   51|  7.87k|   if(oid == Cert_Extension::CRL_ReasonCode::static_oid()) {
  ------------------
  |  Branch (51:7): [True: 169, False: 7.70k]
  ------------------
   52|    169|      return std::make_unique<Cert_Extension::CRL_ReasonCode>();
   53|    169|   }
   54|       |
   55|  7.70k|   if(oid == Cert_Extension::Authority_Key_ID::static_oid()) {
  ------------------
  |  Branch (55:7): [True: 455, False: 7.24k]
  ------------------
   56|    455|      return std::make_unique<Cert_Extension::Authority_Key_ID>();
   57|    455|   }
   58|       |
   59|  7.24k|   if(oid == Cert_Extension::Name_Constraints::static_oid()) {
  ------------------
  |  Branch (59:7): [True: 578, False: 6.66k]
  ------------------
   60|    578|      return std::make_unique<Cert_Extension::Name_Constraints>();
   61|    578|   }
   62|       |
   63|  6.66k|   if(oid == Cert_Extension::CRL_Distribution_Points::static_oid()) {
  ------------------
  |  Branch (63:7): [True: 513, False: 6.15k]
  ------------------
   64|    513|      return std::make_unique<Cert_Extension::CRL_Distribution_Points>();
   65|    513|   }
   66|       |
   67|  6.15k|   if(oid == Cert_Extension::CRL_Issuing_Distribution_Point::static_oid()) {
  ------------------
  |  Branch (67:7): [True: 132, False: 6.02k]
  ------------------
   68|    132|      return std::make_unique<Cert_Extension::CRL_Issuing_Distribution_Point>();
   69|    132|   }
   70|       |
   71|  6.02k|   if(oid == Cert_Extension::Certificate_Policies::static_oid()) {
  ------------------
  |  Branch (71:7): [True: 329, False: 5.69k]
  ------------------
   72|    329|      return std::make_unique<Cert_Extension::Certificate_Policies>();
   73|    329|   }
   74|       |
   75|  5.69k|   if(oid == Cert_Extension::Extended_Key_Usage::static_oid()) {
  ------------------
  |  Branch (75:7): [True: 385, False: 5.30k]
  ------------------
   76|    385|      return std::make_unique<Cert_Extension::Extended_Key_Usage>();
   77|    385|   }
   78|       |
   79|  5.30k|   if(oid == Cert_Extension::Authority_Information_Access::static_oid()) {
  ------------------
  |  Branch (79:7): [True: 203, False: 5.10k]
  ------------------
   80|    203|      return std::make_unique<Cert_Extension::Authority_Information_Access>();
   81|    203|   }
   82|       |
   83|  5.10k|   return nullptr;  // unknown
   84|  5.30k|}
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_118Policy_Information11decode_fromERNS_11BER_DecoderE:
  579|    372|      void decode_from(BER_Decoder& codec) override {
  580|    372|         codec.start_sequence().decode(m_oid).discard_remaining().end_cons();
  581|    372|      }
x509_ext.cpp:_ZNK5Botan14Cert_Extension12_GLOBAL__N_118Policy_Information3oidEv:
  575|    193|      const OID& oid() const { return m_oid; }
x509_ext.cpp:_ZN5Botan14Cert_Extension12_GLOBAL__N_118Policy_InformationC2Ev:
  571|    372|      Policy_Information() = default;

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

_ZNK5Botan16X509_Certificate9PEM_labelEv:
   70|  3.44k|std::string X509_Certificate::PEM_label() const {
   71|  3.44k|   return "CERTIFICATE";
   72|  3.44k|}
_ZNK5Botan16X509_Certificate20alternate_PEM_labelsEv:
   74|     78|std::vector<std::string> X509_Certificate::alternate_PEM_labels() const {
   75|     78|   return {"X509 CERTIFICATE"};
   76|     78|}
_ZN5Botan16X509_CertificateC2ERNS_10DataSourceE:
   78|  10.0k|X509_Certificate::X509_Certificate(DataSource& src) {
   79|  10.0k|   load_data(src);
   80|  10.0k|}
_ZN5Botan16X509_Certificate12force_decodeEv:
  282|  6.18k|void X509_Certificate::force_decode() {
  283|  6.18k|   m_data.reset();
  284|  6.18k|   m_data = parse_x509_cert_body(*this);
  285|  6.18k|}
_ZNK5Botan16X509_Certificate4dataEv:
  287|  15.4k|const X509_Certificate_Data& X509_Certificate::data() const {
  288|  15.4k|   if(m_data == nullptr) {
  ------------------
  |  Branch (288:7): [True: 0, False: 15.4k]
  ------------------
  289|      0|      throw Invalid_State("X509_Certificate uninitialized");
  290|      0|   }
  291|  15.4k|   return *m_data;
  292|  15.4k|}
_ZNK5Botan16X509_Certificate12x509_versionEv:
  294|    580|uint32_t X509_Certificate::x509_version() const {
  295|    580|   return static_cast<uint32_t>(data().m_version);
  296|    580|}
_ZNK5Botan16X509_Certificate14is_self_signedEv:
  298|  2.04k|bool X509_Certificate::is_self_signed() const {
  299|  2.04k|   return data().m_self_signed;
  300|  2.04k|}
_ZNK5Botan16X509_Certificate10not_beforeEv:
  302|    510|const X509_Time& X509_Certificate::not_before() const {
  303|    510|   return data().m_not_before;
  304|    510|}
_ZNK5Botan16X509_Certificate9not_afterEv:
  306|    510|const X509_Time& X509_Certificate::not_after() const {
  307|    510|   return data().m_not_after;
  308|    510|}
_ZNK5Botan16X509_Certificate16v2_issuer_key_idEv:
  314|    118|const std::vector<uint8_t>& X509_Certificate::v2_issuer_key_id() const {
  315|    118|   return data().m_v2_issuer_key_id;
  316|    118|}
_ZNK5Botan16X509_Certificate17v2_subject_key_idEv:
  318|    114|const std::vector<uint8_t>& X509_Certificate::v2_subject_key_id() const {
  319|    114|   return data().m_v2_subject_key_id;
  320|    114|}
_ZNK5Botan16X509_Certificate23subject_public_key_infoEv:
  326|    510|const std::vector<uint8_t>& X509_Certificate::subject_public_key_info() const {
  327|    510|   return data().m_subject_public_key_bits_seq;
  328|    510|}
_ZNK5Botan16X509_Certificate16authority_key_idEv:
  342|  1.05k|const std::vector<uint8_t>& X509_Certificate::authority_key_id() const {
  343|  1.05k|   return data().m_authority_key_id;
  344|  1.05k|}
_ZNK5Botan16X509_Certificate14subject_key_idEv:
  346|     29|const std::vector<uint8_t>& X509_Certificate::subject_key_id() const {
  347|     29|   return data().m_subject_key_id;
  348|     29|}
_ZNK5Botan16X509_Certificate18is_serial_negativeEv:
  354|    510|bool X509_Certificate::is_serial_negative() const {
  355|    510|   return data().m_serial_negative;
  356|    510|}
_ZNK5Botan16X509_Certificate9issuer_dnEv:
  358|  1.42k|const X509_DN& X509_Certificate::issuer_dn() const {
  359|  1.42k|   return data().m_issuer_dn;
  360|  1.42k|}
_ZNK5Botan16X509_Certificate10subject_dnEv:
  362|  1.91k|const X509_DN& X509_Certificate::subject_dn() const {
  363|  1.91k|   return data().m_subject_dn;
  364|  1.91k|}
_ZNK5Botan16X509_Certificate10is_CA_certEv:
  374|    521|bool X509_Certificate::is_CA_cert() const {
  375|    521|   if(data().m_version < 3 && data().m_self_signed) {
  ------------------
  |  Branch (375:7): [True: 219, False: 302]
  |  Branch (375:31): [True: 215, False: 4]
  ------------------
  376|    215|      return true;
  377|    215|   }
  378|       |
  379|    306|   return data().m_is_ca_certificate;
  380|    521|}
_ZNK5Botan16X509_Certificate10path_limitEv:
  382|    356|uint32_t X509_Certificate::path_limit() const {
  383|    356|   if(data().m_version < 3 && data().m_self_signed) {
  ------------------
  |  Branch (383:7): [True: 134, False: 222]
  |  Branch (383:31): [True: 134, False: 0]
  ------------------
  384|    134|      return 32;  // in theory infinite, but this is more than enough
  385|    134|   }
  386|       |
  387|    222|   return static_cast<uint32_t>(data().m_path_len_constraint);
  388|    356|}
_ZNK5Botan16X509_Certificate11constraintsEv:
  390|    365|Key_Constraints X509_Certificate::constraints() const {
  391|    365|   return data().m_key_constraints;
  392|    365|}
_ZNK5Botan16X509_Certificate13v3_extensionsEv:
  406|    290|const Extensions& X509_Certificate::v3_extensions() const {
  407|    290|   return data().m_v3_extensions;
  408|    290|}
_ZNK5Botan16X509_Certificate15has_constraintsENS_15Key_ConstraintsE:
  410|    365|bool X509_Certificate::has_constraints(Key_Constraints usage) const {
  411|       |   // Unlike allowed_usage, returns false if constraints was not set
  412|    365|   return constraints().includes(usage);
  413|    365|}
_ZNK5Botan16X509_Certificate13allowed_usageENS_10Usage_TypeE:
  439|    365|bool X509_Certificate::allowed_usage(Usage_Type usage) const {
  440|       |   // These follow suggestions in RFC 5280 4.2.1.12
  441|       |
  442|    365|   switch(usage) {
  ------------------
  |  Branch (442:11): [True: 0, False: 365]
  ------------------
  443|    365|      case Usage_Type::UNSPECIFIED:
  ------------------
  |  Branch (443:7): [True: 365, False: 0]
  ------------------
  444|    365|         return true;
  445|       |
  446|      0|      case Usage_Type::TLS_SERVER_AUTH:
  ------------------
  |  Branch (446:7): [True: 0, False: 365]
  ------------------
  447|      0|         return (allowed_usage(Key_Constraints::KeyAgreement) || allowed_usage(Key_Constraints::KeyEncipherment) ||
  ------------------
  |  Branch (447:18): [True: 0, False: 0]
  |  Branch (447:66): [True: 0, False: 0]
  ------------------
  448|      0|                 allowed_usage(Key_Constraints::DigitalSignature)) &&
  ------------------
  |  Branch (448:18): [True: 0, False: 0]
  ------------------
  449|      0|                allowed_extended_usage("PKIX.ServerAuth");
  ------------------
  |  Branch (449:17): [True: 0, False: 0]
  ------------------
  450|       |
  451|      0|      case Usage_Type::TLS_CLIENT_AUTH:
  ------------------
  |  Branch (451:7): [True: 0, False: 365]
  ------------------
  452|      0|         return (allowed_usage(Key_Constraints::DigitalSignature) || allowed_usage(Key_Constraints::KeyAgreement)) &&
  ------------------
  |  Branch (452:18): [True: 0, False: 0]
  |  Branch (452:70): [True: 0, False: 0]
  ------------------
  453|      0|                allowed_extended_usage("PKIX.ClientAuth");
  ------------------
  |  Branch (453:17): [True: 0, False: 0]
  ------------------
  454|       |
  455|      0|      case Usage_Type::OCSP_RESPONDER:
  ------------------
  |  Branch (455:7): [True: 0, False: 365]
  ------------------
  456|      0|         return (allowed_usage(Key_Constraints::DigitalSignature) || allowed_usage(Key_Constraints::NonRepudiation)) &&
  ------------------
  |  Branch (456:18): [True: 0, False: 0]
  |  Branch (456:70): [True: 0, False: 0]
  ------------------
  457|      0|                has_ex_constraint("PKIX.OCSPSigning");
  ------------------
  |  Branch (457:17): [True: 0, False: 0]
  ------------------
  458|       |
  459|      0|      case Usage_Type::CERTIFICATE_AUTHORITY:
  ------------------
  |  Branch (459:7): [True: 0, False: 365]
  ------------------
  460|      0|         return is_CA_cert();
  461|       |
  462|      0|      case Usage_Type::ENCRYPTION:
  ------------------
  |  Branch (462:7): [True: 0, False: 365]
  ------------------
  463|      0|         return (allowed_usage(Key_Constraints::KeyEncipherment) || allowed_usage(Key_Constraints::DataEncipherment));
  ------------------
  |  Branch (463:18): [True: 0, False: 0]
  |  Branch (463:69): [True: 0, False: 0]
  ------------------
  464|    365|   }
  465|       |
  466|      0|   return false;
  467|    365|}
_ZNK5Botan16X509_Certificate18subject_public_keyEv:
  546|    510|std::unique_ptr<Public_Key> X509_Certificate::subject_public_key() const {
  547|    510|   try {
  548|    510|      return std::unique_ptr<Public_Key>(X509::load_key(subject_public_key_info()));
  549|    510|   } catch(std::exception& e) {
  550|    220|      throw Decoding_Error("X509_Certificate::subject_public_key", e);
  551|    220|   }
  552|    510|}
_ZNK5Botan16X509_Certificate11fingerprintENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  572|  1.84k|std::string X509_Certificate::fingerprint(std::string_view hash_name) const {
  573|       |   /*
  574|       |   * The SHA-1 and SHA-256 fingerprints are precomputed since these
  575|       |   * are the most commonly used. Especially, SHA-256 fingerprints are
  576|       |   * used for cycle detection during path construction.
  577|       |   *
  578|       |   * If SHA-1 or SHA-256 was missing at parsing time the vectors are
  579|       |   * left empty in which case we fall back to create_hex_fingerprint
  580|       |   * which will throw if the hash is unavailable.
  581|       |   */
  582|  1.84k|   if(hash_name == "SHA-256" && !data().m_fingerprint_sha256.empty()) {
  ------------------
  |  Branch (582:7): [True: 1.84k, False: 0]
  |  Branch (582:33): [True: 1.84k, False: 0]
  ------------------
  583|  1.84k|      return data().m_fingerprint_sha256;
  584|  1.84k|   } else if(hash_name == "SHA-1" && !data().m_fingerprint_sha1.empty()) {
  ------------------
  |  Branch (584:14): [True: 0, False: 0]
  |  Branch (584:38): [True: 0, False: 0]
  ------------------
  585|      0|      return data().m_fingerprint_sha1;
  586|      0|   } else {
  587|      0|      return create_hex_fingerprint(this->BER_encode(), hash_name);
  588|      0|   }
  589|  1.84k|}
x509cert.cpp:_ZN5Botan12_GLOBAL__N_120parse_x509_cert_bodyERKNS_11X509_ObjectE:
  101|  6.18k|std::unique_ptr<X509_Certificate_Data> parse_x509_cert_body(const X509_Object& obj) {
  102|  6.18k|   auto data = std::make_unique<X509_Certificate_Data>();
  103|       |
  104|  6.18k|   BigInt serial_bn;
  105|  6.18k|   BER_Object public_key;
  106|  6.18k|   BER_Object v3_exts_data;
  107|       |
  108|  6.18k|   BER_Decoder(obj.signed_body())
  109|  6.18k|      .decode_optional(data->m_version, ASN1_Type(0), ASN1_Class::Constructed | ASN1_Class::ContextSpecific)
  110|  6.18k|      .decode(serial_bn)
  111|  6.18k|      .decode(data->m_sig_algo_inner)
  112|  6.18k|      .decode(data->m_issuer_dn)
  113|  6.18k|      .start_sequence()
  114|  6.18k|      .decode(data->m_not_before)
  115|  6.18k|      .decode(data->m_not_after)
  116|  6.18k|      .end_cons()
  117|  6.18k|      .decode(data->m_subject_dn)
  118|  6.18k|      .get_next(public_key)
  119|  6.18k|      .decode_optional_string(data->m_v2_issuer_key_id, ASN1_Type::BitString, 1)
  120|  6.18k|      .decode_optional_string(data->m_v2_subject_key_id, ASN1_Type::BitString, 2)
  121|  6.18k|      .get_next(v3_exts_data)
  122|  6.18k|      .verify_end("TBSCertificate has extra data after extensions block");
  123|       |
  124|  6.18k|   if(data->m_version > 2) {
  ------------------
  |  Branch (124:7): [True: 31, False: 6.15k]
  ------------------
  125|     31|      throw Decoding_Error("Unknown X.509 cert version " + std::to_string(data->m_version));
  126|     31|   }
  127|  6.15k|   if(obj.signature_algorithm() != data->m_sig_algo_inner) {
  ------------------
  |  Branch (127:7): [True: 59, False: 6.09k]
  ------------------
  128|     59|      throw Decoding_Error("X.509 Certificate had differing algorithm identifers in inner and outer ID fields");
  129|     59|   }
  130|       |
  131|  6.09k|   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|  6.09k|   data->m_serial_negative = serial_bn.is_negative();
  135|       |
  136|       |   // for general sanity convert wire version (0 based) to standards version (v1 .. v3)
  137|  6.09k|   data->m_version += 1;
  138|       |
  139|  6.09k|   data->m_serial = BigInt::encode(serial_bn);
  140|  6.09k|   data->m_subject_dn_bits = ASN1::put_in_sequence(data->m_subject_dn.get_bits());
  141|  6.09k|   data->m_issuer_dn_bits = ASN1::put_in_sequence(data->m_issuer_dn.get_bits());
  142|       |
  143|  6.09k|   data->m_subject_public_key_bits.assign(public_key.bits(), public_key.bits() + public_key.length());
  144|       |
  145|  6.09k|   data->m_subject_public_key_bits_seq = ASN1::put_in_sequence(data->m_subject_public_key_bits);
  146|       |
  147|  6.09k|   BER_Decoder(data->m_subject_public_key_bits)
  148|  6.09k|      .decode(data->m_subject_public_key_algid)
  149|  6.09k|      .decode(data->m_subject_public_key_bitstring, ASN1_Type::BitString);
  150|       |
  151|  6.09k|   if(v3_exts_data.is_a(3, ASN1_Class::Constructed | ASN1_Class::ContextSpecific)) {
  ------------------
  |  Branch (151:7): [True: 2.22k, False: 3.87k]
  ------------------
  152|       |      // Path validation will reject a v1/v2 cert with v3 extensions
  153|  2.22k|      BER_Decoder(v3_exts_data).decode(data->m_v3_extensions).verify_end();
  154|  3.87k|   } else if(v3_exts_data.is_set()) {
  ------------------
  |  Branch (154:14): [True: 55, False: 3.81k]
  ------------------
  155|     55|      throw BER_Bad_Tag("Unknown tag in X.509 cert", v3_exts_data.tagging());
  156|     55|   }
  157|       |
  158|       |   // Now cache some fields from the extensions
  159|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Key_Usage>()) {
  ------------------
  |  Branch (159:12): [True: 213, False: 5.82k]
  ------------------
  160|    213|      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|    213|      if(data->m_key_constraints.empty()) {
  ------------------
  |  Branch (165:10): [True: 1, False: 212]
  ------------------
  166|      1|         throw Decoding_Error("Certificate has invalid encoding for KeyUsage");
  167|      1|      }
  168|    213|   }
  169|       |
  170|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Key_ID>()) {
  ------------------
  |  Branch (170:12): [True: 316, False: 5.72k]
  ------------------
  171|    316|      data->m_subject_key_id = ext->get_key_id();
  172|    316|   }
  173|       |
  174|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Key_ID>()) {
  ------------------
  |  Branch (174:12): [True: 153, False: 5.88k]
  ------------------
  175|    153|      data->m_authority_key_id = ext->get_key_id();
  176|    153|   }
  177|       |
  178|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Name_Constraints>()) {
  ------------------
  |  Branch (178:12): [True: 7, False: 6.03k]
  ------------------
  179|      7|      data->m_name_constraints = ext->get_name_constraints();
  180|      7|   }
  181|       |
  182|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Basic_Constraints>()) {
  ------------------
  |  Branch (182:12): [True: 241, False: 5.79k]
  ------------------
  183|    241|      if(ext->get_is_ca() == true) {
  ------------------
  |  Branch (183:10): [True: 173, False: 68]
  ------------------
  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|    173|         if(data->m_key_constraints.empty() || data->m_key_constraints.includes(Key_Constraints::KeyCertSign)) {
  ------------------
  |  Branch (191:13): [True: 100, False: 73]
  |  Branch (191:48): [True: 61, False: 12]
  ------------------
  192|    161|            data->m_is_ca_certificate = true;
  193|    161|            data->m_path_len_constraint = ext->get_path_limit();
  194|    161|         }
  195|    173|      }
  196|    241|   }
  197|       |
  198|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Issuer_Alternative_Name>()) {
  ------------------
  |  Branch (198:12): [True: 34, False: 6.00k]
  ------------------
  199|     34|      data->m_issuer_alt_name = ext->get_alt_name();
  200|     34|   }
  201|       |
  202|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Subject_Alternative_Name>()) {
  ------------------
  |  Branch (202:12): [True: 156, False: 5.88k]
  ------------------
  203|    156|      data->m_subject_alt_name = ext->get_alt_name();
  204|    156|   }
  205|       |
  206|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Extended_Key_Usage>()) {
  ------------------
  |  Branch (206:12): [True: 76, False: 5.96k]
  ------------------
  207|     76|      data->m_extended_key_usage = ext->object_identifiers();
  208|     76|   }
  209|       |
  210|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Certificate_Policies>()) {
  ------------------
  |  Branch (210:12): [True: 63, False: 5.97k]
  ------------------
  211|     63|      data->m_cert_policies = ext->get_policy_oids();
  212|     63|   }
  213|       |
  214|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::Authority_Information_Access>()) {
  ------------------
  |  Branch (214:12): [True: 46, False: 5.99k]
  ------------------
  215|     46|      data->m_ocsp_responder = ext->ocsp_responder();
  216|     46|      data->m_ca_issuers = ext->ca_issuers();
  217|     46|   }
  218|       |
  219|  6.03k|   if(auto ext = data->m_v3_extensions.get_extension_object_as<Cert_Extension::CRL_Distribution_Points>()) {
  ------------------
  |  Branch (219:12): [True: 72, False: 5.96k]
  ------------------
  220|     72|      data->m_crl_distribution_points = ext->crl_distribution_urls();
  221|     72|   }
  222|       |
  223|       |   // Check for self-signed vs self-issued certificates
  224|  6.03k|   if(data->m_subject_dn == data->m_issuer_dn) {
  ------------------
  |  Branch (224:7): [True: 3.44k, False: 2.59k]
  ------------------
  225|  3.44k|      if(data->m_subject_key_id.empty() == false && data->m_authority_key_id.empty() == false) {
  ------------------
  |  Branch (225:10): [True: 209, False: 3.23k]
  |  Branch (225:53): [True: 86, False: 123]
  ------------------
  226|     86|         data->m_self_signed = (data->m_subject_key_id == data->m_authority_key_id);
  227|  3.36k|      } 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|  3.36k|         data->m_self_signed = true;
  234|       |
  235|  3.36k|         try {
  236|  3.36k|            auto pub_key = X509::load_key(data->m_subject_public_key_bits_seq);
  237|       |
  238|  3.36k|            const auto sig_status = obj.verify_signature(*pub_key);
  239|       |
  240|  3.36k|            if(sig_status.first == Certificate_Status_Code::OK ||
  ------------------
  |  Branch (240:16): [True: 1.61k, False: 1.74k]
  ------------------
  241|  3.36k|               sig_status.first == Certificate_Status_Code::SIGNATURE_ALGO_UNKNOWN) {
  ------------------
  |  Branch (241:16): [True: 93, False: 1.65k]
  ------------------
  242|    107|               data->m_self_signed = true;
  243|  3.25k|            } else {
  244|  3.25k|               data->m_self_signed = false;
  245|  3.25k|            }
  246|  3.36k|         } catch(...) {
  247|       |            // ignore errors here to allow parsing to continue
  248|  1.59k|         }
  249|  3.36k|      }
  250|  3.44k|   }
  251|       |
  252|  6.03k|   const std::vector<uint8_t> full_encoding = obj.BER_encode();
  253|       |
  254|  6.03k|   auto sha1 = HashFunction::create("SHA-1");
  255|  6.03k|   if(sha1) {
  ------------------
  |  Branch (255:7): [True: 4.45k, False: 1.58k]
  ------------------
  256|  4.45k|      sha1->update(data->m_subject_public_key_bitstring);
  257|  4.45k|      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|  4.45k|      data->m_fingerprint_sha1 = create_hex_fingerprint(full_encoding, "SHA-1");
  261|  4.45k|   }
  262|       |
  263|  6.03k|   auto sha256 = HashFunction::create("SHA-256");
  264|  6.03k|   if(sha256) {
  ------------------
  |  Branch (264:7): [True: 4.45k, False: 1.58k]
  ------------------
  265|  4.45k|      sha256->update(data->m_issuer_dn_bits);
  266|  4.45k|      data->m_issuer_dn_bits_sha256 = sha256->final_stdvec();
  267|       |
  268|  4.45k|      sha256->update(data->m_subject_dn_bits);
  269|  4.45k|      data->m_subject_dn_bits_sha256 = sha256->final_stdvec();
  270|       |
  271|  4.45k|      data->m_fingerprint_sha256 = create_hex_fingerprint(full_encoding, "SHA-256");
  272|  4.45k|   }
  273|       |
  274|  6.03k|   return data;
  275|  6.03k|}

_ZN5Botan4PKIX11check_chainERKNSt3__16vectorINS_16X509_CertificateENS1_9allocatorIS3_EEEENS1_6chrono10time_pointINS9_12system_clockENS9_8durationIxNS1_5ratioILl1ELl1000000EEEEEEENS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_10Usage_TypeERKNS_28Path_Validation_RestrictionsE:
   40|    365|                                             const Path_Validation_Restrictions& restrictions) {
   41|    365|   if(cert_path.empty()) {
  ------------------
  |  Branch (41:7): [True: 0, False: 365]
  ------------------
   42|      0|      throw Invalid_Argument("PKIX::check_chain cert_path empty");
   43|      0|   }
   44|       |
   45|    365|   const bool self_signed_ee_cert = (cert_path.size() == 1);
   46|       |
   47|    365|   X509_Time validation_time(ref_time);
   48|       |
   49|    365|   CertificatePathStatusCodes cert_status(cert_path.size());
   50|       |
   51|    365|   if(!hostname.empty() && !cert_path[0].matches_dns_name(hostname)) {
  ------------------
  |  Branch (51:7): [True: 0, False: 365]
  |  Branch (51:28): [True: 0, False: 0]
  ------------------
   52|      0|      cert_status[0].insert(Certificate_Status_Code::CERT_NAME_NOMATCH);
   53|      0|   }
   54|       |
   55|    365|   if(!cert_path[0].allowed_usage(usage)) {
  ------------------
  |  Branch (55:7): [True: 0, False: 365]
  ------------------
   56|      0|      if(usage == Usage_Type::OCSP_RESPONDER) {
  ------------------
  |  Branch (56:10): [True: 0, False: 0]
  ------------------
   57|      0|         cert_status[0].insert(Certificate_Status_Code::OCSP_RESPONSE_MISSING_KEYUSAGE);
   58|      0|      }
   59|      0|      cert_status[0].insert(Certificate_Status_Code::INVALID_USAGE);
   60|      0|   }
   61|       |
   62|    365|   if(cert_path[0].has_constraints(Key_Constraints::KeyCertSign) && cert_path[0].is_CA_cert() == false) {
  ------------------
  |  Branch (62:7): [True: 11, False: 354]
  |  Branch (62:69): [True: 10, False: 1]
  ------------------
   63|       |      /*
   64|       |      "If the keyCertSign bit is asserted, then the cA bit in the
   65|       |      basic constraints extension (Section 4.2.1.9) MUST also be
   66|       |      asserted." - RFC 5280
   67|       |
   68|       |      We don't bother doing this check on the rest of the path since they
   69|       |      must have the cA bit asserted or the validation will fail anyway.
   70|       |      */
   71|     10|      cert_status[0].insert(Certificate_Status_Code::INVALID_USAGE);
   72|     10|   }
   73|       |
   74|    875|   for(size_t i = 0; i != cert_path.size(); ++i) {
  ------------------
  |  Branch (74:22): [True: 510, False: 365]
  ------------------
   75|    510|      std::set<Certificate_Status_Code>& status = cert_status.at(i);
   76|       |
   77|    510|      const bool at_self_signed_root = (i == cert_path.size() - 1);
   78|       |
   79|    510|      const X509_Certificate& subject = cert_path[i];
   80|    510|      const X509_Certificate& issuer = cert_path[at_self_signed_root ? (i) : (i + 1)];
  ------------------
  |  Branch (80:50): [True: 145, False: 365]
  ------------------
   81|       |
   82|    510|      if(at_self_signed_root && (issuer.is_self_signed() == false)) {
  ------------------
  |  Branch (82:10): [True: 145, False: 365]
  |  Branch (82:33): [True: 0, False: 145]
  ------------------
   83|      0|         status.insert(Certificate_Status_Code::CHAIN_LACKS_TRUST_ROOT);
   84|      0|      }
   85|       |
   86|    510|      if(subject.issuer_dn() != issuer.subject_dn()) {
  ------------------
  |  Branch (86:10): [True: 0, False: 510]
  ------------------
   87|      0|         status.insert(Certificate_Status_Code::CHAIN_NAME_MISMATCH);
   88|      0|      }
   89|       |
   90|       |      // Check the serial number
   91|    510|      if(subject.is_serial_negative()) {
  ------------------
  |  Branch (91:10): [True: 141, False: 369]
  ------------------
   92|    141|         status.insert(Certificate_Status_Code::CERT_SERIAL_NEGATIVE);
   93|    141|      }
   94|       |
   95|       |      // Check the subject's DN components' length
   96|       |
   97|  1.01k|      for(const auto& dn_pair : subject.subject_dn().dn_info()) {
  ------------------
  |  Branch (97:31): [True: 1.01k, False: 510]
  ------------------
   98|  1.01k|         const size_t dn_ub = X509_DN::lookup_ub(dn_pair.first);
   99|       |         // dn_pair = <OID,str>
  100|  1.01k|         if(dn_ub > 0 && dn_pair.second.size() > dn_ub) {
  ------------------
  |  Branch (100:13): [True: 634, False: 379]
  |  Branch (100:26): [True: 39, False: 595]
  ------------------
  101|     39|            status.insert(Certificate_Status_Code::DN_TOO_LONG);
  102|     39|         }
  103|  1.01k|      }
  104|       |
  105|       |      // Check all certs for valid time range
  106|    510|      if(validation_time < subject.not_before()) {
  ------------------
  |  Branch (106:10): [True: 105, False: 405]
  ------------------
  107|    105|         status.insert(Certificate_Status_Code::CERT_NOT_YET_VALID);
  108|    105|      }
  109|       |
  110|    510|      if(validation_time > subject.not_after()) {
  ------------------
  |  Branch (110:10): [True: 308, False: 202]
  ------------------
  111|    308|         status.insert(Certificate_Status_Code::CERT_HAS_EXPIRED);
  112|    308|      }
  113|       |
  114|       |      // Check issuer constraints
  115|    510|      if(!issuer.is_CA_cert() && !self_signed_ee_cert) {
  ------------------
  |  Branch (115:10): [True: 262, False: 248]
  |  Branch (115:34): [True: 262, False: 0]
  ------------------
  116|    262|         status.insert(Certificate_Status_Code::CA_CERT_NOT_FOR_CERT_ISSUER);
  117|    262|      }
  118|       |
  119|    510|      auto issuer_key = issuer.subject_public_key();
  120|       |
  121|       |      // Check the signature algorithm is known
  122|    510|      if(!subject.signature_algorithm().oid().registered_oid()) {
  ------------------
  |  Branch (122:10): [True: 12, False: 498]
  ------------------
  123|     12|         status.insert(Certificate_Status_Code::SIGNATURE_ALGO_UNKNOWN);
  124|    498|      } else {
  125|       |         // only perform the following checks if the signature algorithm is known
  126|    498|         if(!issuer_key) {
  ------------------
  |  Branch (126:13): [True: 0, False: 498]
  ------------------
  127|      0|            status.insert(Certificate_Status_Code::CERT_PUBKEY_INVALID);
  128|    498|         } else {
  129|    498|            const auto sig_status = subject.verify_signature(*issuer_key);
  130|       |
  131|    498|            if(sig_status.first == Certificate_Status_Code::VERIFIED) {
  ------------------
  |  Branch (131:16): [True: 8, False: 490]
  ------------------
  132|      8|               const std::string hash_used_for_signature = sig_status.second;
  133|      8|               BOTAN_ASSERT_NOMSG(!hash_used_for_signature.empty());
  ------------------
  |  |   60|      8|   do {                                                                     \
  |  |   61|      8|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 8]
  |  |  ------------------
  |  |   62|      8|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|      8|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  134|      8|               const auto& trusted_hashes = restrictions.trusted_hashes();
  135|       |
  136|       |               // Ignore untrusted hashes on self-signed roots
  137|      8|               if(!trusted_hashes.empty() && !at_self_signed_root) {
  ------------------
  |  Branch (137:19): [True: 8, False: 0]
  |  Branch (137:46): [True: 0, False: 8]
  ------------------
  138|      0|                  if(!trusted_hashes.contains(hash_used_for_signature)) {
  ------------------
  |  Branch (138:22): [True: 0, False: 0]
  ------------------
  139|      0|                     status.insert(Certificate_Status_Code::UNTRUSTED_HASH);
  140|      0|                  }
  141|      0|               }
  142|    490|            } else {
  143|    490|               status.insert(sig_status.first);
  144|    490|            }
  145|       |
  146|    498|            if(issuer_key->estimated_strength() < restrictions.minimum_key_strength()) {
  ------------------
  |  Branch (146:16): [True: 208, False: 290]
  ------------------
  147|    208|               status.insert(Certificate_Status_Code::SIGNATURE_METHOD_TOO_WEAK);
  148|    208|            }
  149|    498|         }
  150|    498|      }
  151|       |
  152|       |      // Check cert extensions
  153|       |
  154|    510|      if(subject.x509_version() == 1) {
  ------------------
  |  Branch (154:10): [True: 118, False: 392]
  ------------------
  155|    118|         if(subject.v2_issuer_key_id().empty() == false || subject.v2_subject_key_id().empty() == false) {
  ------------------
  |  Branch (155:13): [True: 4, False: 114]
  |  Branch (155:60): [True: 8, False: 106]
  ------------------
  156|     12|            status.insert(Certificate_Status_Code::V2_IDENTIFIERS_IN_V1_CERT);
  157|     12|         }
  158|    118|      }
  159|       |
  160|    510|      const Extensions& extensions = subject.v3_extensions();
  161|    510|      const auto& extensions_vec = extensions.extensions();
  162|    510|      if(subject.x509_version() < 3 && !extensions_vec.empty()) {
  ------------------
  |  Branch (162:10): [True: 137, False: 373]
  |  Branch (162:40): [True: 96, False: 41]
  ------------------
  163|     96|         status.insert(Certificate_Status_Code::EXT_IN_V1_V2_CERT);
  164|     96|      }
  165|    645|      for(auto& extension : extensions_vec) {
  ------------------
  |  Branch (165:27): [True: 645, False: 510]
  ------------------
  166|    645|         extension.first->validate(subject, issuer, cert_path, cert_status, i);
  167|    645|      }
  168|    510|      if(extensions_vec.size() != extensions.get_extension_oids().size()) {
  ------------------
  |  Branch (168:10): [True: 20, False: 490]
  ------------------
  169|     20|         status.insert(Certificate_Status_Code::DUPLICATE_CERT_EXTENSION);
  170|     20|      }
  171|    510|   }
  172|       |
  173|       |   // path len check
  174|    365|   size_t max_path_length = cert_path.size();
  175|    510|   for(size_t i = cert_path.size() - 1; i > 0; --i) {
  ------------------
  |  Branch (175:41): [True: 145, False: 365]
  ------------------
  176|    145|      std::set<Certificate_Status_Code>& status = cert_status.at(i);
  177|    145|      const X509_Certificate& subject = cert_path[i];
  178|       |
  179|       |      /*
  180|       |      * If the certificate was not self-issued, verify that max_path_length is
  181|       |      * greater than zero and decrement max_path_length by 1.
  182|       |      */
  183|    145|      if(subject.subject_dn() != subject.issuer_dn()) {
  ------------------
  |  Branch (183:10): [True: 0, False: 145]
  ------------------
  184|      0|         if(max_path_length > 0) {
  ------------------
  |  Branch (184:13): [True: 0, False: 0]
  ------------------
  185|      0|            --max_path_length;
  186|      0|         } else {
  187|      0|            status.insert(Certificate_Status_Code::CERT_CHAIN_TOO_LONG);
  188|      0|         }
  189|      0|      }
  190|       |
  191|       |      /*
  192|       |      * If pathLenConstraint is present in the certificate and is less than max_path_length,
  193|       |      * set max_path_length to the value of pathLenConstraint.
  194|       |      */
  195|    145|      if(subject.path_limit() != Cert_Extension::NO_CERT_PATH_LIMIT && subject.path_limit() < max_path_length) {
  ------------------
  |  Branch (195:10): [True: 144, False: 1]
  |  Branch (195:72): [True: 67, False: 77]
  ------------------
  196|     67|         max_path_length = subject.path_limit();
  197|     67|      }
  198|    145|   }
  199|       |
  200|    365|   return cert_status;
  201|    365|}
_ZN5Botan4PKIX9check_crlERKNSt3__16vectorINS_16X509_CertificateENS1_9allocatorIS3_EEEERKNS2_INS1_8optionalINS_8X509_CRLEEENS4_ISB_EEEENS1_6chrono10time_pointINSG_12system_clockENSG_8durationIxNS1_5ratioILl1ELl1000000EEEEEEE:
  323|    145|                                           std::chrono::system_clock::time_point ref_time) {
  324|    145|   if(cert_path.empty()) {
  ------------------
  |  Branch (324:7): [True: 0, False: 145]
  ------------------
  325|      0|      throw Invalid_Argument("PKIX::check_crl cert_path empty");
  326|      0|   }
  327|       |
  328|    145|   CertificatePathStatusCodes cert_status(cert_path.size());
  329|    145|   const X509_Time validation_time(ref_time);
  330|       |
  331|    290|   for(size_t i = 0; i != cert_path.size() - 1; ++i) {
  ------------------
  |  Branch (331:22): [True: 145, False: 145]
  ------------------
  332|    145|      std::set<Certificate_Status_Code>& status = cert_status.at(i);
  333|       |
  334|    145|      if(i < crls.size() && crls[i].has_value()) {
  ------------------
  |  Branch (334:10): [True: 145, False: 0]
  |  Branch (334:29): [True: 0, False: 145]
  ------------------
  335|      0|         const X509_Certificate& subject = cert_path.at(i);
  336|      0|         const X509_Certificate& ca = cert_path.at(i + 1);
  337|       |
  338|      0|         if(!ca.allowed_usage(Key_Constraints::CrlSign)) {
  ------------------
  |  Branch (338:13): [True: 0, False: 0]
  ------------------
  339|      0|            status.insert(Certificate_Status_Code::CA_CERT_NOT_FOR_CRL_ISSUER);
  340|      0|         }
  341|       |
  342|      0|         if(validation_time < crls[i]->this_update()) {
  ------------------
  |  Branch (342:13): [True: 0, False: 0]
  ------------------
  343|      0|            status.insert(Certificate_Status_Code::CRL_NOT_YET_VALID);
  344|      0|         }
  345|       |
  346|      0|         if(validation_time > crls[i]->next_update()) {
  ------------------
  |  Branch (346:13): [True: 0, False: 0]
  ------------------
  347|      0|            status.insert(Certificate_Status_Code::CRL_HAS_EXPIRED);
  348|      0|         }
  349|       |
  350|      0|         auto ca_key = ca.subject_public_key();
  351|      0|         if(crls[i]->check_signature(*ca_key) == false) {
  ------------------
  |  Branch (351:13): [True: 0, False: 0]
  ------------------
  352|      0|            status.insert(Certificate_Status_Code::CRL_BAD_SIGNATURE);
  353|      0|         }
  354|       |
  355|      0|         status.insert(Certificate_Status_Code::VALID_CRL_CHECKED);
  356|       |
  357|      0|         if(crls[i]->is_revoked(subject)) {
  ------------------
  |  Branch (357:13): [True: 0, False: 0]
  ------------------
  358|      0|            status.insert(Certificate_Status_Code::CERT_IS_REVOKED);
  359|      0|         }
  360|       |
  361|      0|         std::string dp = subject.crl_distribution_point();
  362|      0|         if(!dp.empty()) {
  ------------------
  |  Branch (362:13): [True: 0, False: 0]
  ------------------
  363|      0|            if(dp != crls[i]->crl_issuing_distribution_point()) {
  ------------------
  |  Branch (363:16): [True: 0, False: 0]
  ------------------
  364|      0|               status.insert(Certificate_Status_Code::NO_MATCHING_CRLDP);
  365|      0|            }
  366|      0|         }
  367|       |
  368|      0|         for(const auto& extension : crls[i]->extensions().extensions()) {
  ------------------
  |  Branch (368:36): [True: 0, False: 0]
  ------------------
  369|       |            // XXX this is wrong - the OID might be defined but the extention not full parsed
  370|       |            // for example see #1652
  371|       |
  372|       |            // is the extension critical and unknown?
  373|      0|            if(extension.second && !extension.first->oid_of().registered_oid()) {
  ------------------
  |  Branch (373:16): [True: 0, False: 0]
  |  Branch (373:16): [True: 0, False: 0]
  |  Branch (373:36): [True: 0, False: 0]
  ------------------
  374|       |               /* NIST Certificate Path Valiadation Testing document: "When an implementation does not recognize a critical extension in the
  375|       |                * crlExtensions field, it shall assume that identified certificates have been revoked and are no longer valid"
  376|       |                */
  377|      0|               status.insert(Certificate_Status_Code::CERT_IS_REVOKED);
  378|      0|            }
  379|      0|         }
  380|      0|      }
  381|    145|   }
  382|       |
  383|    435|   while(!cert_status.empty() && cert_status.back().empty()) {
  ------------------
  |  Branch (383:10): [True: 290, False: 145]
  |  Branch (383:34): [True: 290, False: 0]
  ------------------
  384|    290|      cert_status.pop_back();
  385|    290|   }
  386|       |
  387|    145|   return cert_status;
  388|    145|}
_ZN5Botan4PKIX9check_crlERKNSt3__16vectorINS_16X509_CertificateENS1_9allocatorIS3_EEEERKNS2_IPNS_17Certificate_StoreENS4_ISA_EEEENS1_6chrono10time_pointINSF_12system_clockENSF_8durationIxNS1_5ratioILl1ELl1000000EEEEEEE:
  392|    145|                                           std::chrono::system_clock::time_point ref_time) {
  393|    145|   if(cert_path.empty()) {
  ------------------
  |  Branch (393:7): [True: 0, False: 145]
  ------------------
  394|      0|      throw Invalid_Argument("PKIX::check_crl cert_path empty");
  395|      0|   }
  396|       |
  397|    145|   if(certstores.empty()) {
  ------------------
  |  Branch (397:7): [True: 0, False: 145]
  ------------------
  398|      0|      throw Invalid_Argument("PKIX::check_crl certstores empty");
  399|      0|   }
  400|       |
  401|    145|   std::vector<std::optional<X509_CRL>> crls(cert_path.size());
  402|       |
  403|    435|   for(size_t i = 0; i != cert_path.size(); ++i) {
  ------------------
  |  Branch (403:22): [True: 290, False: 145]
  ------------------
  404|    290|      for(auto certstore : certstores) {
  ------------------
  |  Branch (404:26): [True: 290, False: 290]
  ------------------
  405|    290|         crls[i] = certstore->find_crl_for(cert_path[i]);
  406|    290|         if(crls[i]) {
  ------------------
  |  Branch (406:13): [True: 0, False: 290]
  ------------------
  407|      0|            break;
  408|      0|         }
  409|    290|      }
  410|    290|   }
  411|       |
  412|    145|   return PKIX::check_crl(cert_path, crls, ref_time);
  413|    145|}
_ZN5Botan4PKIX27build_all_certificate_pathsERNSt3__16vectorINS2_INS_16X509_CertificateENS1_9allocatorIS3_EEEENS4_IS6_EEEERKNS2_IPNS_17Certificate_StoreENS4_ISB_EEEERKNS1_8optionalIS3_EERKS6_:
  656|    762|                                                          const std::vector<X509_Certificate>& end_entity_extra) {
  657|    762|   if(!cert_paths_out.empty()) {
  ------------------
  |  Branch (657:7): [True: 0, False: 762]
  ------------------
  658|      0|      throw Invalid_Argument("PKIX::build_all_certificate_paths: cert_paths_out must be empty");
  659|      0|   }
  660|       |
  661|    762|   if(end_entity->is_self_signed()) {
  ------------------
  |  Branch (661:7): [True: 125, False: 637]
  ------------------
  662|    125|      return Certificate_Status_Code::CANNOT_ESTABLISH_TRUST;
  663|    125|   }
  664|       |
  665|       |   /*
  666|       |    * Pile up error messages
  667|       |    */
  668|    637|   std::vector<Certificate_Status_Code> stats;
  669|       |
  670|    637|   Certificate_Store_In_Memory ee_extras;
  671|    637|   for(const auto& cert : end_entity_extra) {
  ------------------
  |  Branch (671:25): [True: 0, False: 637]
  ------------------
  672|      0|      ee_extras.add_certificate(cert);
  673|      0|   }
  674|       |
  675|       |   /*
  676|       |   * This is an inelegant but functional way of preventing path loops
  677|       |   * (where C1 -> C2 -> C3 -> C1). We store a set of all the certificate
  678|       |   * fingerprints in the path. If there is a duplicate, we error out.
  679|       |   * TODO: save fingerprints in result struct? Maybe useful for blacklists, etc.
  680|       |   */
  681|    637|   std::set<std::string> certs_seen;
  682|       |
  683|       |   // new certs are added and removed from the path during the DFS
  684|       |   // it is copied into cert_paths_out when we encounter a trusted root
  685|    637|   std::vector<X509_Certificate> path_so_far;
  686|       |
  687|       |   // todo can we assume that the end certificate is not trusted?
  688|    637|   std::vector<cert_maybe_trusted> stack = {{end_entity, false}};
  689|       |
  690|  2.47k|   while(!stack.empty()) {
  ------------------
  |  Branch (690:10): [True: 1.84k, False: 637]
  ------------------
  691|  1.84k|      std::optional<X509_Certificate> last = stack.back().first;
  692|       |      // found a deletion marker that guides the DFS, backtracing
  693|  1.84k|      if(last == std::nullopt) {
  ------------------
  |  Branch (693:10): [True: 602, False: 1.23k]
  ------------------
  694|    602|         stack.pop_back();
  695|    602|         std::string fprint = path_so_far.back().fingerprint("SHA-256");
  696|    602|         certs_seen.erase(fprint);
  697|    602|         path_so_far.pop_back();
  698|    602|      }
  699|       |      // process next cert on the path
  700|  1.23k|      else {
  701|  1.23k|         const bool trusted = stack.back().second;
  702|  1.23k|         stack.pop_back();
  703|       |
  704|       |         // certificate already seen?
  705|  1.23k|         const std::string fprint = last->fingerprint("SHA-256");
  706|  1.23k|         if(certs_seen.count(fprint) == 1) {
  ------------------
  |  Branch (706:13): [True: 106, False: 1.13k]
  ------------------
  707|    106|            stats.push_back(Certificate_Status_Code::CERT_CHAIN_LOOP);
  708|       |            // the current path ended in a loop
  709|    106|            continue;
  710|    106|         }
  711|       |
  712|       |         // the current path ends here
  713|  1.13k|         if(last->is_self_signed()) {
  ------------------
  |  Branch (713:13): [True: 365, False: 768]
  ------------------
  714|       |            // found a trust anchor
  715|    365|            if(trusted) {
  ------------------
  |  Branch (715:16): [True: 365, False: 0]
  ------------------
  716|    365|               cert_paths_out.push_back(path_so_far);
  717|    365|               cert_paths_out.back().push_back(*last);
  718|       |
  719|    365|               continue;
  720|    365|            }
  721|       |            // found an untrustworthy root
  722|      0|            else {
  723|      0|               stats.push_back(Certificate_Status_Code::CANNOT_ESTABLISH_TRUST);
  724|      0|               continue;
  725|      0|            }
  726|    365|         }
  727|       |
  728|    768|         const X509_DN issuer_dn = last->issuer_dn();
  729|    768|         const std::vector<uint8_t> auth_key_id = last->authority_key_id();
  730|       |
  731|       |         // search for trusted issuers
  732|    768|         std::vector<X509_Certificate> trusted_issuers;
  733|    768|         for(Certificate_Store* store : trusted_certstores) {
  ------------------
  |  Branch (733:39): [True: 768, False: 768]
  ------------------
  734|    768|            auto new_issuers = store->find_all_certs(issuer_dn, auth_key_id);
  735|    768|            trusted_issuers.insert(trusted_issuers.end(), new_issuers.begin(), new_issuers.end());
  736|    768|         }
  737|       |
  738|       |         // search the supplemental certs
  739|    768|         std::vector<X509_Certificate> misc_issuers = ee_extras.find_all_certs(issuer_dn, auth_key_id);
  740|       |
  741|       |         // if we could not find any issuers, the current path ends here
  742|    768|         if(trusted_issuers.empty() && misc_issuers.empty()) {
  ------------------
  |  Branch (742:13): [True: 166, False: 602]
  |  Branch (742:40): [True: 166, False: 0]
  ------------------
  743|    166|            stats.push_back(Certificate_Status_Code::CERT_ISSUER_NOT_FOUND);
  744|    166|            continue;
  745|    166|         }
  746|       |
  747|       |         // push the latest certificate onto the path_so_far
  748|    602|         path_so_far.push_back(*last);
  749|    602|         certs_seen.emplace(fprint);
  750|       |
  751|       |         // push a deletion marker on the stack for backtracing later
  752|    602|         stack.push_back({std::optional<X509_Certificate>(), false});
  753|       |
  754|    602|         for(const auto& trusted_cert : trusted_issuers) {
  ------------------
  |  Branch (754:39): [True: 602, False: 602]
  ------------------
  755|    602|            stack.push_back({trusted_cert, true});
  756|    602|         }
  757|       |
  758|    602|         for(const auto& misc : misc_issuers) {
  ------------------
  |  Branch (758:31): [True: 0, False: 602]
  ------------------
  759|      0|            stack.push_back({misc, false});
  760|      0|         }
  761|    602|      }
  762|  1.84k|   }
  763|       |
  764|       |   // could not construct any potentially valid path
  765|    637|   if(cert_paths_out.empty()) {
  ------------------
  |  Branch (765:7): [True: 272, False: 365]
  ------------------
  766|    272|      if(stats.empty()) {
  ------------------
  |  Branch (766:10): [True: 0, False: 272]
  ------------------
  767|      0|         throw Internal_Error("X509 path building failed for unknown reasons");
  768|    272|      } else {
  769|       |         // arbitrarily return the first error
  770|    272|         return stats[0];
  771|    272|      }
  772|    365|   } else {
  773|    365|      return Certificate_Status_Code::OK;
  774|    365|   }
  775|    637|}
_ZN5Botan4PKIX23merge_revocation_statusERNSt3__16vectorINS1_3setINS_23Certificate_Status_CodeENS1_4lessIS4_EENS1_9allocatorIS4_EEEENS7_IS9_EEEERKSB_SE_RKNS_28Path_Validation_RestrictionsE:
  780|    145|                                   const Path_Validation_Restrictions& restrictions) {
  781|    145|   if(chain_status.empty()) {
  ------------------
  |  Branch (781:7): [True: 0, False: 145]
  ------------------
  782|      0|      throw Invalid_Argument("PKIX::merge_revocation_status chain_status was empty");
  783|      0|   }
  784|       |
  785|    290|   for(size_t i = 0; i != chain_status.size() - 1; ++i) {
  ------------------
  |  Branch (785:22): [True: 145, False: 145]
  ------------------
  786|    145|      bool had_crl = false, had_ocsp = false;
  787|       |
  788|    145|      if(i < crl.size() && !crl[i].empty()) {
  ------------------
  |  Branch (788:10): [True: 0, False: 145]
  |  Branch (788:28): [True: 0, False: 0]
  ------------------
  789|      0|         for(auto&& code : crl[i]) {
  ------------------
  |  Branch (789:26): [True: 0, False: 0]
  ------------------
  790|      0|            if(code == Certificate_Status_Code::VALID_CRL_CHECKED) {
  ------------------
  |  Branch (790:16): [True: 0, False: 0]
  ------------------
  791|      0|               had_crl = true;
  792|      0|            }
  793|      0|            chain_status[i].insert(code);
  794|      0|         }
  795|      0|      }
  796|       |
  797|    145|      if(i < ocsp.size() && !ocsp[i].empty()) {
  ------------------
  |  Branch (797:10): [True: 0, False: 145]
  |  Branch (797:29): [True: 0, False: 0]
  ------------------
  798|      0|         for(auto&& code : ocsp[i]) {
  ------------------
  |  Branch (798:26): [True: 0, False: 0]
  ------------------
  799|      0|            if(code == Certificate_Status_Code::OCSP_RESPONSE_GOOD ||
  ------------------
  |  Branch (799:16): [True: 0, False: 0]
  ------------------
  800|      0|               code == Certificate_Status_Code::OCSP_NO_REVOCATION_URL ||   // softfail
  ------------------
  |  Branch (800:16): [True: 0, False: 0]
  ------------------
  801|      0|               code == Certificate_Status_Code::OCSP_SERVER_NOT_AVAILABLE)  // softfail
  ------------------
  |  Branch (801:16): [True: 0, False: 0]
  ------------------
  802|      0|            {
  803|      0|               had_ocsp = true;
  804|      0|            }
  805|       |
  806|      0|            chain_status[i].insert(code);
  807|      0|         }
  808|      0|      }
  809|       |
  810|    145|      if(had_crl == false && had_ocsp == false) {
  ------------------
  |  Branch (810:10): [True: 145, False: 0]
  |  Branch (810:30): [True: 145, False: 0]
  ------------------
  811|    145|         if((restrictions.require_revocation_information() && i == 0) ||
  ------------------
  |  Branch (811:14): [True: 0, False: 145]
  |  Branch (811:63): [True: 0, False: 0]
  ------------------
  812|    145|            (restrictions.ocsp_all_intermediates() && i > 0)) {
  ------------------
  |  Branch (812:14): [True: 0, False: 145]
  |  Branch (812:55): [True: 0, False: 0]
  ------------------
  813|      0|            chain_status[i].insert(Certificate_Status_Code::NO_REVOCATION_DATA);
  814|      0|         }
  815|    145|      }
  816|    145|   }
  817|    145|}
_ZN5Botan4PKIX14overall_statusERKNSt3__16vectorINS1_3setINS_23Certificate_Status_CodeENS1_4lessIS4_EENS1_9allocatorIS4_EEEENS7_IS9_EEEE:
  819|    145|Certificate_Status_Code PKIX::overall_status(const CertificatePathStatusCodes& cert_status) {
  820|    145|   if(cert_status.empty()) {
  ------------------
  |  Branch (820:7): [True: 0, False: 145]
  ------------------
  821|      0|      throw Invalid_Argument("PKIX::overall_status empty cert status");
  822|      0|   }
  823|       |
  824|    145|   Certificate_Status_Code overall_status = Certificate_Status_Code::OK;
  825|       |
  826|       |   // take the "worst" error as overall
  827|    290|   for(const std::set<Certificate_Status_Code>& s : cert_status) {
  ------------------
  |  Branch (827:51): [True: 290, False: 145]
  ------------------
  828|    290|      if(!s.empty()) {
  ------------------
  |  Branch (828:10): [True: 287, False: 3]
  ------------------
  829|    287|         auto worst = *s.rbegin();
  830|       |         // Leave informative OCSP/CRL confirmations on cert-level status only
  831|    287|         if(worst >= Certificate_Status_Code::FIRST_ERROR_STATUS && worst > overall_status) {
  ------------------
  |  Branch (831:13): [True: 287, False: 0]
  |  Branch (831:69): [True: 198, False: 89]
  ------------------
  832|    198|            overall_status = worst;
  833|    198|         }
  834|    287|      }
  835|    290|   }
  836|    145|   return overall_status;
  837|    145|}
_ZN5Botan18x509_path_validateERKNSt3__16vectorINS_16X509_CertificateENS0_9allocatorIS2_EEEERKNS_28Path_Validation_RestrictionsERKNS1_IPNS_17Certificate_StoreENS3_ISC_EEEENS0_17basic_string_viewIcNS0_11char_traitsIcEEEENS_10Usage_TypeENS0_6chrono10time_pointINSM_12system_clockENSM_8durationIxNS0_5ratioILl1ELl1000000EEEEEEENSP_IxNSQ_ILl1ELl1000EEEEERKNS1_INS0_8optionalINS_4OCSP8ResponseEEENS3_ISZ_EEEE:
  846|    762|                                          const std::vector<std::optional<OCSP::Response>>& ocsp_resp) {
  847|    762|   if(end_certs.empty()) {
  ------------------
  |  Branch (847:7): [True: 0, False: 762]
  ------------------
  848|      0|      throw Invalid_Argument("x509_path_validate called with no subjects");
  849|      0|   }
  850|       |
  851|    762|   X509_Certificate end_entity = end_certs[0];
  852|    762|   std::vector<X509_Certificate> end_entity_extra;
  853|    762|   for(size_t i = 1; i < end_certs.size(); ++i) {
  ------------------
  |  Branch (853:22): [True: 0, False: 762]
  ------------------
  854|      0|      end_entity_extra.push_back(end_certs[i]);
  855|      0|   }
  856|       |
  857|    762|   std::vector<std::vector<X509_Certificate>> cert_paths;
  858|    762|   Certificate_Status_Code path_building_result =
  859|    762|      PKIX::build_all_certificate_paths(cert_paths, trusted_roots, end_entity, end_entity_extra);
  860|       |
  861|       |   // If we cannot successfully build a chain to a trusted self-signed root, stop now
  862|    762|   if(path_building_result != Certificate_Status_Code::OK) {
  ------------------
  |  Branch (862:7): [True: 397, False: 365]
  ------------------
  863|    397|      return Path_Validation_Result(path_building_result);
  864|    397|   }
  865|       |
  866|    365|   std::vector<Path_Validation_Result> error_results;
  867|       |   // Try validating all the potentially valid paths and return the first one to validate properly
  868|    365|   for(auto cert_path : cert_paths) {
  ------------------
  |  Branch (868:23): [True: 365, False: 365]
  ------------------
  869|    365|      CertificatePathStatusCodes status = PKIX::check_chain(cert_path, ref_time, hostname, usage, restrictions);
  870|       |
  871|    365|      CertificatePathStatusCodes crl_status = PKIX::check_crl(cert_path, trusted_roots, ref_time);
  872|       |
  873|    365|      CertificatePathStatusCodes ocsp_status;
  874|       |
  875|    365|      if(!ocsp_resp.empty()) {
  ------------------
  |  Branch (875:10): [True: 0, False: 365]
  ------------------
  876|      0|         ocsp_status = PKIX::check_ocsp(cert_path, ocsp_resp, trusted_roots, ref_time, restrictions);
  877|      0|      }
  878|       |
  879|    365|      if(ocsp_status.empty() && ocsp_timeout != std::chrono::milliseconds(0)) {
  ------------------
  |  Branch (879:10): [True: 145, False: 220]
  |  Branch (879:10): [True: 0, False: 365]
  |  Branch (879:33): [True: 0, False: 145]
  ------------------
  880|      0|#if defined(BOTAN_TARGET_OS_HAS_THREADS) && defined(BOTAN_HAS_HTTP_UTIL)
  881|      0|         ocsp_status = PKIX::check_ocsp_online(cert_path, trusted_roots, ref_time, ocsp_timeout, restrictions);
  882|       |#else
  883|       |         ocsp_status.resize(1);
  884|       |         ocsp_status[0].insert(Certificate_Status_Code::OCSP_NO_HTTP);
  885|       |#endif
  886|      0|      }
  887|       |
  888|    365|      PKIX::merge_revocation_status(status, crl_status, ocsp_status, restrictions);
  889|       |
  890|    365|      Path_Validation_Result pvd(status, std::move(cert_path));
  891|    365|      if(pvd.successful_validation()) {
  ------------------
  |  Branch (891:10): [True: 0, False: 365]
  ------------------
  892|      0|         return pvd;
  893|    365|      } else {
  894|    365|         error_results.push_back(std::move(pvd));
  895|    365|      }
  896|    365|   }
  897|    365|   return error_results[0];
  898|    365|}
_ZN5Botan18x509_path_validateERKNS_16X509_CertificateERKNS_28Path_Validation_RestrictionsERKNSt3__16vectorIPNS_17Certificate_StoreENS6_9allocatorIS9_EEEENS6_17basic_string_viewIcNS6_11char_traitsIcEEEENS_10Usage_TypeENS6_6chrono10time_pointINSK_12system_clockENSK_8durationIxNS6_5ratioILl1ELl1000000EEEEEEENSN_IxNSO_ILl1ELl1000EEEEERKNS7_INS6_8optionalINS_4OCSP8ResponseEEENSA_ISX_EEEE:
  907|    762|                                          const std::vector<std::optional<OCSP::Response>>& ocsp_resp) {
  908|    762|   std::vector<X509_Certificate> certs;
  909|    762|   certs.push_back(end_cert);
  910|    762|   return x509_path_validate(certs, restrictions, trusted_roots, hostname, usage, when, ocsp_timeout, ocsp_resp);
  911|    762|}
_ZN5Botan28Path_Validation_RestrictionsC2EbmbNSt3__16chrono8durationIxNS1_5ratioILl1ELl1EEEEENS1_10unique_ptrINS_17Certificate_StoreENS1_14default_deleteIS8_EEEE:
  953|    762|      m_trusted_ocsp_responders(std::move(trusted_ocsp_responders)) {
  954|    762|   if(key_strength <= 80) {
  ------------------
  |  Branch (954:7): [True: 0, False: 762]
  ------------------
  955|      0|      m_trusted_hashes.insert("SHA-1");
  956|      0|   }
  957|       |
  958|    762|   m_trusted_hashes.insert("SHA-224");
  959|    762|   m_trusted_hashes.insert("SHA-256");
  960|    762|   m_trusted_hashes.insert("SHA-384");
  961|    762|   m_trusted_hashes.insert("SHA-512");
  962|    762|   m_trusted_hashes.insert("SHAKE-256(512)");
  963|    762|}
_ZN5Botan22Path_Validation_ResultC2ENSt3__16vectorINS1_3setINS_23Certificate_Status_CodeENS1_4lessIS4_EENS1_9allocatorIS4_EEEENS7_IS9_EEEEONS2_INS_16X509_CertificateENS7_ISC_EEEE:
  987|    145|      m_overall(PKIX::overall_status(m_all_status)) {}
_ZNK5Botan22Path_Validation_Result21successful_validationEv:
 1000|    145|bool Path_Validation_Result::successful_validation() const {
 1001|    145|   return (result() == Certificate_Status_Code::VERIFIED || result() == Certificate_Status_Code::OCSP_RESPONSE_GOOD ||
  ------------------
  |  Branch (1001:12): [True: 0, False: 145]
  |  Branch (1001:61): [True: 0, False: 145]
  ------------------
 1002|    145|           result() == Certificate_Status_Code::VALID_CRL_CHECKED);
  ------------------
  |  Branch (1002:12): [True: 0, False: 145]
  ------------------
 1003|    145|}
x509path.cpp:_ZN5Botan12_GLOBAL__N_113find_warningsERKNSt3__16vectorINS1_3setINS_23Certificate_Status_CodeENS1_4lessIS4_EENS1_9allocatorIS4_EEEENS7_IS9_EEEE:
  966|    145|CertificatePathStatusCodes find_warnings(const CertificatePathStatusCodes& all_statuses) {
  967|    145|   CertificatePathStatusCodes warnings;
  968|    290|   for(const auto& status_set_i : all_statuses) {
  ------------------
  |  Branch (968:33): [True: 290, False: 145]
  ------------------
  969|    290|      std::set<Certificate_Status_Code> warning_set_i;
  970|  1.12k|      for(const auto& code : status_set_i) {
  ------------------
  |  Branch (970:28): [True: 1.12k, False: 290]
  ------------------
  971|  1.12k|         if(code >= Certificate_Status_Code::FIRST_WARNING_STATUS &&
  ------------------
  |  Branch (971:13): [True: 1.12k, False: 0]
  ------------------
  972|  1.12k|            code < Certificate_Status_Code::FIRST_ERROR_STATUS) {
  ------------------
  |  Branch (972:13): [True: 94, False: 1.03k]
  ------------------
  973|     94|            warning_set_i.insert(code);
  974|     94|         }
  975|  1.12k|      }
  976|    290|      warnings.push_back(warning_set_i);
  977|    290|   }
  978|    145|   return warnings;
  979|    145|}