_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EEC2Ev:
   63|  10.7k|      AlignmentBuffer() : m_position(0) {}
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE5clearEv:
   72|  21.4k|      void clear() {
   73|  21.4k|         clear_mem(m_buffer.data(), m_buffer.size());
   74|  21.4k|         m_position = 0;
   75|  21.4k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EED2Ev:
   65|  10.7k|      ~AlignmentBuffer() { secure_scrub_memory(m_buffer.data(), m_buffer.size()); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE21handle_unaligned_dataERNS_12BufferSlicerE:
  167|  37.1k|      [[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|  37.1k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (171:31): [True: 0, False: 37.1k]
  ------------------
  172|       |
  173|  37.1k|         if(in_alignment() && slicer.remaining() >= m_buffer.size() + defer) {
  ------------------
  |  Branch (173:13): [True: 17.9k, False: 19.2k]
  |  Branch (173:31): [True: 198, False: 17.7k]
  ------------------
  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|    198|            return std::nullopt;
  178|    198|         }
  179|       |
  180|       |         // Fill the buffer with as much input data as needed to reach alignment
  181|       |         // or until the input source is depleted.
  182|  36.9k|         const auto elements_to_consume = std::min(m_buffer.size() - m_position, slicer.remaining());
  183|  36.9k|         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|  36.9k|         if(ready_to_consume() && (!defers_final_block() || !slicer.empty())) {
  ------------------
  |  Branch (189:13): [True: 7.19k, False: 29.7k]
  |  Branch (189:36): [True: 7.19k, False: 0]
  |  Branch (189:61): [True: 0, False: 0]
  ------------------
  190|  7.19k|            return consume();
  191|  29.7k|         } else {
  192|  29.7k|            return std::nullopt;
  193|  29.7k|         }
  194|  36.9k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18defers_final_blockEv:
  234|  51.7k|      constexpr bool defers_final_block() const {
  235|  51.7k|         return FINAL_BLOCK_STRATEGY == AlignmentBufferFinalBlock::must_be_deferred;
  236|  51.7k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE6appendENSt3__14spanIKhLm18446744073709551615EEE:
   91|  47.6k|      void append(std::span<const T> elements) {
   92|  47.6k|         BOTAN_ASSERT_NOMSG(elements.size() <= elements_until_alignment());
  ------------------
  |  |   60|  47.6k|   do {                                                                     \
  |  |   61|  47.6k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 47.6k]
  |  |  ------------------
  |  |   62|  47.6k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  47.6k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 47.6k]
  |  |  ------------------
  ------------------
   93|  47.6k|         std::copy(elements.begin(), elements.end(), m_buffer.begin() + m_position);
   94|  47.6k|         m_position += elements.size();
   95|  47.6k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE24elements_until_alignmentEv:
  222|  80.5k|      size_t elements_until_alignment() const { return m_buffer.size() - m_position; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE16ready_to_consumeEv:
  232|  78.5k|      bool ready_to_consume() const { return m_position == m_buffer.size(); }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE7consumeEv:
  201|  19.0k|      [[nodiscard]] std::span<const T> consume() {
  202|  19.0k|         BOTAN_ASSERT_NOMSG(ready_to_consume());
  ------------------
  |  |   60|  19.0k|   do {                                                                     \
  |  |   61|  19.0k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 19.0k]
  |  |  ------------------
  |  |   62|  19.0k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  19.0k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 19.0k]
  |  |  ------------------
  ------------------
  203|  19.0k|         m_position = 0;
  204|  19.0k|         return m_buffer;
  205|  19.0k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE12in_alignmentEv:
  227|  81.7k|      bool in_alignment() const { return m_position == 0; }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE23aligned_data_to_processERNS_12BufferSlicerE:
  127|  7.39k|      [[nodiscard]] std::tuple<std::span<const uint8_t>, size_t> aligned_data_to_process(BufferSlicer& slicer) const {
  128|  7.39k|         BOTAN_ASSERT_NOMSG(in_alignment());
  ------------------
  |  |   60|  7.39k|   do {                                                                     \
  |  |   61|  7.39k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 7.39k]
  |  |  ------------------
  |  |   62|  7.39k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  7.39k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 7.39k]
  |  |  ------------------
  ------------------
  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|  7.39k|         const size_t defer = (defers_final_block()) ? 1 : 0;
  ------------------
  |  Branch (132:31): [True: 0, False: 7.39k]
  ------------------
  133|  7.39k|         const size_t full_blocks_to_process = (slicer.remaining() - defer) / m_buffer.size();
  134|  7.39k|         return {slicer.take(full_blocks_to_process * m_buffer.size()), full_blocks_to_process};
  135|  7.39k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE18fill_up_with_zerosEv:
   80|  11.8k|      void fill_up_with_zeros() {
   81|  11.8k|         if(!ready_to_consume()) {
  ------------------
  |  Branch (81:13): [True: 11.4k, False: 399]
  ------------------
   82|  11.4k|            clear_mem(&m_buffer[m_position], elements_until_alignment());
   83|  11.4k|            m_position = m_buffer.size();
   84|  11.4k|         }
   85|  11.8k|      }
_ZN5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE20directly_modify_lastEm:
  114|  10.7k|      std::span<T> directly_modify_last(size_t elements) {
  115|  10.7k|         BOTAN_ASSERT_NOMSG(size() >= elements);
  ------------------
  |  |   60|  10.7k|   do {                                                                     \
  |  |   61|  10.7k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 10.7k]
  |  |  ------------------
  |  |   62|  10.7k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  10.7k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 10.7k]
  |  |  ------------------
  ------------------
  116|  10.7k|         return std::span(m_buffer).last(elements);
  117|  10.7k|      }
_ZNK5Botan15AlignmentBufferIhLm64ELNS_25AlignmentBufferFinalBlockE0EE4sizeEv:
  218|  10.7k|      constexpr size_t size() const { return m_buffer.size(); }

_ZN5Botan14expand_top_bitIhEET_S1_Qsr3std11is_integralIS1_EE5value:
   25|   162M|{
   26|   162M|   return static_cast<T>(0) - (a >> (sizeof(T) * 8 - 1));
   27|   162M|}
_ZN5Botan6chooseIhEET_S1_S1_S1_:
  180|   162M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|   162M|   return (b ^ (mask & (a ^ b)));
  183|   162M|}
_ZN5Botan6chooseIjEET_S1_S1_S1_:
  180|  19.6M|inline constexpr T choose(T mask, T a, T b) {
  181|       |   //return (mask & a) | (~mask & b);
  182|  19.6M|   return (b ^ (mask & (a ^ b)));
  183|  19.6M|}
_ZN5Botan8majorityIjEET_S1_S1_S1_:
  186|  9.69M|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|  9.69M|   return choose(a ^ b, c, b);
  197|  9.69M|}

_ZN5Botan13reverse_bytesEj:
   35|  2.48M|inline constexpr uint32_t reverse_bytes(uint32_t x) {
   36|  2.48M|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   37|  2.48M|   return __builtin_bswap32(x);
   38|       |#else
   39|       |   // MSVC at least recognizes this as a bswap
   40|       |   return ((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) | ((x & 0xFF000000) >> 24);
   41|       |#endif
   42|  2.48M|}
_ZN5Botan13reverse_bytesEm:
   50|  7.59k|inline constexpr uint64_t reverse_bytes(uint64_t x) {
   51|  7.59k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   52|  7.59k|   return __builtin_bswap64(x);
   53|       |#else
   54|       |   uint32_t hi = static_cast<uint32_t>(x >> 32);
   55|       |   uint32_t lo = static_cast<uint32_t>(x);
   56|       |
   57|       |   hi = reverse_bytes(hi);
   58|       |   lo = reverse_bytes(lo);
   59|       |
   60|       |   return (static_cast<uint64_t>(lo) << 32) | hi;
   61|       |#endif
   62|  7.59k|}

_ZN5Botan5CRC245clearEv:
   31|  3.89k|      void clear() override { m_crc = 0XCE04B7L; }
_ZNK5Botan5CRC2413output_lengthEv:
   25|    249|      size_t output_length() const override { return 3; }
_ZN5Botan5CRC24D2Ev:
   35|  1.82k|      ~CRC24() override { clear(); }
_ZN5Botan5CRC24C2Ev:
   33|  1.82k|      CRC24() { clear(); }

_ZN5Botan2CT4MaskIhEC2Eh:
  286|   162M|      constexpr Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskIhE5valueEv:
  283|   162M|      constexpr T value() const { return m_mask; }
_ZN5Botan2CT4MaskIhE5is_ltEhh:
  139|   162M|      static constexpr Mask<T> is_lt(T x, T y) { return Mask<T>(expand_top_bit<T>(x ^ ((x ^ y) | ((x - y) ^ x)))); }
_ZNK5Botan2CT4MaskIhE6selectEhh:
  234|   162M|      constexpr T select(T x, T y) const { return choose(value(), x, y); }

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

_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ETkNSt3__117unsigned_integralEjTkNS_6ranges23contiguous_output_rangeIhEENS3_4spanIhLm4EEEEEvT0_OT1_:
  491|  60.7k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  60.7k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  60.7k|   std::span out{out_range};
  494|       |
  495|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  496|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  497|       |   // in a `constexpr` context.
  498|  60.7k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 60.7k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  60.7k|   } else {
  501|       |      if constexpr(sizeof(InT) == 1) {
  502|       |         out[0] = static_cast<uint8_t>(in);
  503|       |      } else if constexpr(is_native(endianness)) {
  504|       |         typecast_copy(out, in);
  505|  60.7k|      } else if constexpr(is_opposite(endianness)) {
  506|  60.7k|         typecast_copy(out, reverse_bytes(in));
  507|       |      } else {
  508|       |         static_assert(native_endianness_is_unknown<endianness>());
  509|       |         return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  510|       |      }
  511|  60.7k|   }
  512|  60.7k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ENS0_10AutoDetectETkNS0_20unsigned_integralishEmQoosr3stdE7same_asIS3_T0_Esr3stdE7same_asIT1_S4_EEEvS5_Ph:
  677|  7.59k|inline constexpr void store_any(T in, uint8_t out[]) {
  678|       |   // asserts that *out points to enough bytes to write into
  679|  7.59k|   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  680|  7.59k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ENS0_10AutoDetectETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm8EEEQsr3stdE7same_asIS3_T0_EEEvT1_OT2_:
  612|  7.59k|inline constexpr void store_any(T in, OutR&& out_range) {
  613|  7.59k|   store_any<endianness, T>(in, std::forward<OutR>(out_range));
  614|  7.59k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ETkNSt3__117unsigned_integralEmTkNS_6ranges23contiguous_output_rangeIhEENS3_4spanIhLm8EEEEEvT0_OT1_:
  491|  7.59k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  7.59k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  7.59k|   std::span out{out_range};
  494|       |
  495|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  496|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  497|       |   // in a `constexpr` context.
  498|  7.59k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 7.59k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  7.59k|   } else {
  501|       |      if constexpr(sizeof(InT) == 1) {
  502|       |         out[0] = static_cast<uint8_t>(in);
  503|       |      } else if constexpr(is_native(endianness)) {
  504|       |         typecast_copy(out, in);
  505|  7.59k|      } else if constexpr(is_opposite(endianness)) {
  506|  7.59k|         typecast_copy(out, reverse_bytes(in));
  507|       |      } else {
  508|       |         static_assert(native_endianness_is_unknown<endianness>());
  509|       |         return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  510|       |      }
  511|  7.59k|   }
  512|  7.59k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS0_20unsigned_integralishEmQoosr3stdE7same_asIS3_T0_Esr3stdE7same_asIT1_S4_EEEvS5_Ph:
  677|  3.12k|inline constexpr void store_any(T in, uint8_t out[]) {
  678|       |   // asserts that *out points to enough bytes to write into
  679|  3.12k|   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  680|  3.12k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm8EEEQsr3stdE7same_asIS3_T0_EEEvT1_OT2_:
  612|  3.12k|inline constexpr void store_any(T in, OutR&& out_range) {
  613|  3.12k|   store_any<endianness, T>(in, std::forward<OutR>(out_range));
  614|  3.12k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ETkNSt3__117unsigned_integralEmTkNS_6ranges23contiguous_output_rangeIhEENS3_4spanIhLm8EEEEEvT0_OT1_:
  491|  3.12k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  3.12k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  3.12k|   std::span out{out_range};
  494|       |
  495|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  496|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  497|       |   // in a `constexpr` context.
  498|  3.12k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 3.12k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  3.12k|   } else {
  501|       |      if constexpr(sizeof(InT) == 1) {
  502|       |         out[0] = static_cast<uint8_t>(in);
  503|  3.12k|      } else if constexpr(is_native(endianness)) {
  504|  3.12k|         typecast_copy(out, in);
  505|       |      } else if constexpr(is_opposite(endianness)) {
  506|       |         typecast_copy(out, reverse_bytes(in));
  507|       |      } else {
  508|       |         static_assert(native_endianness_is_unknown<endianness>());
  509|       |         return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  510|       |      }
  511|  3.12k|   }
  512|  3.12k|}
_ZN5Botan8get_byteILm3EjEEhT0_QltT_stS1_:
   77|  10.3M|{
   78|  10.3M|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   79|  10.3M|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   80|  10.3M|}
_ZN5Botan8get_byteILm2EjEEhT0_QltT_stS1_:
   77|  10.3M|{
   78|  10.3M|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   79|  10.3M|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   80|  10.3M|}
_ZN5Botan8get_byteILm1EjEEhT0_QltT_stS1_:
   77|  10.3M|{
   78|  10.3M|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   79|  10.3M|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   80|  10.3M|}
_ZN5Botan8get_byteILm0EjEEhT0_QltT_stS1_:
   77|  10.3M|{
   78|  10.3M|   const size_t shift = ((~B) & (sizeof(T) - 1)) << 3;
   79|  10.3M|   return static_cast<uint8_t>((input >> shift) & 0xFF);
   80|  10.3M|}
_ZN5Botan6detail8load_anyILNS0_10EndiannessE0ETkNSt3__117unsigned_integralEjTkNS_6ranges16contiguous_rangeIhEENS3_4spanIKhLm4EEEEET0_OT1_:
  248|  2.42M|inline constexpr OutT load_any(InR&& in_range) {
  249|  2.42M|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  250|  2.42M|   std::span in{in_range};
  251|       |
  252|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  253|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  254|       |   // in a `constexpr` context.
  255|  2.42M|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (255:7): [Folded, False: 2.42M]
  ------------------
  256|      0|      return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  257|  2.42M|   } else {
  258|       |      if constexpr(sizeof(OutT) == 1) {
  259|       |         return static_cast<OutT>(in[0]);
  260|       |      } else if constexpr(is_native(endianness)) {
  261|       |         return typecast_copy<OutT>(in);
  262|  2.42M|      } else if constexpr(is_opposite(endianness)) {
  263|  2.42M|         return reverse_bytes(typecast_copy<OutT>(in));
  264|       |      } else {
  265|       |         static_assert(native_endianness_is_unknown<endianness>());
  266|       |         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  267|       |      }
  268|  2.42M|   }
  269|  2.42M|}
_ZN5Botan6detail33copy_out_any_word_aligned_portionILNS0_10EndiannessE0ETkNS0_20unsigned_integralishEjEEmRNSt3__14spanIhLm18446744073709551615EEERNS4_IKT0_Lm18446744073709551615EEE:
  718|  7.59k|size_t copy_out_any_word_aligned_portion(std::span<uint8_t>& out, std::span<const T>& in) {
  719|  7.59k|   const size_t full_words = out.size() / sizeof(T);
  720|  7.59k|   const size_t full_word_bytes = full_words * sizeof(T);
  721|  7.59k|   const size_t remaining_bytes = out.size() - full_word_bytes;
  722|  7.59k|   BOTAN_ASSERT_NOMSG(in.size_bytes() >= full_word_bytes + remaining_bytes);
  ------------------
  |  |   60|  7.59k|   do {                                                                     \
  |  |   61|  7.59k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 7.59k]
  |  |  ------------------
  |  |   62|  7.59k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  7.59k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 7.59k]
  |  |  ------------------
  ------------------
  723|       |
  724|       |   // copy full words
  725|  7.59k|   store_any<endianness, T>(out.first(full_word_bytes), in.first(full_words));
  726|  7.59k|   out = out.subspan(full_word_bytes);
  727|  7.59k|   in = in.subspan(full_words);
  728|       |
  729|  7.59k|   return remaining_bytes;
  730|  7.59k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm18446744073709551615EEETkNS3_14spanable_rangeENS6_IKjLm18446744073709551615EEEQoosr3stdE7same_asINS0_10AutoDetectET0_Esr3stdE7same_asISB_NS5_11conditionalIXsr21__is_primary_templateINS5_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS5_6ranges5__cpo5beginEEclsr3stdE7declvalIRT2_EEEEEEEEE5valueENS5_26indirectly_readable_traitsISJ_EESK_E4type10value_typeEEEEvOT1_OSG_:
  569|  7.59k|inline constexpr void store_any(OutR&& out, InR&& in) {
  570|  7.59k|   ranges::assert_equal_byte_lengths(out, in);
  571|       |
  572|  7.59k|   auto store_elementwise = [&] {
  573|  7.59k|      using element_type = std::ranges::range_value_t<InR>;
  574|  7.59k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  7.59k|      std::span<uint8_t> out_s(out);
  576|  7.59k|      for(auto in_elem : in) {
  577|  7.59k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  7.59k|         out_s = out_s.subspan(bytes_per_element);
  579|  7.59k|      }
  580|  7.59k|   };
  581|       |
  582|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  583|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  584|       |   // in a `constexpr` context.
  585|  7.59k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (585:7): [Folded, False: 7.59k]
  ------------------
  586|      0|      store_elementwise();
  587|  7.59k|   } else {
  588|       |      if constexpr(is_native(endianness)) {
  589|       |         typecast_copy(out, in);
  590|  7.59k|      } else {
  591|  7.59k|         store_elementwise();
  592|  7.59k|      }
  593|  7.59k|   }
  594|  7.59k|}
_ZZN5Botan6detail9store_anyILNS0_10EndiannessE0EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm18446744073709551615EEETkNS3_14spanable_rangeENS6_IKjLm18446744073709551615EEEQoosr3stdE7same_asINS0_10AutoDetectET0_Esr3stdE7same_asISB_NS5_11conditionalIXsr21__is_primary_templateINS5_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS5_6ranges5__cpo5beginEEclsr3stdE7declvalIRT2_EEEEEEEEE5valueENS5_26indirectly_readable_traitsISJ_EESK_E4type10value_typeEEEEvOT1_OSG_ENKUlvE_clEv:
  572|  7.59k|   auto store_elementwise = [&] {
  573|  7.59k|      using element_type = std::ranges::range_value_t<InR>;
  574|  7.59k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  7.59k|      std::span<uint8_t> out_s(out);
  576|  60.7k|      for(auto in_elem : in) {
  ------------------
  |  Branch (576:24): [True: 60.7k, False: 7.59k]
  ------------------
  577|  60.7k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  60.7k|         out_s = out_s.subspan(bytes_per_element);
  579|  60.7k|      }
  580|  7.59k|   };
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm4EEETpTkNS0_20unsigned_integralishEJjEQaagtsZT2_Li0Eooaasr3stdE7same_asINS0_10AutoDetectET0_E10all_same_vIDpT2_Eaa20unsigned_integralishIS9_E10all_same_vIS9_SB_EEEvOT1_SB_:
  548|  60.7k|inline constexpr void store_any(OutR&& out, Ts... ins) {
  549|  60.7k|   ranges::assert_exact_byte_length<(sizeof(Ts) + ...)>(out);
  550|  60.7k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  551|  60.7k|      store_any<endianness, T>(i, o.subspan(off).template first<sizeof(T)>());
  552|  60.7k|      off += sizeof(T);
  553|  60.7k|   };
  554|       |
  555|  60.7k|   (store_one(std::span{out}, ins), ...);
  556|  60.7k|}
_ZZN5Botan6detail9store_anyILNS0_10EndiannessE0EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm4EEETpTkNS0_20unsigned_integralishEJjEQaagtsZT2_Li0Eooaasr3stdE7same_asINS0_10AutoDetectET0_E10all_same_vIDpT2_Eaa20unsigned_integralishIS9_E10all_same_vIS9_SB_EEEvOT1_SB_ENUlTyS9_T_E_clIjS7_EEDaS9_SE_:
  550|  60.7k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  551|  60.7k|      store_any<endianness, T>(i, o.subspan(off).template first<sizeof(T)>());
  552|  60.7k|      off += sizeof(T);
  553|  60.7k|   };
_ZN5Botan6detail8load_anyILNS0_10EndiannessE0ETkNS0_20unsigned_integralishEjEET0_PKhm:
  421|  2.42M|inline constexpr OutT load_any(const uint8_t in[], size_t off) {
  422|       |   // asserts that *in points to enough bytes to read at offset off
  423|  2.42M|   constexpr size_t out_size = sizeof(OutT);
  424|  2.42M|   return load_any<endianness, OutT>(std::span<const uint8_t, out_size>(in + off * out_size, out_size));
  425|  2.42M|}
_ZN5Botan7load_beIjJPKhiEEEDaDpOT0_:
  471|  2.42M|inline constexpr auto load_be(ParamTs&&... params) {
  472|  2.42M|   return detail::load_any<detail::Endianness::Big, OutT>(std::forward<ParamTs>(params)...);
  473|  2.42M|}
_ZN5Botan7load_leINS_6detail10AutoDetectEJRA4_jPKhiEEEDaDpOT0_:
  462|  2.59M|inline constexpr auto load_le(ParamTs&&... params) {
  463|  2.59M|   return detail::load_any<detail::Endianness::Little, OutT>(std::forward<ParamTs>(params)...);
  464|  2.59M|}
_ZN5Botan6detail8load_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS0_20unsigned_integralishEjQoosr3stdE7same_asIS3_T0_Esr3stdE7same_asIT1_S4_EEEvPS5_PKhm:
  450|  2.60M|inline constexpr void load_any(T out[], const uint8_t in[], size_t count) {
  451|       |   // asserts that *in and *out point to the correct amount of memory
  452|  2.60M|   load_any<endianness, OutT>(std::span<T>(out, count), std::span<const uint8_t>(in, count * sizeof(T)));
  453|  2.60M|}
_ZN5Botan6detail8load_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS_6ranges23contiguous_output_rangeENSt3__14spanIjLm18446744073709551615EEETkNS4_16contiguous_rangeIhEENS6_IKhLm18446744073709551615EEEQaa20unsigned_integralishINS5_11conditionalIXsr21__is_primary_templateINS5_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS5_6ranges5__cpo5beginEEclsr3stdE7declvalIRT1_EEEEEEEEE5valueENS5_26indirectly_readable_traitsISI_EESJ_E4type10value_typeEEoosr3stdE7same_asIS3_T0_Esr3stdE7same_asISP_SO_EEEvOSF_OT2_:
  322|  2.60M|inline constexpr void load_any(OutR&& out, InR&& in) {
  323|  2.60M|   ranges::assert_equal_byte_lengths(out, in);
  324|       |
  325|  2.60M|   auto load_elementwise = [&] {
  326|  2.60M|      using element_type = std::ranges::range_value_t<OutR>;
  327|  2.60M|      constexpr size_t bytes_per_element = sizeof(element_type);
  328|  2.60M|      std::span<const uint8_t> in_s(in);
  329|  2.60M|      for(auto& out_elem : out) {
  330|  2.60M|         out_elem = load_any<endianness, element_type>(in_s.template first<bytes_per_element>());
  331|  2.60M|         in_s = in_s.subspan(bytes_per_element);
  332|  2.60M|      }
  333|  2.60M|   };
  334|       |
  335|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  336|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  337|       |   // in a `constexpr` context.
  338|  2.60M|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (338:7): [Folded, False: 2.60M]
  ------------------
  339|      0|      load_elementwise();
  340|  2.60M|   } else {
  341|  2.60M|      if constexpr(is_native(endianness)) {
  342|  2.60M|         typecast_copy(out, in);
  343|       |      } else {
  344|       |         load_elementwise();
  345|       |      }
  346|  2.60M|   }
  347|  2.60M|}
_ZN5Botan7load_leINS_6detail10AutoDetectEJPjPKhmEEEDaDpOT0_:
  462|  6.38k|inline constexpr auto load_le(ParamTs&&... params) {
  463|  6.38k|   return detail::load_any<detail::Endianness::Little, OutT>(std::forward<ParamTs>(params)...);
  464|  6.38k|}
_ZN5Botan8store_leINS_6detail10AutoDetectEJRKmPhEEEDaDpOT0_:
  702|  3.12k|inline constexpr auto store_le(ParamTs&&... params) {
  703|  3.12k|   return detail::store_any<detail::Endianness::Little, ModifierT>(std::forward<ParamTs>(params)...);
  704|  3.12k|}
_ZN5Botan11copy_out_leITkNS_6ranges14spanable_rangeERNSt3__16vectorIjNS_16secure_allocatorIjEEEEEEvNS2_4spanIhLm18446744073709551615EEEOT_:
  755|  3.12k|void copy_out_le(std::span<uint8_t> out, InR&& in) {
  756|  3.12k|   using T = std::ranges::range_value_t<InR>;
  757|  3.12k|   std::span<const T> in_s{in};
  758|  3.12k|   const auto remaining_bytes = detail::copy_out_any_word_aligned_portion<detail::Endianness::Little>(out, in_s);
  759|       |
  760|       |   // copy remaining bytes as a partial word
  761|  3.12k|   for(size_t i = 0; i < remaining_bytes; ++i) {
  ------------------
  |  Branch (761:22): [True: 0, False: 3.12k]
  ------------------
  762|      0|      out[i] = get_byte_var(sizeof(T) - 1 - i, in_s.front());
  763|      0|   }
  764|  3.12k|}
_ZN5Botan6detail33copy_out_any_word_aligned_portionILNS0_10EndiannessE1ETkNS0_20unsigned_integralishEjEEmRNSt3__14spanIhLm18446744073709551615EEERNS4_IKT0_Lm18446744073709551615EEE:
  718|  3.12k|size_t copy_out_any_word_aligned_portion(std::span<uint8_t>& out, std::span<const T>& in) {
  719|  3.12k|   const size_t full_words = out.size() / sizeof(T);
  720|  3.12k|   const size_t full_word_bytes = full_words * sizeof(T);
  721|  3.12k|   const size_t remaining_bytes = out.size() - full_word_bytes;
  722|  3.12k|   BOTAN_ASSERT_NOMSG(in.size_bytes() >= full_word_bytes + remaining_bytes);
  ------------------
  |  |   60|  3.12k|   do {                                                                     \
  |  |   61|  3.12k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.12k]
  |  |  ------------------
  |  |   62|  3.12k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.12k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 3.12k]
  |  |  ------------------
  ------------------
  723|       |
  724|       |   // copy full words
  725|  3.12k|   store_any<endianness, T>(out.first(full_word_bytes), in.first(full_words));
  726|  3.12k|   out = out.subspan(full_word_bytes);
  727|  3.12k|   in = in.subspan(full_words);
  728|       |
  729|  3.12k|   return remaining_bytes;
  730|  3.12k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm18446744073709551615EEETkNS3_14spanable_rangeENS6_IKjLm18446744073709551615EEEQoosr3stdE7same_asINS0_10AutoDetectET0_Esr3stdE7same_asISB_NS5_11conditionalIXsr21__is_primary_templateINS5_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS5_6ranges5__cpo5beginEEclsr3stdE7declvalIRT2_EEEEEEEEE5valueENS5_26indirectly_readable_traitsISJ_EESK_E4type10value_typeEEEEvOT1_OSG_:
  569|  3.12k|inline constexpr void store_any(OutR&& out, InR&& in) {
  570|  3.12k|   ranges::assert_equal_byte_lengths(out, in);
  571|       |
  572|  3.12k|   auto store_elementwise = [&] {
  573|  3.12k|      using element_type = std::ranges::range_value_t<InR>;
  574|  3.12k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  3.12k|      std::span<uint8_t> out_s(out);
  576|  3.12k|      for(auto in_elem : in) {
  577|  3.12k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  3.12k|         out_s = out_s.subspan(bytes_per_element);
  579|  3.12k|      }
  580|  3.12k|   };
  581|       |
  582|       |   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
  583|       |   // internally to copy ranges on a byte-by-byte basis, which is not allowed
  584|       |   // in a `constexpr` context.
  585|  3.12k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (585:7): [Folded, False: 3.12k]
  ------------------
  586|      0|      store_elementwise();
  587|  3.12k|   } else {
  588|  3.12k|      if constexpr(is_native(endianness)) {
  589|  3.12k|         typecast_copy(out, in);
  590|       |      } else {
  591|       |         store_elementwise();
  592|       |      }
  593|  3.12k|   }
  594|  3.12k|}
_ZN5Botan8store_beINS_6detail10AutoDetectEJRKmPhEEEDaDpOT0_:
  711|  7.59k|inline constexpr auto store_be(ParamTs&&... params) {
  712|  7.59k|   return detail::store_any<detail::Endianness::Big, ModifierT>(std::forward<ParamTs>(params)...);
  713|  7.59k|}
_ZN5Botan11copy_out_beITkNS_6ranges14spanable_rangeERNSt3__16vectorIjNS_16secure_allocatorIjEEEEEEvNS2_4spanIhLm18446744073709551615EEEOT_:
  739|  7.59k|void copy_out_be(std::span<uint8_t> out, InR&& in) {
  740|  7.59k|   using T = std::ranges::range_value_t<InR>;
  741|  7.59k|   std::span<const T> in_s{in};
  742|  7.59k|   const auto remaining_bytes = detail::copy_out_any_word_aligned_portion<detail::Endianness::Big>(out, in_s);
  743|       |
  744|       |   // copy remaining bytes as a partial word
  745|  7.59k|   for(size_t i = 0; i < remaining_bytes; ++i) {
  ------------------
  |  Branch (745:22): [True: 0, False: 7.59k]
  ------------------
  746|      0|      out[i] = get_byte_var(i, in_s.front());
  747|      0|   }
  748|  7.59k|}

_ZNK5Botan3MD513output_lengthEv:
   34|  3.12k|      size_t output_length() const override { return output_bytes; }

_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EEC2Ev:
   42|  7.59k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5clearEv:
   70|  15.1k|      void clear() {
   71|  15.1k|         MD::init(m_digest);
   72|  15.1k|         m_buffer.clear();
   73|  15.1k|         m_count = 0;
   74|  15.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EEC2Ev:
   42|  3.12k|      MerkleDamgard_Hash() { clear(); }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5clearEv:
   70|  6.25k|      void clear() {
   71|  6.25k|         MD::init(m_digest);
   72|  6.25k|         m_buffer.clear();
   73|  6.25k|         m_count = 0;
   74|  6.25k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  15.0k|      void update(std::span<const uint8_t> input) {
   45|  15.0k|         BufferSlicer in(input);
   46|       |
   47|  31.0k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 15.9k, False: 15.0k]
  ------------------
   48|  15.9k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 1.19k, False: 14.7k]
  ------------------
   49|  1.19k|               MD::compress_n(m_digest, one_block.value(), 1);
   50|  1.19k|            }
   51|       |
   52|  15.9k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 1.38k, False: 14.5k]
  ------------------
   53|  1.38k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  1.38k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 545, False: 843]
  ------------------
   55|    545|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|    545|               }
   57|  1.38k|            }
   58|  15.9k|         }
   59|       |
   60|  15.0k|         m_count += input.size();
   61|  15.0k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  3.12k|      void final(std::span<uint8_t> output) {
   64|  3.12k|         append_padding_bit();
   65|  3.12k|         append_counter_and_finalize();
   66|  3.12k|         copy_output(output);
   67|  3.12k|         clear();
   68|  3.12k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE18append_padding_bitEv:
   77|  3.12k|      void append_padding_bit() {
   78|  3.12k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  3.12k|   do {                                                                     \
  |  |   61|  3.12k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.12k]
  |  |  ------------------
  |  |   62|  3.12k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.12k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 3.12k]
  |  |  ------------------
  ------------------
   79|  3.12k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
   80|  3.12k|            const uint8_t final_byte = 0x80;
   81|  3.12k|            m_buffer.append({&final_byte, 1});
   82|       |         } else {
   83|       |            const uint8_t final_byte = 0x01;
   84|       |            m_buffer.append({&final_byte, 1});
   85|       |         }
   86|  3.12k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE27append_counter_and_finalizeEv:
   88|  3.12k|      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|  3.12k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 707, False: 2.42k]
  ------------------
   92|    707|            m_buffer.fill_up_with_zeros();
   93|    707|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|    707|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  3.12k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  3.12k|   do {                                                                     \
  |  |   61|  3.12k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.12k]
  |  |  ------------------
  |  |   62|  3.12k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.12k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 3.12k]
  |  |  ------------------
  ------------------
   98|  3.12k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  3.12k|         const uint64_t bit_count = m_count * 8;
  102|  3.12k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|       |         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  104|       |            store_be(bit_count, last_bytes.data());
  105|  3.12k|         } else {
  106|  3.12k|            store_le(bit_count, last_bytes.data());
  107|  3.12k|         }
  108|       |
  109|       |         // Compress the very last block.
  110|  3.12k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  3.12k|      }
_ZN5Botan18MerkleDamgard_HashINS_3MD5EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  3.12k|      void copy_output(std::span<uint8_t> output) {
  114|  3.12k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  3.12k|   do {                                                                     \
  |  |   61|  3.12k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.12k]
  |  |  ------------------
  |  |   62|  3.12k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.12k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 3.12k]
  |  |  ------------------
  ------------------
  115|       |
  116|       |         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  117|       |            copy_out_be(output.first(MD::output_bytes), m_digest);
  118|  3.12k|         } else {
  119|  3.12k|            copy_out_le(output.first(MD::output_bytes), m_digest);
  120|  3.12k|         }
  121|  3.12k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE6updateENSt3__14spanIKhLm18446744073709551615EEE:
   44|  15.1k|      void update(std::span<const uint8_t> input) {
   45|  15.1k|         BufferSlicer in(input);
   46|       |
   47|  36.3k|         while(!in.empty()) {
  ------------------
  |  Branch (47:16): [True: 21.1k, False: 15.1k]
  ------------------
   48|  21.1k|            if(const auto one_block = m_buffer.handle_unaligned_data(in)) {
  ------------------
  |  Branch (48:27): [True: 6.00k, False: 15.1k]
  ------------------
   49|  6.00k|               MD::compress_n(m_digest, one_block.value(), 1);
   50|  6.00k|            }
   51|       |
   52|  21.1k|            if(m_buffer.in_alignment()) {
  ------------------
  |  Branch (52:16): [True: 6.00k, False: 15.1k]
  ------------------
   53|  6.00k|               const auto [aligned_data, full_blocks] = m_buffer.aligned_data_to_process(in);
   54|  6.00k|               if(full_blocks > 0) {
  ------------------
  |  Branch (54:19): [True: 4.51k, False: 1.49k]
  ------------------
   55|  4.51k|                  MD::compress_n(m_digest, aligned_data, full_blocks);
   56|  4.51k|               }
   57|  6.00k|            }
   58|  21.1k|         }
   59|       |
   60|  15.1k|         m_count += input.size();
   61|  15.1k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE5finalENSt3__14spanIhLm18446744073709551615EEE:
   63|  7.59k|      void final(std::span<uint8_t> output) {
   64|  7.59k|         append_padding_bit();
   65|  7.59k|         append_counter_and_finalize();
   66|  7.59k|         copy_output(output);
   67|  7.59k|         clear();
   68|  7.59k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE18append_padding_bitEv:
   77|  7.59k|      void append_padding_bit() {
   78|  7.59k|         BOTAN_ASSERT_NOMSG(!m_buffer.ready_to_consume());
  ------------------
  |  |   60|  7.59k|   do {                                                                     \
  |  |   61|  7.59k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 7.59k]
  |  |  ------------------
  |  |   62|  7.59k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  7.59k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 7.59k]
  |  |  ------------------
  ------------------
   79|  7.59k|         if constexpr(MD::bit_endianness == MD_Endian::Big) {
   80|  7.59k|            const uint8_t final_byte = 0x80;
   81|  7.59k|            m_buffer.append({&final_byte, 1});
   82|       |         } else {
   83|       |            const uint8_t final_byte = 0x01;
   84|       |            m_buffer.append({&final_byte, 1});
   85|       |         }
   86|  7.59k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE27append_counter_and_finalizeEv:
   88|  7.59k|      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|  7.59k|         if(m_buffer.elements_until_alignment() < MD::ctr_bytes) {
  ------------------
  |  Branch (91:13): [True: 409, False: 7.18k]
  ------------------
   92|    409|            m_buffer.fill_up_with_zeros();
   93|    409|            MD::compress_n(m_digest, m_buffer.consume(), 1);
   94|    409|         }
   95|       |
   96|       |         // Make sure that any remaining bytes in the very last block are zero.
   97|  7.59k|         BOTAN_ASSERT_NOMSG(m_buffer.elements_until_alignment() >= MD::ctr_bytes);
  ------------------
  |  |   60|  7.59k|   do {                                                                     \
  |  |   61|  7.59k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 7.59k]
  |  |  ------------------
  |  |   62|  7.59k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  7.59k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 7.59k]
  |  |  ------------------
  ------------------
   98|  7.59k|         m_buffer.fill_up_with_zeros();
   99|       |
  100|       |         // Replace a bunch of the right-most zero-padding with the counter bytes.
  101|  7.59k|         const uint64_t bit_count = m_count * 8;
  102|  7.59k|         auto last_bytes = m_buffer.directly_modify_last(sizeof(bit_count));
  103|  7.59k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  104|  7.59k|            store_be(bit_count, last_bytes.data());
  105|       |         } else {
  106|       |            store_le(bit_count, last_bytes.data());
  107|       |         }
  108|       |
  109|       |         // Compress the very last block.
  110|  7.59k|         MD::compress_n(m_digest, m_buffer.consume(), 1);
  111|  7.59k|      }
_ZN5Botan18MerkleDamgard_HashINS_7SHA_256EE11copy_outputENSt3__14spanIhLm18446744073709551615EEE:
  113|  7.59k|      void copy_output(std::span<uint8_t> output) {
  114|  7.59k|         BOTAN_ASSERT_NOMSG(output.size() >= MD::output_bytes);
  ------------------
  |  |   60|  7.59k|   do {                                                                     \
  |  |   61|  7.59k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 7.59k]
  |  |  ------------------
  |  |   62|  7.59k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  7.59k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 7.59k]
  |  |  ------------------
  ------------------
  115|       |
  116|  7.59k|         if constexpr(MD::byte_endianness == MD_Endian::Big) {
  117|  7.59k|            copy_out_be(output.first(MD::output_bytes), m_digest);
  118|       |         } else {
  119|       |            copy_out_le(output.first(MD::output_bytes), m_digest);
  120|       |         }
  121|  7.59k|      }

_ZN5Botan4rotlILm4EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotrILm18EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotrILm6EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotlILm9EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm6EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm20EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm10EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm23EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm7EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm12EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm17EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm22EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm5EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm14EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm11EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm16EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm15EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan4rotlILm21EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   23|  25.5k|{
   24|  25.5k|   return static_cast<T>((input << ROT) | (input >> (8 * sizeof(T) - ROT)));
   25|  25.5k|}
_ZN5Botan3rhoILm2ELm13ELm22EjEET2_S1_:
   51|  9.69M|inline constexpr T rho(T x) {
   52|  9.69M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  9.69M|}
_ZN5Botan4rotrILm2EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotrILm13EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotrILm22EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan3rhoILm6ELm11ELm25EjEET2_S1_:
   51|  9.69M|inline constexpr T rho(T x) {
   52|  9.69M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ rotr<R3>(x);
   53|  9.69M|}
_ZN5Botan4rotrILm11EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotrILm25EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan5sigmaILm17ELm19ELm10EjEET2_S1_:
   43|  9.69M|inline constexpr T sigma(T x) {
   44|  9.69M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  9.69M|}
_ZN5Botan4rotrILm17EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan4rotrILm19EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}
_ZN5Botan5sigmaILm7ELm18ELm3EjEET2_S1_:
   43|  9.69M|inline constexpr T sigma(T x) {
   44|  9.69M|   return rotr<R1>(x) ^ rotr<R2>(x) ^ (x >> S);
   45|  9.69M|}
_ZN5Botan4rotrILm7EjEET0_S1_QaagtT_Li0EltT_mlLi8EstS1_:
   35|  9.69M|{
   36|  9.69M|   return static_cast<T>((input >> ROT) | (input << (8 * sizeof(T) - ROT)));
   37|  9.69M|}

_ZN5Botan11checked_mulEmm:
   47|  10.7k|inline std::optional<size_t> checked_mul(size_t x, size_t y) {
   48|  10.7k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_add_overflow)
   49|  10.7k|   size_t z;
   50|  10.7k|   if(__builtin_mul_overflow(x, y, &z)) [[unlikely]]
  ------------------
  |  Branch (50:7): [True: 0, False: 10.7k]
  ------------------
   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|  10.7k|   return z;
   62|  10.7k|}

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

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

_ZN5Botan12BufferSlicerC2ENSt3__14spanIKhLm18446744073709551615EEE:
  144|  54.3k|      BufferSlicer(std::span<const uint8_t> buffer) : m_remaining(buffer) {}
_ZN5Botan12BufferSlicer4takeEm:
  156|   202k|      std::span<const uint8_t> take(const size_t count) {
  157|   202k|         BOTAN_STATE_CHECK(remaining() >= count);
  ------------------
  |  |   42|   202k|   do {                                                         \
  |  |   43|   202k|      if(!(expr))                                               \
  |  |  ------------------
  |  |  |  Branch (43:10): [True: 0, False: 202k]
  |  |  ------------------
  |  |   44|   202k|         Botan::throw_invalid_state(#expr, __func__, __FILE__); \
  |  |   45|   202k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (45:12): [Folded, False: 202k]
  |  |  ------------------
  ------------------
  158|   202k|         auto result = m_remaining.first(count);
  159|   202k|         m_remaining = m_remaining.subspan(count);
  160|   202k|         return result;
  161|   202k|      }
_ZNK5Botan12BufferSlicer9remainingEv:
  185|   264k|      size_t remaining() const { return m_remaining.size(); }
_ZNK5Botan12BufferSlicer5emptyEv:
  187|  67.3k|      bool empty() const { return m_remaining.empty(); }

_ZN5Botan20Buffered_ComputationD2Ev:
  134|  12.5k|      virtual ~Buffered_Computation() = default;

_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIhLm4EEEEEvOT0_:
   97|   121k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|   121k|   const std::span s{r};
   99|   121k|   if constexpr(statically_spanable_range<R>) {
  100|   121k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  101|       |   } else {
  102|       |      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  103|       |   }
  104|   121k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm4EEETpTkNS0_14spanable_rangeEJRNS3_IKjLm1EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  60.7k|{
  119|  60.7k|   const std::span s0{r0};
  120|       |
  121|  60.7k|   if constexpr(statically_spanable_range<R0>) {
  122|  60.7k|      constexpr size_t expected_size = s0.size_bytes();
  123|  60.7k|      (assert_exact_byte_length<expected_size>(rs), ...);
  124|       |   } else {
  125|       |      const size_t expected_size = s0.size_bytes();
  126|       |      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  127|       |                      "memory regions don't have equal lengths");
  128|       |   }
  129|  60.7k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIKjLm1EEEEEvOT0_:
   97|  60.7k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  60.7k|   const std::span s{r};
   99|  60.7k|   if constexpr(statically_spanable_range<R>) {
  100|  60.7k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  101|       |   } else {
  102|       |      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  103|       |   }
  104|  60.7k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm4EEEEEmOT_:
   84|  60.7k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  60.7k|   return std::span{r}.size_bytes();
   86|  60.7k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeERNSt3__14spanIhLm8EEEEEvOT0_:
   97|  10.7k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  10.7k|   const std::span s{r};
   99|  10.7k|   if constexpr(statically_spanable_range<R>) {
  100|  10.7k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  101|       |   } else {
  102|       |      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  103|       |   }
  104|  10.7k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm8EEETpTkNS0_14spanable_rangeEJRNS3_IKmLm1EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  10.7k|{
  119|  10.7k|   const std::span s0{r0};
  120|       |
  121|  10.7k|   if constexpr(statically_spanable_range<R0>) {
  122|  10.7k|      constexpr size_t expected_size = s0.size_bytes();
  123|  10.7k|      (assert_exact_byte_length<expected_size>(rs), ...);
  124|       |   } else {
  125|       |      const size_t expected_size = s0.size_bytes();
  126|       |      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  127|       |                      "memory regions don't have equal lengths");
  128|       |   }
  129|  10.7k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeERNSt3__14spanIKmLm1EEEEEvOT0_:
   97|  10.7k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  10.7k|   const std::span s{r};
   99|  10.7k|   if constexpr(statically_spanable_range<R>) {
  100|  10.7k|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  101|       |   } else {
  102|       |      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  103|       |   }
  104|  10.7k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm8EEEEEmOT_:
   84|  10.7k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  10.7k|   return std::span{r}.size_bytes();
   86|  10.7k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIjLm18446744073709551615EEETpTkNS0_14spanable_rangeEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  5.20M|{
  119|  5.20M|   const std::span s0{r0};
  120|       |
  121|       |   if constexpr(statically_spanable_range<R0>) {
  122|       |      constexpr size_t expected_size = s0.size_bytes();
  123|       |      (assert_exact_byte_length<expected_size>(rs), ...);
  124|  5.20M|   } else {
  125|  5.20M|      const size_t expected_size = s0.size_bytes();
  126|  5.20M|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  5.20M|   do {                                                          \
  |  |   31|  5.20M|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 5.20M]
  |  |  ------------------
  |  |   32|  5.20M|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  5.20M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded, False: 5.20M]
  |  |  ------------------
  ------------------
  127|  5.20M|                      "memory regions don't have equal lengths");
  128|  5.20M|   }
  129|  5.20M|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIKhLm4EEEEEvOT0_:
   97|  4.84M|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  4.84M|   const std::span s{r};
   99|  4.84M|   if constexpr(statically_spanable_range<R>) {
  100|  4.84M|      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  101|       |   } else {
  102|       |      BOTAN_ASSERT(s.size_bytes() == expected, "memory region does not have expected byte lengths");
  103|       |   }
  104|  4.84M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIjLm1EEETpTkNS0_14spanable_rangeEJRNS3_IKhLm4EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  2.42M|{
  119|  2.42M|   const std::span s0{r0};
  120|       |
  121|  2.42M|   if constexpr(statically_spanable_range<R0>) {
  122|  2.42M|      constexpr size_t expected_size = s0.size_bytes();
  123|  2.42M|      (assert_exact_byte_length<expected_size>(rs), ...);
  124|       |   } else {
  125|       |      const size_t expected_size = s0.size_bytes();
  126|       |      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  127|       |                      "memory regions don't have equal lengths");
  128|       |   }
  129|  2.42M|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIjLm1EEEEEmOT_:
   84|  2.42M|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  2.42M|   return std::span{r}.size_bytes();
   86|  2.42M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJRNS3_IKjLm18446744073709551615EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  13.8k|{
  119|  13.8k|   const std::span s0{r0};
  120|       |
  121|       |   if constexpr(statically_spanable_range<R0>) {
  122|       |      constexpr size_t expected_size = s0.size_bytes();
  123|       |      (assert_exact_byte_length<expected_size>(rs), ...);
  124|  13.8k|   } else {
  125|  13.8k|      const size_t expected_size = s0.size_bytes();
  126|  13.8k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  13.8k|   do {                                                          \
  |  |   31|  13.8k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 13.8k]
  |  |  ------------------
  |  |   32|  13.8k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  13.8k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded, False: 13.8k]
  |  |  ------------------
  ------------------
  127|  13.8k|                      "memory regions don't have equal lengths");
  128|  13.8k|   }
  129|  13.8k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIjLm18446744073709551615EEEEEmOT_:
   84|  2.60M|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  2.60M|   return std::span{r}.size_bytes();
   86|  2.60M|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm18446744073709551615EEEEEmOT_:
   84|  3.12k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  3.12k|   return std::span{r}.size_bytes();
   86|  3.12k|}

_ZN5Botan11clear_bytesEPvm:
  103|  32.8k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  32.8k|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 32.8k, False: 0]
  ------------------
  105|  32.8k|      std::memset(ptr, 0, bytes);
  106|  32.8k|   }
  107|  32.8k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIhLm4EEEjQaaaasr3stdE23is_trivially_copyable_vIT0_Entsr3std6rangesE5rangeIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEEvOSB_RKS6_:
  201|  60.7k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  202|  60.7k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  203|  60.7k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIhLm4EEETkNS1_16contiguous_rangeENS3_IKjLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS8_IXsr21__is_primary_templateINS9_Iu14__remove_cvrefIDTclL_ZNSB_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSH_ISP_EESQ_E4type10value_typeEEEEvOSM_OSC_:
  178|  60.7k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  60.7k|   ranges::assert_equal_byte_lengths(out, in);
  180|  60.7k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  60.7k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIhLm8EEEmQaaaasr3stdE23is_trivially_copyable_vIT0_Entsr3std6rangesE5rangeIS6_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEEEvOSB_RKS6_:
  201|  10.7k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  202|  10.7k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  203|  10.7k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIhLm8EEETkNS1_16contiguous_rangeENS3_IKmLm1EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS8_IXsr21__is_primary_templateINS9_Iu14__remove_cvrefIDTclL_ZNSB_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSH_ISP_EESQ_E4type10value_typeEEEEvOSM_OSC_:
  178|  10.7k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  10.7k|   ranges::assert_equal_byte_lengths(out, in);
  180|  10.7k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  10.7k|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeERNSt3__14spanIKhLm4EEEQaaaasr3stdE26is_default_constructible_vIT_Esr3stdE23is_trivially_copyable_vIS7_Esr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEEES7_OSC_:
  212|  2.42M|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  213|  2.42M|   ToT dst;
  214|  2.42M|   typecast_copy(dst, src);
  215|  2.42M|   return dst;
  216|  2.42M|}
_ZN5Botan13typecast_copyIjTkNS_6ranges16contiguous_rangeERNSt3__14spanIKhLm4EEEQaaaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISE_EESF_E4type10value_typeEEsr3stdE23is_trivially_copyable_vIT_Entsr3std6rangesE5rangeISL_EEEvRSL_OSB_:
  190|  2.42M|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  191|  2.42M|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  192|  2.42M|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeENSt3__14spanIjLm1EEETkNS1_16contiguous_rangeERNS3_IKhLm4EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISF_EESG_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS8_IXsr21__is_primary_templateINS9_Iu14__remove_cvrefIDTclL_ZNSB_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSH_ISP_EESQ_E4type10value_typeEEEEvOSM_OSC_:
  178|  2.42M|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  2.42M|   ranges::assert_equal_byte_lengths(out, in);
  180|  2.42M|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  2.42M|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|  32.8k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  32.8k|   clear_bytes(ptr, sizeof(T) * n);
  122|  32.8k|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIjLm18446744073709551615EEETkNS1_16contiguous_rangeERNS3_IKhLm18446744073709551615EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISG_EESH_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS9_IXsr21__is_primary_templateINSA_Iu14__remove_cvrefIDTclL_ZNSC_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSI_ISQ_EESR_E4type10value_typeEEEEvOSN_OSD_:
  178|  2.60M|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  2.60M|   ranges::assert_equal_byte_lengths(out, in);
  180|  2.60M|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  2.60M|}
_ZN5Botan13typecast_copyITkNS_6ranges23contiguous_output_rangeERNSt3__14spanIhLm18446744073709551615EEETkNS1_16contiguous_rangeERNS3_IKjLm18446744073709551615EEEQaasr3stdE23is_trivially_copyable_vINS2_11conditionalIXsr21__is_primary_templateINS2_15iterator_traitsIu14__remove_cvrefIDTclL_ZNS2_6ranges5__cpo5beginEEclsr3stdE7declvalIRT0_EEEEEEEEE5valueENS2_26indirectly_readable_traitsISG_EESH_E4type10value_typeEEsr3stdE23is_trivially_copyable_vINS9_IXsr21__is_primary_templateINSA_Iu14__remove_cvrefIDTclL_ZNSC_5beginEEclsr3stdE7declvalIRT_EEEEEEEEE5valueENSI_ISQ_EESR_E4type10value_typeEEEEvOSN_OSD_:
  178|  3.12k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  3.12k|   ranges::assert_equal_byte_lengths(out, in);
  180|  3.12k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  3.12k|}
_ZN5Botan8copy_memIiQsr3std10is_trivialINSt3__15decayIT_E4typeEEE5valueEEvPS3_PKS3_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, False: 1.53k]
  |  |  ------------------
  ------------------
  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|}

_ZN5Botan16secure_allocatorIjE8allocateEm:
   45|  10.7k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIjE10deallocateEPjm:
   47|  10.7k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }

_ZN5Botan10hex_encodeEPcPKhmb:
   33|   410k|void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase) {
   34|  81.7M|   for(size_t i = 0; i != input_length; ++i) {
  ------------------
  |  Branch (34:22): [True: 81.3M, False: 410k]
  ------------------
   35|  81.3M|      const uint8_t n0 = (input[i] >> 4) & 0xF;
   36|  81.3M|      const uint8_t n1 = (input[i]) & 0xF;
   37|       |
   38|  81.3M|      output[2 * i] = hex_encode_nibble(n0, uppercase);
   39|  81.3M|      output[2 * i + 1] = hex_encode_nibble(n1, uppercase);
   40|  81.3M|   }
   41|   410k|}
hex.cpp:_ZN5Botan12_GLOBAL__N_117hex_encode_nibbleEhb:
   20|   162M|char hex_encode_nibble(uint8_t n, bool uppercase) {
   21|   162M|   BOTAN_DEBUG_ASSERT(n <= 15);
  ------------------
  |  |   99|   162M|      do {                          \
  |  |  100|   162M|      } while(0)
  |  |  ------------------
  |  |  |  Branch (100:15): [Folded, False: 162M]
  |  |  ------------------
  ------------------
   22|       |
   23|   162M|   const auto in_09 = CT::Mask<uint8_t>::is_lt(n, 10);
   24|       |
   25|   162M|   const char c_09 = n + '0';
   26|   162M|   const char c_af = n + (uppercase ? 'A' : 'a') - 10;
  ------------------
  |  Branch (26:27): [True: 0, False: 162M]
  ------------------
   27|       |
   28|   162M|   return in_09.select(c_09, c_af);
   29|   162M|}

_ZN9Botan_FFI15ffi_guard_thunkEPKcRKNSt3__18functionIFivEEE:
  116|   410k|int ffi_guard_thunk(const char* func_name, const std::function<int()>& thunk) {
  117|   410k|   g_last_exception_what.clear();
  118|       |
  119|   410k|   try {
  120|   410k|      return thunk();
  121|   410k|   } catch(std::bad_alloc&) {
  122|      0|      return ffi_error_exception_thrown(func_name, "bad_alloc", BOTAN_FFI_ERROR_OUT_OF_MEMORY);
  123|      0|   } catch(Botan_FFI::FFI_Error& e) {
  124|      0|      return ffi_error_exception_thrown(func_name, e.what(), e.error_code());
  125|      0|   } catch(Botan::Exception& e) {
  126|      0|      return ffi_error_exception_thrown(func_name, e.what(), ffi_map_error_type(e.error_type()));
  127|      0|   } catch(std::exception& e) {
  128|      0|      return ffi_error_exception_thrown(func_name, e.what());
  129|      0|   } catch(...) {
  130|      0|      return ffi_error_exception_thrown(func_name, "unknown exception");
  131|      0|   }
  132|       |
  133|      0|   return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
  134|   410k|}
botan_scrub_mem:
  308|   225k|int botan_scrub_mem(void* mem, size_t bytes) {
  309|   225k|   Botan::secure_scrub_memory(mem, bytes);
  310|   225k|   return BOTAN_FFI_SUCCESS;
  311|   225k|}
botan_hex_encode:
  313|   410k|int botan_hex_encode(const uint8_t* in, size_t len, char* out, uint32_t flags) {
  314|   410k|   return ffi_guard_thunk(__func__, [=]() -> int {
  315|   410k|      const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
  316|   410k|      Botan::hex_encode(out, in, len, uppercase);
  317|   410k|      return BOTAN_FFI_SUCCESS;
  318|   410k|   });
  319|   410k|}
ffi.cpp:_ZZ16botan_hex_encodeENK3$_0clEv:
  314|   410k|   return ffi_guard_thunk(__func__, [=]() -> int {
  315|   410k|      const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
  ------------------
  |  |  225|   410k|#define BOTAN_FFI_HEX_LOWER_CASE 1
  ------------------
  316|   410k|      Botan::hex_encode(out, in, len, uppercase);
  317|   410k|      return BOTAN_FFI_SUCCESS;
  318|   410k|   });

_ZN5Botan5CRC248add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  175|  2.51k|void CRC24::add_data(std::span<const uint8_t> input) {
  176|  2.51k|   uint32_t tmp = m_crc;
  177|       |
  178|       |   // Input is word aligned if WA & input == 0
  179|  2.51k|   static const uint8_t WA = sizeof(size_t) - 1;
  180|       |
  181|       |   // Ensure input is word aligned before processing in parallel
  182|  4.28k|   for(; !input.empty() && (reinterpret_cast<uintptr_t>(input.data()) & WA); input = input.last(input.size() - 1)) {
  ------------------
  |  Branch (182:10): [True: 3.30k, False: 984]
  |  Branch (182:28): [True: 1.76k, False: 1.53k]
  ------------------
  183|  1.76k|      tmp = process8(tmp, input.front());
  184|  1.76k|   }
  185|       |
  186|  2.59M|   while(input.size() >= 16) {
  ------------------
  |  Branch (186:10): [True: 2.59M, False: 2.51k]
  ------------------
  187|  2.59M|      uint32_t d[4];
  188|  2.59M|      load_le(d, input.data(), 4);
  189|  2.59M|      tmp = process32(tmp, d[0]);
  190|  2.59M|      tmp = process32(tmp, d[1]);
  191|  2.59M|      tmp = process32(tmp, d[2]);
  192|  2.59M|      tmp = process32(tmp, d[3]);
  193|       |
  194|  2.59M|      input = input.last(input.size() - 16);
  195|  2.59M|   }
  196|       |
  197|  17.0k|   for(; !input.empty(); input = input.last(input.size() - 1)) {
  ------------------
  |  Branch (197:10): [True: 14.5k, False: 2.51k]
  ------------------
  198|  14.5k|      tmp = process8(tmp, input.front());
  199|  14.5k|   }
  200|       |
  201|  2.51k|   m_crc = tmp;
  202|  2.51k|}
_ZN5Botan5CRC2412final_resultENSt3__14spanIhLm18446744073709551615EEE:
  207|    249|void CRC24::final_result(std::span<uint8_t> output) {
  208|    249|   output[0] = get_byte<3>(m_crc);
  209|    249|   output[1] = get_byte<2>(m_crc);
  210|    249|   output[2] = get_byte<1>(m_crc);
  211|    249|   clear();
  212|    249|}
crc24.cpp:_ZN5Botan12_GLOBAL__N_18process8Ejh:
  142|  16.3k|inline uint32_t process8(uint32_t crc, uint8_t data) {
  143|  16.3k|   return (crc >> 8) ^ CRC24_T0[get_byte<3>(crc) ^ data];
  144|  16.3k|}
crc24.cpp:_ZN5Botan12_GLOBAL__N_19process32Ejj:
  146|  10.3M|inline uint32_t process32(uint32_t crc, uint32_t word) {
  147|  10.3M|   const uint32_t sum = crc ^ word;
  148|       |
  149|  10.3M|   return CRC24_T3[get_byte<3>(sum)] ^ CRC24_T2[get_byte<2>(sum)] ^ CRC24_T1[get_byte<1>(sum)] ^
  150|  10.3M|          CRC24_T0[get_byte<0>(sum)];
  151|  10.3M|}

_ZN5Botan12HashFunction6createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
  107|  12.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|  12.5k|   if(provider.empty() == false && provider != "base") {
  ------------------
  |  Branch (118:7): [True: 0, False: 12.5k]
  |  Branch (118:36): [True: 0, False: 0]
  ------------------
  119|      0|      return nullptr;  // unknown provider
  120|      0|   }
  121|       |
  122|  12.5k|#if defined(BOTAN_HAS_SHA1)
  123|  12.5k|   if(algo_spec == "SHA-1") {
  ------------------
  |  Branch (123:7): [True: 0, False: 12.5k]
  ------------------
  124|      0|      return std::make_unique<SHA_1>();
  125|      0|   }
  126|  12.5k|#endif
  127|       |
  128|  12.5k|#if defined(BOTAN_HAS_SHA2_32)
  129|  12.5k|   if(algo_spec == "SHA-224") {
  ------------------
  |  Branch (129:7): [True: 0, False: 12.5k]
  ------------------
  130|      0|      return std::make_unique<SHA_224>();
  131|      0|   }
  132|       |
  133|  12.5k|   if(algo_spec == "SHA-256") {
  ------------------
  |  Branch (133:7): [True: 7.59k, False: 4.95k]
  ------------------
  134|  7.59k|      return std::make_unique<SHA_256>();
  135|  7.59k|   }
  136|  4.95k|#endif
  137|       |
  138|  4.95k|#if defined(BOTAN_HAS_SHA2_64)
  139|  4.95k|   if(algo_spec == "SHA-384") {
  ------------------
  |  Branch (139:7): [True: 0, False: 4.95k]
  ------------------
  140|      0|      return std::make_unique<SHA_384>();
  141|      0|   }
  142|       |
  143|  4.95k|   if(algo_spec == "SHA-512") {
  ------------------
  |  Branch (143:7): [True: 0, False: 4.95k]
  ------------------
  144|      0|      return std::make_unique<SHA_512>();
  145|      0|   }
  146|       |
  147|  4.95k|   if(algo_spec == "SHA-512-256") {
  ------------------
  |  Branch (147:7): [True: 0, False: 4.95k]
  ------------------
  148|      0|      return std::make_unique<SHA_512_256>();
  149|      0|   }
  150|  4.95k|#endif
  151|       |
  152|  4.95k|#if defined(BOTAN_HAS_RIPEMD_160)
  153|  4.95k|   if(algo_spec == "RIPEMD-160") {
  ------------------
  |  Branch (153:7): [True: 0, False: 4.95k]
  ------------------
  154|      0|      return std::make_unique<RIPEMD_160>();
  155|      0|   }
  156|  4.95k|#endif
  157|       |
  158|       |#if defined(BOTAN_HAS_WHIRLPOOL)
  159|       |   if(algo_spec == "Whirlpool") {
  160|       |      return std::make_unique<Whirlpool>();
  161|       |   }
  162|       |#endif
  163|       |
  164|  4.95k|#if defined(BOTAN_HAS_MD5)
  165|  4.95k|   if(algo_spec == "MD5") {
  ------------------
  |  Branch (165:7): [True: 3.12k, False: 1.82k]
  ------------------
  166|  3.12k|      return std::make_unique<MD5>();
  167|  3.12k|   }
  168|  1.82k|#endif
  169|       |
  170|       |#if defined(BOTAN_HAS_MD4)
  171|       |   if(algo_spec == "MD4") {
  172|       |      return std::make_unique<MD4>();
  173|       |   }
  174|       |#endif
  175|       |
  176|       |#if defined(BOTAN_HAS_GOST_34_11)
  177|       |   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11") {
  178|       |      return std::make_unique<GOST_34_11>();
  179|       |   }
  180|       |#endif
  181|       |
  182|       |#if defined(BOTAN_HAS_ADLER32)
  183|       |   if(algo_spec == "Adler32") {
  184|       |      return std::make_unique<Adler32>();
  185|       |   }
  186|       |#endif
  187|       |
  188|  1.82k|#if defined(BOTAN_HAS_CRC24)
  189|  1.82k|   if(algo_spec == "CRC24") {
  ------------------
  |  Branch (189:7): [True: 1.82k, False: 0]
  ------------------
  190|  1.82k|      return std::make_unique<CRC24>();
  191|  1.82k|   }
  192|      0|#endif
  193|       |
  194|       |#if defined(BOTAN_HAS_CRC32)
  195|       |   if(algo_spec == "CRC32") {
  196|       |      return std::make_unique<CRC32>();
  197|       |   }
  198|       |#endif
  199|       |
  200|       |#if defined(BOTAN_HAS_STREEBOG)
  201|       |   if(algo_spec == "Streebog-256") {
  202|       |      return std::make_unique<Streebog>(256);
  203|       |   }
  204|       |   if(algo_spec == "Streebog-512") {
  205|       |      return std::make_unique<Streebog>(512);
  206|       |   }
  207|       |#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|       |#if defined(BOTAN_HAS_SKEIN_512)
  218|       |   if(req.algo_name() == "Skein-512") {
  219|       |      return std::make_unique<Skein_512>(req.arg_as_integer(0, 512), req.arg(1, ""));
  220|       |   }
  221|       |#endif
  222|       |
  223|       |#if defined(BOTAN_HAS_BLAKE2B)
  224|       |   if(req.algo_name() == "Blake2b" || req.algo_name() == "BLAKE2b") {
  225|       |      return std::make_unique<BLAKE2b>(req.arg_as_integer(0, 512));
  226|       |   }
  227|       |#endif
  228|       |
  229|       |#if defined(BOTAN_HAS_BLAKE2S)
  230|       |   if(req.algo_name() == "Blake2s" || req.algo_name() == "BLAKE2s") {
  231|       |      return std::make_unique<BLAKE2s>(req.arg_as_integer(0, 256));
  232|       |   }
  233|       |#endif
  234|       |
  235|       |#if defined(BOTAN_HAS_KECCAK)
  236|       |   if(req.algo_name() == "Keccak-1600") {
  237|       |      return std::make_unique<Keccak_1600>(req.arg_as_integer(0, 512));
  238|       |   }
  239|       |#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|       |#if defined(BOTAN_HAS_PARALLEL_HASH)
  257|       |   if(req.algo_name() == "Parallel") {
  258|       |      std::vector<std::unique_ptr<HashFunction>> hashes;
  259|       |
  260|       |      for(size_t i = 0; i != req.arg_count(); ++i) {
  261|       |         auto h = HashFunction::create(req.arg(i));
  262|       |         if(!h) {
  263|       |            return nullptr;
  264|       |         }
  265|       |         hashes.push_back(std::move(h));
  266|       |      }
  267|       |
  268|       |      return std::make_unique<Parallel>(hashes);
  269|       |   }
  270|       |#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|       |#if defined(BOTAN_HAS_COMB4P)
  284|       |   if(req.algo_name() == "Comb4P" && req.arg_count() == 2) {
  285|       |      auto h1 = HashFunction::create(req.arg(0));
  286|       |      auto h2 = HashFunction::create(req.arg(1));
  287|       |
  288|       |      if(h1 && h2) {
  289|       |         return std::make_unique<Comb4P>(std::move(h1), std::move(h2));
  290|       |      }
  291|       |   }
  292|       |#endif
  293|       |
  294|      0|   return nullptr;
  295|      0|}

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

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

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

_ZN5Botan19secure_scrub_memoryEPvm:
   87|   247k|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|       |   ::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|   247k|}

_ZN3rnp13is_blank_lineEPKcm:
   72|  15.0k|{
   73|  15.8k|    for (size_t i = 0; i < len && line[i]; i++) {
  ------------------
  |  Branch (73:24): [True: 15.8k, False: 0]
  |  Branch (73:35): [True: 15.8k, False: 0]
  ------------------
   74|  15.8k|        if (line[i] != ' ' && line[i] != '\t' && line[i] != '\r') {
  ------------------
  |  Branch (74:13): [True: 15.5k, False: 244]
  |  Branch (74:31): [True: 15.1k, False: 446]
  |  Branch (74:50): [True: 15.0k, False: 138]
  ------------------
   75|  15.0k|            return false;
   76|  15.0k|        }
   77|  15.8k|    }
   78|      0|    return true;
   79|  15.0k|}

_Z17rnp_y2k38_warningl:
   41|  21.8k|{
   42|  21.8k|    return (sizeof(t) == 4 && (t < 0 || t == INT32_MAX));
  ------------------
  |  Branch (42:13): [Folded, False: 21.8k]
  |  Branch (42:32): [True: 0, False: 0]
  |  Branch (42:41): [True: 0, False: 0]
  ------------------
   43|  21.8k|}
_Z9rnp_ctimel:
   75|  21.8k|{
   76|  21.8k|    char   time_buf[26];
   77|  21.8k|    time_t adjusted = adjust_time32(t);
   78|  21.8k|#ifndef _WIN32
   79|  21.8k|    (void) ctime_r(&adjusted, time_buf);
   80|       |#else
   81|       |    (void) ctime_s(time_buf, sizeof(time_buf), &adjusted);
   82|       |#endif
   83|  21.8k|    return std::string(time_buf);
   84|  21.8k|}
time-utils.cpp:_ZL13adjust_time32l:
   35|  21.8k|{
   36|  21.8k|    return (sizeof(t) == 4 && t < 0) ? INT32_MAX : t;
  ------------------
  |  Branch (36:13): [Folded, False: 21.8k]
  |  Branch (36:31): [True: 0, False: 0]
  ------------------
   37|  21.8k|}

LLVMFuzzerTestOneInput:
   37|  7.83k|{
   38|  7.83k|    rnp_input_t input = NULL;
   39|  7.83k|    (void) rnp_input_from_memory(&input, data, size, false);
   40|  7.83k|    rnp_output_t output = NULL;
   41|  7.83k|    (void) rnp_output_to_null(&output);
   42|       |
   43|  7.83k|    (void) rnp_dump_packets_to_output(input, output, RNP_DUMP_RAW);
  ------------------
  |  |   74|  7.83k|#define RNP_DUMP_RAW (1U << 1)
  ------------------
   44|  7.83k|    rnp_output_destroy(output);
   45|  7.83k|    rnp_input_destroy(input);
   46|       |
   47|  7.83k|    rnp_input_t input2 = NULL;
   48|  7.83k|    (void) rnp_input_from_memory(&input2, data, size, false);
   49|  7.83k|    char *json = NULL;
   50|  7.83k|    (void) rnp_dump_packets_to_json(input2, RNP_DUMP_RAW, &json);
  ------------------
  |  |   74|  7.83k|#define RNP_DUMP_RAW (1U << 1)
  ------------------
   51|  7.83k|    rnp_buffer_destroy(json);
   52|  7.83k|    rnp_input_destroy(input2);
   53|       |
   54|  7.83k|    return 0;
   55|  7.83k|}

_ZNK26pgp_dilithium_public_key_t11get_encodedEv:
   97|  3.61k|    {
   98|  3.61k|        return key_encoded_;
   99|  3.61k|    };
_ZN26pgp_dilithium_public_key_tC2Ev:
   79|  15.9k|    pgp_dilithium_public_key_t() = default;

_ZN26pgp_dilithium_public_key_tC2EPKhm21dilithium_parameter_e:
   34|  7.29k|    : key_encoded_(key_encoded, key_encoded + key_encoded_len), dilithium_param_(param),
   35|  7.29k|      is_initialized_(true)
   36|  7.29k|{
   37|  7.29k|}
_Z21dilithium_pubkey_size21dilithium_parameter_e:
   76|  15.6k|{
   77|  15.6k|    switch (parameter) {
   78|  13.0k|    case dilithium_L3:
  ------------------
  |  Branch (78:5): [True: 13.0k, False: 2.57k]
  ------------------
   79|  13.0k|        return 1952;
   80|  2.57k|    case dilithium_L5:
  ------------------
  |  Branch (80:5): [True: 2.57k, False: 13.0k]
  ------------------
   81|  2.57k|        return 2592;
   82|      0|    default:
  ------------------
  |  Branch (82:5): [True: 0, False: 15.6k]
  ------------------
   83|      0|        RNP_LOG("invalid parameter given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   84|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   85|  15.6k|    }
   86|  15.6k|}
_Z24dilithium_signature_size21dilithium_parameter_e:
   90|  1.16k|{
   91|  1.16k|    switch (parameter) {
   92|    703|    case dilithium_L3:
  ------------------
  |  Branch (92:5): [True: 703, False: 458]
  ------------------
   93|    703|        return 3293;
   94|    458|    case dilithium_L5:
  ------------------
  |  Branch (94:5): [True: 458, False: 703]
  ------------------
   95|    458|        return 4595;
   96|      0|    default:
  ------------------
  |  Branch (96:5): [True: 0, False: 1.16k]
  ------------------
   97|      0|        RNP_LOG("invalid parameter given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   98|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   99|  1.16k|    }
  100|  1.16k|}

_ZN35pgp_dilithium_exdsa_composite_key_tD2Ev:
   32|  24.6k|{
   33|  24.6k|}
_ZNK35pgp_dilithium_exdsa_composite_key_t20initialized_or_throwEv:
   37|  3.61k|{
   38|  3.61k|    if (!is_initialized()) {
  ------------------
  |  Branch (38:9): [True: 0, False: 3.61k]
  ------------------
   39|      0|        RNP_LOG("Trying to use uninitialized mldsa-ecdsa/eddsa key");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   40|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_STATE);
   41|      0|    }
   42|  3.61k|}
_ZN35pgp_dilithium_exdsa_composite_key_t23exdsa_curve_pubkey_sizeE11pgp_curve_t:
   96|  22.9k|{
   97|  22.9k|    switch (curve) {
   98|  12.8k|    case PGP_CURVE_ED25519:
  ------------------
  |  Branch (98:5): [True: 12.8k, False: 10.0k]
  ------------------
   99|  12.8k|        return 32;
  100|       |    /* TODO */
  101|       |    //  case PGP_CURVE_ED448:
  102|       |    //    return 56;
  103|  3.05k|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (103:5): [True: 3.05k, False: 19.8k]
  ------------------
  104|  3.05k|        return 65;
  105|  1.79k|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (105:5): [True: 1.79k, False: 21.1k]
  ------------------
  106|  1.79k|        return 97;
  107|  3.31k|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (107:5): [True: 3.31k, False: 19.6k]
  ------------------
  108|  3.31k|        return 65;
  109|  1.89k|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (109:5): [True: 1.89k, False: 21.0k]
  ------------------
  110|  1.89k|        return 97;
  111|      0|    default:
  ------------------
  |  Branch (111:5): [True: 0, False: 22.9k]
  ------------------
  112|      0|        RNP_LOG("invalid curve given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  113|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  114|  22.9k|    }
  115|  22.9k|}
_ZN35pgp_dilithium_exdsa_composite_key_t26exdsa_curve_signature_sizeE11pgp_curve_t:
  119|  1.16k|{
  120|  1.16k|    switch (curve) {
  121|    278|    case PGP_CURVE_ED25519:
  ------------------
  |  Branch (121:5): [True: 278, False: 883]
  ------------------
  122|    278|        return 64;
  123|       |    /* TODO */
  124|       |    //  case PGP_CURVE_ED448:
  125|       |    //    return 114;
  126|    217|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (126:5): [True: 217, False: 944]
  ------------------
  127|    217|        return 64;
  128|    221|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (128:5): [True: 221, False: 940]
  ------------------
  129|    221|        return 96;
  130|    208|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (130:5): [True: 208, False: 953]
  ------------------
  131|    208|        return 64;
  132|    237|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (132:5): [True: 237, False: 924]
  ------------------
  133|    237|        return 96;
  134|      0|    default:
  ------------------
  |  Branch (134:5): [True: 0, False: 1.16k]
  ------------------
  135|      0|        RNP_LOG("invalid curve given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  136|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  137|  1.16k|    }
  138|  1.16k|}
_ZN35pgp_dilithium_exdsa_composite_key_t22pk_alg_to_dilithium_idE16pgp_pubkey_alg_t:
  142|  24.0k|{
  143|  24.0k|    switch (pk_alg) {
  144|  13.1k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (144:5): [True: 13.1k, False: 10.9k]
  ------------------
  145|  13.1k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  13.1k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  146|  16.4k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (146:5): [True: 3.27k, False: 20.8k]
  ------------------
  147|  16.4k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  16.4k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  148|  19.9k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (148:5): [True: 3.52k, False: 20.5k]
  ------------------
  149|  19.9k|        return dilithium_L3;
  150|  2.12k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (150:5): [True: 2.12k, False: 21.9k]
  ------------------
  151|  2.12k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.12k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  152|  4.14k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (152:5): [True: 2.01k, False: 22.0k]
  ------------------
  153|  4.14k|        return dilithium_L5;
  154|      0|    default:
  ------------------
  |  Branch (154:5): [True: 0, False: 24.0k]
  ------------------
  155|      0|        RNP_LOG("invalid PK alg given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  157|  24.0k|    }
  158|  24.0k|}
_ZN35pgp_dilithium_exdsa_composite_key_t18pk_alg_to_curve_idE16pgp_pubkey_alg_t:
  162|  31.3k|{
  163|  31.3k|    switch (pk_alg) {
  164|  17.3k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (164:5): [True: 17.3k, False: 14.0k]
  ------------------
  165|  17.3k|        return PGP_CURVE_ED25519;
  166|  4.18k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (166:5): [True: 4.18k, False: 27.1k]
  ------------------
  167|  4.18k|        return PGP_CURVE_NIST_P_256;
  168|  4.59k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (168:5): [True: 4.59k, False: 26.7k]
  ------------------
  169|  4.59k|        return PGP_CURVE_BP256;
  170|  2.69k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (170:5): [True: 2.69k, False: 28.6k]
  ------------------
  171|  2.69k|        return PGP_CURVE_BP384;
  172|  2.57k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (172:5): [True: 2.57k, False: 28.8k]
  ------------------
  173|  2.57k|        return PGP_CURVE_NIST_P_384;
  174|       |    /*case PGP_PKA_DILITHIUM5_ED448:
  175|       |      throw rnp::rnp_exception(RNP_ERROR_NOT_IMPLEMENTED);*/
  176|      0|    default:
  ------------------
  |  Branch (176:5): [True: 0, False: 31.3k]
  ------------------
  177|      0|        RNP_LOG("invalid PK alg given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  178|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  179|  31.3k|    }
  180|  31.3k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE16pgp_pubkey_alg_t:
  191|  7.29k|    : pk_alg_(pk_alg)
  192|  7.29k|{
  193|  7.29k|    parse_component_keys(key_encoded);
  194|  7.29k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_t12encoded_sizeE16pgp_pubkey_alg_t:
  358|  15.6k|{
  359|  15.6k|    dilithium_parameter_e dilithium_param = pk_alg_to_dilithium_id(pk_alg);
  360|  15.6k|    pgp_curve_t           curve = pk_alg_to_curve_id(pk_alg);
  361|  15.6k|    return exdsa_curve_pubkey_size(curve) + dilithium_pubkey_size(dilithium_param);
  362|  15.6k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_t20parse_component_keysENSt3__16vectorIhNS0_9allocatorIhEEEE:
  367|  7.29k|{
  368|  7.29k|    if (key_encoded.size() != encoded_size(pk_alg_)) {
  ------------------
  |  Branch (368:9): [True: 0, False: 7.29k]
  ------------------
  369|      0|        RNP_LOG("ML-DSA composite key format invalid: length mismatch");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  370|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  371|      0|    }
  372|       |
  373|  7.29k|    dilithium_parameter_e dilithium_param = pk_alg_to_dilithium_id(pk_alg_);
  374|  7.29k|    pgp_curve_t           curve = pk_alg_to_curve_id(pk_alg_);
  375|  7.29k|    size_t                split_at = exdsa_curve_pubkey_size(pk_alg_to_curve_id(pk_alg_));
  376|       |
  377|  7.29k|    dilithium_key_ = pgp_dilithium_public_key_t(
  378|  7.29k|      key_encoded.data() + split_at, key_encoded.size() - split_at, dilithium_param);
  379|  7.29k|    exdsa_key_ = exdsa_public_key_t(key_encoded.data(), split_at, curve);
  380|       |
  381|  7.29k|    is_initialized_ = true;
  382|  7.29k|}
_ZNK42pgp_dilithium_exdsa_composite_public_key_t11get_encodedEv:
  386|  3.61k|{
  387|  3.61k|    initialized_or_throw();
  388|  3.61k|    std::vector<uint8_t> result;
  389|  3.61k|    std::vector<uint8_t> exdsa_key_encoded = exdsa_key_.get_encoded();
  390|  3.61k|    std::vector<uint8_t> dilithium_key_encoded = dilithium_key_.get_encoded();
  391|       |
  392|  3.61k|    result.insert(result.end(), std::begin(exdsa_key_encoded), std::end(exdsa_key_encoded));
  393|  3.61k|    result.insert(
  394|  3.61k|      result.end(), std::begin(dilithium_key_encoded), std::end(dilithium_key_encoded));
  395|  3.61k|    return result;
  396|  3.61k|};

_ZNK35pgp_dilithium_exdsa_composite_key_t14is_initializedEv:
   58|  3.61k|    {
   59|  3.61k|        return is_initialized_;
   60|  3.61k|    }
_ZN31pgp_dilithium_exdsa_signature_t24composite_signature_sizeE16pgp_pubkey_alg_t:
   72|  1.16k|    {
   73|  1.16k|        return dilithium_signature_size(
   74|  1.16k|                 pgp_dilithium_exdsa_composite_key_t::pk_alg_to_dilithium_id(pk_alg)) +
   75|  1.16k|               pgp_dilithium_exdsa_composite_key_t::exdsa_curve_signature_size(
   76|  1.16k|                 pgp_dilithium_exdsa_composite_key_t::pk_alg_to_curve_id(pk_alg));
   77|  1.16k|    }
_ZN43pgp_dilithium_exdsa_composite_private_key_tC2Ev:
   96|  8.69k|    pgp_dilithium_exdsa_composite_private_key_t() = default;
_ZN42pgp_dilithium_exdsa_composite_public_key_tC2Ev:
  140|  8.69k|    pgp_dilithium_exdsa_composite_public_key_t() = default;

_ZN3pgp3dsa3Key12clear_secretEv:
   56|  1.51k|    {
   57|  1.51k|        x.forget();
   58|  1.51k|    }
_ZN3pgp3dsa3KeyD2Ev:
   61|  1.51k|    {
   62|  1.51k|        clear_secret();
   63|  1.51k|    }

_ZNK3pgp2ec5Curve5bytesEv:
  102|  4.08k|    {
  103|       |        return BITS_TO_BYTES(bitlen);
  ------------------
  |  |   56|  4.08k|#define BITS_TO_BYTES(b) (((b) + (CHAR_BIT - 1)) / CHAR_BIT)
  ------------------
  104|  4.08k|    }
_ZN3pgp2ec3Key12clear_secretEv:
  125|  10.0k|    {
  126|  10.0k|        x.forget();
  127|  10.0k|    }
_ZN3pgp2ec3KeyD2Ev:
  130|  10.0k|    {
  131|  10.0k|        clear_secret();
  132|  10.0k|    }
_ZN17pgp_ed25519_key_t12clear_secretEv:
  189|  1.72k|    {
  190|  1.72k|        secure_clear(priv.data(), priv.size());
  191|  1.72k|        priv.resize(0);
  192|  1.72k|    }
_ZN17pgp_ed25519_key_tD2Ev:
  195|  1.72k|    {
  196|  1.72k|        clear_secret();
  197|  1.72k|    }
_ZN16pgp_x25519_key_t12clear_secretEv:
  210|  1.89k|    {
  211|  1.89k|        secure_clear(priv.data(), priv.size());
  212|  1.89k|        priv.resize(0);
  213|  1.89k|    }
_ZN16pgp_x25519_key_tD2Ev:
  216|  1.89k|    {
  217|  1.89k|        clear_secret();
  218|  1.89k|    }

_ZN3pgp2ec5Curve6by_OIDERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  262|  7.56k|{
  263|  37.5k|    for (size_t i = 0; i < PGP_CURVE_MAX; i++) {
  ------------------
  |  Branch (263:24): [True: 36.0k, False: 1.56k]
  ------------------
  264|  36.0k|        if (oid == ec_curves[i].OID) {
  ------------------
  |  Branch (264:13): [True: 5.99k, False: 30.0k]
  ------------------
  265|  5.99k|            return static_cast<pgp_curve_t>(i);
  266|  5.99k|        }
  267|  36.0k|    }
  268|  1.56k|    return PGP_CURVE_MAX;
  269|  7.56k|}
_ZN3pgp2ec5Curve3getE11pgp_curve_t:
  285|  7.35k|{
  286|  7.35k|    return (curve_id < PGP_CURVE_MAX && curve_id > 0) ? &ec_curves[curve_id] : NULL;
  ------------------
  |  Branch (286:13): [True: 7.35k, False: 0]
  |  Branch (286:41): [True: 5.32k, False: 2.02k]
  ------------------
  287|  7.35k|}

_ZN3pgp2eg3Key12clear_secretEv:
   62|  3.20k|    {
   63|  3.20k|        x.forget();
   64|  3.20k|    }
_ZN3pgp2eg3KeyD2Ev:
   67|  3.20k|    {
   68|  3.20k|        clear_secret();
   69|  3.20k|    }

_ZN8ec_key_tD2Ev:
   39|  35.7k|{
   40|  35.7k|}
_ZN8ec_key_tC2E11pgp_curve_t:
   42|  11.0k|ec_key_t::ec_key_t(pgp_curve_t curve) : curve_(curve)
   43|  11.0k|{
   44|  11.0k|}
_ZN21ecdh_kem_public_key_tC2EPhm11pgp_curve_t:
   49|  3.72k|    : ec_key_t(curve), key_(std::vector<uint8_t>(key_buf, key_buf + key_buf_len))
   50|  3.72k|{
   51|  3.72k|}
_ZN18exdsa_public_key_tC2EPhm11pgp_curve_t:
  176|  7.29k|    : ec_key_t(curve), key_(key_buf, key_buf + key_buf_len)
  177|  7.29k|{
  178|  7.29k|}

_ZNK21ecdh_kem_public_key_t11get_encodedEv:
   85|  1.66k|    {
   86|  1.66k|        return key_;
   87|  1.66k|    }
_ZNK18exdsa_public_key_t11get_encodedEv:
  148|  3.61k|    {
  149|  3.61k|        return key_;
  150|  3.61k|    }
_ZN8ec_key_tC2Ev:
   50|  24.7k|    ec_key_t() = default;
_ZN21ecdh_kem_public_key_tC2Ev:
   73|  8.77k|    ecdh_kem_public_key_t() = default;
_ZN18exdsa_public_key_tC2Ev:
  136|  15.9k|    exdsa_public_key_t() = default;

_ZN3rnp10Hash_BotanC2E14pgp_hash_alg_t:
   49|  10.7k|Hash_Botan::Hash_Botan(pgp_hash_alg_t alg) : Hash(alg)
   50|  10.7k|{
   51|  10.7k|    auto name = Hash_Botan::name_backend(alg);
   52|  10.7k|    if (!name) {
  ------------------
  |  Branch (52:9): [True: 0, False: 10.7k]
  ------------------
   53|      0|        throw rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   54|      0|    }
   55|       |
   56|  10.7k|    fn_ = Botan::HashFunction::create(name);
   57|  10.7k|    if (!fn_) {
  ------------------
  |  Branch (57:9): [True: 0, False: 10.7k]
  ------------------
   58|      0|        RNP_LOG("Error creating hash object for '%s'", name);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|      0|        throw rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   60|      0|    }
   61|       |
   62|  10.7k|    assert(size_ == fn_->output_length());
   63|  10.7k|}
_ZN3rnp10Hash_BotanD2Ev:
   74|  10.7k|{
   75|  10.7k|}
_ZN3rnp10Hash_Botan6createE14pgp_hash_alg_t:
   79|  10.7k|{
   80|  10.7k|    return std::unique_ptr<Hash_Botan>(new Hash_Botan(alg));
   81|  10.7k|}
_ZN3rnp10Hash_Botan3addEPKvm:
   91|  30.2k|{
   92|  30.2k|    if (!fn_) {
  ------------------
  |  Branch (92:9): [True: 0, False: 30.2k]
  ------------------
   93|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
   94|      0|    }
   95|  30.2k|    fn_->update(static_cast<const uint8_t *>(buf), len);
   96|  30.2k|}
_ZN3rnp10Hash_Botan6finishEPh:
  100|  10.7k|{
  101|  10.7k|    assert(fn_);
  102|  10.7k|    if (!fn_) {
  ------------------
  |  Branch (102:9): [True: 0, False: 10.7k]
  ------------------
  103|      0|        return;
  104|      0|    }
  105|  10.7k|    if (digest) {
  ------------------
  |  Branch (105:9): [True: 10.7k, False: 0]
  ------------------
  106|  10.7k|        fn_->final(digest);
  107|  10.7k|    }
  108|  10.7k|    fn_ = nullptr;
  109|  10.7k|    size_ = 0;
  110|  10.7k|}
_ZN3rnp10Hash_Botan12name_backendE14pgp_hash_alg_t:
  114|  10.7k|{
  115|  10.7k|    return id_str_pair::lookup(botan_alg_map, alg);
  116|  10.7k|}
_ZN3rnp11CRC24_BotanC2Ev:
  119|  1.82k|{
  120|  1.82k|    fn_ = Botan::HashFunction::create("CRC24");
  121|  1.82k|    if (!fn_) {
  ------------------
  |  Branch (121:9): [True: 0, False: 1.82k]
  ------------------
  122|      0|        RNP_LOG("Error creating CRC24 object");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  123|      0|        throw rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  124|      0|    }
  125|  1.82k|    assert(3 == fn_->output_length());
  126|  1.82k|}
_ZN3rnp11CRC24_BotanD2Ev:
  129|  1.82k|{
  130|  1.82k|}
_ZN3rnp11CRC24_Botan6createEv:
  134|  1.82k|{
  135|  1.82k|    return std::unique_ptr<CRC24_Botan>(new CRC24_Botan());
  136|  1.82k|}
_ZN3rnp11CRC24_Botan3addEPKvm:
  140|  2.51k|{
  141|  2.51k|    if (!fn_) {
  ------------------
  |  Branch (141:9): [True: 0, False: 2.51k]
  ------------------
  142|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
  143|      0|    }
  144|  2.51k|    fn_->update(static_cast<const uint8_t *>(buf), len);
  145|  2.51k|}
_ZN3rnp11CRC24_Botan6finishEv:
  149|    249|{
  150|    249|    if (!fn_) {
  ------------------
  |  Branch (150:9): [True: 0, False: 249]
  ------------------
  151|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
  152|      0|    }
  153|    249|    std::array<uint8_t, 3> crc{};
  154|    249|    fn_->final(crc.data());
  155|    249|    fn_ = nullptr;
  156|    249|    return crc;
  157|    249|}

_ZN3rnp4HashC2E14pgp_hash_alg_t:
   48|  40.5k|    Hash(pgp_hash_alg_t alg) : alg_(alg)
   49|  40.5k|    {
   50|  40.5k|        size_ = Hash::size(alg);
   51|  40.5k|    };
_ZN3rnp5CRC24C2Ev:
   81|  1.82k|    CRC24(){};
_ZN3rnp5CRC24D2Ev:
   89|  1.82k|    virtual ~CRC24(){};

_ZN3rnp4Hash6createE14pgp_hash_alg_t:
   72|  40.5k|{
   73|  40.5k|    if (alg == PGP_HASH_SHA1) {
  ------------------
  |  Branch (73:9): [True: 29.8k, False: 10.7k]
  ------------------
   74|  29.8k|        return Hash_SHA1CD::create();
   75|  29.8k|    }
   76|       |#if !defined(ENABLE_SM2)
   77|       |    if (alg == PGP_HASH_SM3) {
   78|       |        RNP_LOG("SM3 hash is not available.");
   79|       |        throw rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   80|       |    }
   81|       |#endif
   82|       |#if defined(CRYPTO_BACKEND_OPENSSL)
   83|       |    return Hash_OpenSSL::create(alg);
   84|       |#elif defined(CRYPTO_BACKEND_BOTAN)
   85|  10.7k|    return Hash_Botan::create(alg);
   86|       |#else
   87|       |#error "Crypto backend not specified"
   88|       |#endif
   89|  40.5k|}
_ZN3rnp5CRC246createEv:
   93|  1.82k|{
   94|       |#if defined(CRYPTO_BACKEND_OPENSSL)
   95|       |    return CRC24_RNP::create();
   96|       |#elif defined(CRYPTO_BACKEND_BOTAN)
   97|       |    return CRC24_Botan::create();
   98|       |#else
   99|       |#error "Crypto backend not specified"
  100|       |#endif
  101|  1.82k|}
_ZN3rnp4Hash3addERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  105|  37.4k|{
  106|  37.4k|    add(val.data(), val.size());
  107|  37.4k|}
_ZN3rnp4Hash3addEj:
  111|  6.25k|{
  112|  6.25k|    uint8_t ibuf[4];
  113|  6.25k|    write_uint32(ibuf, val);
  114|  6.25k|    add(ibuf, sizeof(ibuf));
  115|  6.25k|}
_ZN3rnp4Hash3addERKN3pgp3mpiE:
  119|  6.25k|{
  120|  6.25k|    size_t len = val.size();
  121|  6.25k|    size_t idx = 0;
  122|  7.02k|    while ((idx < len) && (!val[idx])) {
  ------------------
  |  Branch (122:12): [True: 6.81k, False: 215]
  |  Branch (122:27): [True: 768, False: 6.04k]
  ------------------
  123|    768|        idx++;
  124|    768|    }
  125|       |
  126|  6.25k|    if (idx >= len) {
  ------------------
  |  Branch (126:9): [True: 215, False: 6.04k]
  ------------------
  127|    215|        add(0);
  128|    215|        return;
  129|    215|    }
  130|       |
  131|  6.04k|    add(len - idx);
  132|  6.04k|    if (val[idx] & 0x80) {
  ------------------
  |  Branch (132:9): [True: 2.72k, False: 3.32k]
  ------------------
  133|  2.72k|        uint8_t padbyte = 0;
  134|  2.72k|        add(&padbyte, 1);
  135|  2.72k|    }
  136|  6.04k|    add(val.data() + idx, len - idx);
  137|  6.04k|}
_ZN3rnp4Hash6finishEv:
  141|  40.5k|{
  142|  40.5k|    std::vector<uint8_t> res(size_, 0);
  143|  40.5k|    finish(res.data());
  144|  40.5k|    return res;
  145|  40.5k|}
_ZN3rnp4HashD2Ev:
  156|  40.5k|{
  157|  40.5k|}
_ZN3rnp4Hash4sizeE14pgp_hash_alg_t:
  183|  43.2k|{
  184|  43.2k|    size_t val = 0;
  185|  43.2k|    ARRAY_LOOKUP_BY_ID(hash_alg_map, type, len, alg, val);
  ------------------
  |  |   45|  43.2k|    do {                                                                  \
  |  |   46|   112k|        for (size_t i__ = 0; i__ < ARRAY_SIZE(array); i__++) {            \
  |  |  ------------------
  |  |  |  |   34|   112k|#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
  |  |  ------------------
  |  |  |  Branch (46:30): [True: 112k, False: 534]
  |  |  ------------------
  |  |   47|   112k|            if ((array)[i__].id_field == (lookup_value)) {                \
  |  |  ------------------
  |  |  |  Branch (47:17): [True: 42.7k, False: 69.6k]
  |  |  ------------------
  |  |   48|  42.7k|                (ret) = (array)[i__].ret_field;                           \
  |  |   49|  42.7k|                break;                                                    \
  |  |   50|  42.7k|            }                                                             \
  |  |   51|   112k|        }                                                                 \
  |  |   52|  43.2k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (52:14): [Folded, False: 43.2k]
  |  |  ------------------
  ------------------
  186|  43.2k|    return val;
  187|  43.2k|}

_ZN3rnp11Hash_SHA1CDC2Ev:
   35|  29.8k|Hash_SHA1CD::Hash_SHA1CD() : Hash(PGP_HASH_SHA1)
   36|  29.8k|{
   37|       |    assert(size_ == 20);
   38|  29.8k|    SHA1DCInit(&ctx_);
   39|  29.8k|}
_ZN3rnp11Hash_SHA1CDD2Ev:
   47|  29.8k|{
   48|  29.8k|}
_ZN3rnp11Hash_SHA1CD6createEv:
   52|  29.8k|{
   53|  29.8k|    return std::unique_ptr<Hash_SHA1CD>(new Hash_SHA1CD());
   54|  29.8k|}
_ZN3rnp11Hash_SHA1CD3addEPKvm:
   69|  59.6k|{
   70|  59.6k|    SHA1DCUpdate(&ctx_, (const char *) buf, len);
   71|  59.6k|}
_ZN3rnp11Hash_SHA1CD6finishEPh:
   78|  29.8k|{
   79|  29.8k|    unsigned char fixed_digest[20];
   80|  29.8k|    int           res = SHA1DCFinal(fixed_digest, &ctx_);
   81|  29.8k|    if (res && digest) {
  ------------------
  |  Branch (81:9): [True: 0, False: 29.8k]
  |  Branch (81:16): [True: 0, False: 0]
  ------------------
   82|       |        /* Show warning only if digest is non-null */
   83|      0|        RNP_LOG("Warning! SHA1 collision detected and mitigated.");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   84|      0|    }
   85|  29.8k|    if (res) {
  ------------------
  |  Branch (85:9): [True: 0, False: 29.8k]
  ------------------
   86|      0|        return;
   87|      0|    }
   88|  29.8k|    if (digest) {
  ------------------
  |  Branch (88:9): [True: 29.8k, False: 0]
  ------------------
   89|  29.8k|        memcpy(digest, fixed_digest, 20);
   90|  29.8k|    }
   91|  29.8k|}

_ZNK22pgp_kyber_public_key_t11get_encodedEv:
   97|  1.66k|    {
   98|  1.66k|        return key_encoded_;
   99|  1.66k|    };
_ZN22pgp_kyber_public_key_tC2Ev:
   84|  8.77k|    pgp_kyber_public_key_t() = default;

_Z17kyber_pubkey_size17kyber_parameter_e:
   47|  8.39k|{
   48|  8.39k|    switch (parameter) {
   49|  3.81k|    case kyber_768:
  ------------------
  |  Branch (49:5): [True: 3.81k, False: 4.57k]
  ------------------
   50|  3.81k|        return 1184;
   51|  4.57k|    case kyber_1024:
  ------------------
  |  Branch (51:5): [True: 4.57k, False: 3.81k]
  ------------------
   52|  4.57k|        return 1568;
   53|      0|    default:
  ------------------
  |  Branch (53:5): [True: 0, False: 8.39k]
  ------------------
   54|      0|        RNP_LOG("invalid parameter given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   55|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   56|  8.39k|    }
   57|  8.39k|}
_Z21kyber_ciphertext_size17kyber_parameter_e:
   75|  2.39k|{
   76|  2.39k|    switch (parameter) {
   77|  1.36k|    case kyber_768:
  ------------------
  |  Branch (77:5): [True: 1.36k, False: 1.02k]
  ------------------
   78|  1.36k|        return 1088;
   79|  1.02k|    case kyber_1024:
  ------------------
  |  Branch (79:5): [True: 1.02k, False: 1.36k]
  ------------------
   80|  1.02k|        return 1568;
   81|      0|    default:
  ------------------
  |  Branch (81:5): [True: 0, False: 2.39k]
  ------------------
   82|      0|        RNP_LOG("invalid parameter given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   83|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   84|  2.39k|    }
   85|  2.39k|}
_ZN22pgp_kyber_public_key_tC2EPKhm17kyber_parameter_e:
   90|  3.72k|    : key_encoded_(key_encoded, key_encoded + key_encoded_len), kyber_mode_(mode),
   91|  3.72k|      is_initialized_(true)
   92|  3.72k|{
   93|  3.72k|}

_ZN30pgp_kyber_ecdh_composite_key_tD2Ev:
   37|  13.8k|{
   38|  13.8k|}
_ZNK30pgp_kyber_ecdh_composite_key_t20initialized_or_throwEv:
   42|  1.66k|{
   43|  1.66k|    if (!is_initialized()) {
  ------------------
  |  Branch (43:9): [True: 0, False: 1.66k]
  ------------------
   44|      0|        RNP_LOG("Trying to use uninitialized kyber-ecdh key");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   45|      0|        throw rnp::rnp_exception(RNP_ERROR_GENERIC); /* TODO better return error */
   46|      0|    }
   47|  1.66k|}
_ZN30pgp_kyber_ecdh_composite_key_t22ecdh_curve_pubkey_sizeE11pgp_curve_t:
  101|  12.1k|{
  102|  12.1k|    switch (curve) {
  103|  1.37k|    case PGP_CURVE_25519:
  ------------------
  |  Branch (103:5): [True: 1.37k, False: 10.7k]
  ------------------
  104|  1.37k|        return 32;
  105|       |    /* TODO */
  106|       |    //  case PGP_CURVE_X448:
  107|       |    //    return 56;
  108|  2.07k|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (108:5): [True: 2.07k, False: 10.0k]
  ------------------
  109|  2.07k|        return 65;
  110|  4.34k|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (110:5): [True: 4.34k, False: 7.76k]
  ------------------
  111|  4.34k|        return 97;
  112|  1.99k|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (112:5): [True: 1.99k, False: 10.1k]
  ------------------
  113|  1.99k|        return 65;
  114|  2.31k|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (114:5): [True: 2.31k, False: 9.79k]
  ------------------
  115|  2.31k|        return 97;
  116|      0|    default:
  ------------------
  |  Branch (116:5): [True: 0, False: 12.1k]
  ------------------
  117|      0|        RNP_LOG("invalid curve given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  119|  12.1k|    }
  120|  12.1k|}
_ZN30pgp_kyber_ecdh_composite_key_t25ecdh_curve_ephemeral_sizeE11pgp_curve_t:
  124|  2.39k|{
  125|  2.39k|    switch (curve) {
  126|    284|    case PGP_CURVE_25519:
  ------------------
  |  Branch (126:5): [True: 284, False: 2.11k]
  ------------------
  127|    284|        return 32;
  128|       |    /* TODO */
  129|       |    //  case PGP_CURVE_X448:
  130|       |    //    return 56;
  131|    693|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (131:5): [True: 693, False: 1.70k]
  ------------------
  132|    693|        return 65;
  133|    736|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (133:5): [True: 736, False: 1.66k]
  ------------------
  134|    736|        return 97;
  135|    391|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (135:5): [True: 391, False: 2.00k]
  ------------------
  136|    391|        return 65;
  137|    293|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (137:5): [True: 293, False: 2.10k]
  ------------------
  138|    293|        return 97;
  139|      0|    default:
  ------------------
  |  Branch (139:5): [True: 0, False: 2.39k]
  ------------------
  140|      0|        RNP_LOG("invalid curve given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  141|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  142|  2.39k|    }
  143|  2.39k|}
_ZN30pgp_kyber_ecdh_composite_key_t18pk_alg_to_kyber_idE16pgp_pubkey_alg_t:
  170|  14.5k|{
  171|  14.5k|    switch (pk_alg) {
  172|  1.66k|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (172:5): [True: 1.66k, False: 12.8k]
  ------------------
  173|  1.66k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.66k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  174|  4.43k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (174:5): [True: 2.77k, False: 11.7k]
  ------------------
  175|  4.43k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.43k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  176|  6.82k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (176:5): [True: 2.38k, False: 12.1k]
  ------------------
  177|  6.82k|        return kyber_768;
  178|  2.60k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (178:5): [True: 2.60k, False: 11.9k]
  ------------------
  179|  2.60k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.60k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  180|  7.68k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (180:5): [True: 5.08k, False: 9.42k]
  ------------------
  181|  7.68k|        return kyber_1024;
  182|      0|    default:
  ------------------
  |  Branch (182:5): [True: 0, False: 14.5k]
  ------------------
  183|      0|        RNP_LOG("invalid PK alg given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  184|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  185|  14.5k|    }
  186|  14.5k|}
_ZN30pgp_kyber_ecdh_composite_key_t18pk_alg_to_curve_idE16pgp_pubkey_alg_t:
  190|  18.2k|{
  191|  18.2k|    switch (pk_alg) {
  192|  2.09k|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (192:5): [True: 2.09k, False: 16.1k]
  ------------------
  193|  2.09k|        return PGP_CURVE_25519;
  194|  3.39k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (194:5): [True: 3.39k, False: 14.8k]
  ------------------
  195|  3.39k|        return PGP_CURVE_NIST_P_256;
  196|  2.96k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (196:5): [True: 2.96k, False: 15.2k]
  ------------------
  197|  2.96k|        return PGP_CURVE_BP256;
  198|  3.31k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (198:5): [True: 3.31k, False: 14.9k]
  ------------------
  199|  3.31k|        return PGP_CURVE_BP384;
  200|  6.46k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (200:5): [True: 6.46k, False: 11.7k]
  ------------------
  201|  6.46k|        return PGP_CURVE_NIST_P_384;
  202|       |    /*case PGP_PKA_KYBER1024_X448:
  203|       |      return ... NOT_IMPLEMENTED*/
  204|      0|    default:
  ------------------
  |  Branch (204:5): [True: 0, False: 18.2k]
  ------------------
  205|      0|        RNP_LOG("invalid PK alg given");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  206|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  207|  18.2k|    }
  208|  18.2k|}
_ZN37pgp_kyber_ecdh_composite_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE16pgp_pubkey_alg_t:
  447|  3.72k|    : pk_alg_(pk_alg)
  448|  3.72k|{
  449|  3.72k|    parse_component_keys(key_encoded);
  450|  3.72k|}
_ZN37pgp_kyber_ecdh_composite_public_key_t12encoded_sizeE16pgp_pubkey_alg_t:
  469|  8.39k|{
  470|  8.39k|    kyber_parameter_e kyber_param = pk_alg_to_kyber_id(pk_alg);
  471|  8.39k|    pgp_curve_t       curve = pk_alg_to_curve_id(pk_alg);
  472|  8.39k|    return ecdh_curve_pubkey_size(curve) + kyber_pubkey_size(kyber_param);
  473|  8.39k|}
_ZN37pgp_kyber_ecdh_composite_public_key_t20parse_component_keysENSt3__16vectorIhNS0_9allocatorIhEEEE:
  477|  3.72k|{
  478|  3.72k|    if (key_encoded.size() != encoded_size(pk_alg_)) {
  ------------------
  |  Branch (478:9): [True: 0, False: 3.72k]
  ------------------
  479|      0|        RNP_LOG("ML-KEM composite key format invalid: length mismatch");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  480|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
  481|      0|    }
  482|       |
  483|  3.72k|    kyber_parameter_e kyber_param = pk_alg_to_kyber_id(pk_alg_);
  484|  3.72k|    pgp_curve_t       ecdh_curve = pk_alg_to_curve_id(pk_alg_);
  485|  3.72k|    size_t            split_at = ecdh_curve_pubkey_size(pk_alg_to_curve_id(pk_alg_));
  486|       |
  487|  3.72k|    kyber_key_ = pgp_kyber_public_key_t(
  488|  3.72k|      key_encoded.data() + split_at, key_encoded.size() - split_at, kyber_param);
  489|  3.72k|    ecdh_key_ = ecdh_kem_public_key_t(key_encoded.data(), split_at, ecdh_curve);
  490|       |
  491|  3.72k|    is_initialized_ = true;
  492|  3.72k|}
_ZNK37pgp_kyber_ecdh_composite_public_key_t11get_encodedEv:
  555|  1.66k|{
  556|  1.66k|    initialized_or_throw();
  557|  1.66k|    std::vector<uint8_t> result;
  558|  1.66k|    std::vector<uint8_t> ecdh_key_encoded = ecdh_key_.get_encoded();
  559|  1.66k|    std::vector<uint8_t> kyber_key_encoded = kyber_key_.get_encoded();
  560|       |
  561|  1.66k|    result.insert(result.end(), std::begin(ecdh_key_encoded), std::end(ecdh_key_encoded));
  562|  1.66k|    result.insert(result.end(), std::begin(kyber_key_encoded), std::end(kyber_key_encoded));
  563|  1.66k|    return result;
  564|  1.66k|};

_ZNK30pgp_kyber_ecdh_composite_key_t14is_initializedEv:
   60|  1.66k|    {
   61|  1.66k|        return is_initialized_;
   62|  1.66k|    }
_ZN38pgp_kyber_ecdh_composite_private_key_tC2Ev:
   97|  5.05k|    pgp_kyber_ecdh_composite_private_key_t() = default;
_ZN37pgp_kyber_ecdh_composite_public_key_tC2Ev:
  139|  5.05k|    pgp_kyber_ecdh_composite_public_key_t() = default;

_Z12secure_clearPvm:
   35|   225k|{
   36|   225k|    botan_scrub_mem(vp, size);
   37|   225k|}
_ZN3rnp10hex_encodeEPKhmPcmNS_9HexFormatE:
   43|   410k|{
   44|   410k|    uint32_t flags = format == HexFormat::Lowercase ? BOTAN_FFI_HEX_LOWER_CASE : 0;
  ------------------
  |  Branch (44:22): [True: 410k, False: 0]
  ------------------
   45|       |
   46|   410k|    if (hex_len < (buf_len * 2 + 1)) {
  ------------------
  |  Branch (46:9): [True: 0, False: 410k]
  ------------------
   47|      0|        return false;
   48|      0|    }
   49|   410k|    hex[buf_len * 2] = '\0';
   50|   410k|    return botan_hex_encode(buf, buf_len, hex, flags) == 0;
   51|   410k|}

_ZN3rnp10bin_to_hexEPKhmNS_9HexFormatE:
  173|   410k|{
  174|   410k|    std::string res(len * 2 + 1, '\0');
  175|   410k|    (void) hex_encode(data, len, &res.front(), res.size(), format);
  176|   410k|    res.resize(len * 2);
  177|   410k|    return res;
  178|   410k|}

_ZNK3pgp3mpi4bitsEv:
   37|   210k|{
   38|   210k|    size_t  bits = 0;
   39|   210k|    size_t  idx = 0;
   40|   210k|    uint8_t bt;
   41|       |
   42|   231k|    for (idx = 0; (idx < size()) && !data_[idx]; idx++)
  ------------------
  |  Branch (42:19): [True: 227k, False: 3.86k]
  |  Branch (42:37): [True: 20.9k, False: 206k]
  ------------------
   43|  20.9k|        ;
   44|       |
   45|   210k|    if (idx < size()) {
  ------------------
  |  Branch (45:9): [True: 206k, False: 3.86k]
  ------------------
   46|  1.36M|        for (bits = (size() - idx - 1) << 3, bt = data_[idx]; bt; bits++, bt = bt >> 1)
  ------------------
  |  Branch (46:63): [True: 1.15M, False: 206k]
  ------------------
   47|  1.15M|            ;
   48|   206k|    }
   49|       |
   50|   210k|    return bits;
   51|   210k|}
_ZNK3pgp3mpi4sizeEv:
   55|   660k|{
   56|   660k|    return data_.size();
   57|   660k|}
_ZN3pgp3mpi4dataEv:
   61|   130k|{
   62|   130k|    return data_.data();
   63|   130k|}
_ZNK3pgp3mpi4dataEv:
   67|  9.17k|{
   68|  9.17k|    return data_.data();
   69|  9.17k|}
_ZNK3pgp3mpiixEm:
  101|  12.8k|{
  102|  12.8k|    return data_.at(idx);
  103|  12.8k|}
_ZN3pgp3mpi6resizeEmh:
  119|   130k|{
  120|   130k|    data_.resize(size, fill);
  121|   130k|}
_ZN3pgp3mpi6forgetEv:
  125|   111k|{
  126|   111k|    secure_clear(data_.data(), data_.size());
  127|   111k|    data_.resize(0);
  128|   111k|}

_ZN3pgp3rsa3Key12clear_secretEv:
   61|  24.1k|    {
   62|  24.1k|        d.forget();
   63|  24.1k|        p.forget();
   64|  24.1k|        q.forget();
   65|  24.1k|        u.forget();
   66|  24.1k|    }
_ZN3pgp3rsa3KeyD2Ev:
   69|  24.1k|    {
   70|  24.1k|        clear_secret();
   71|  24.1k|    }

_Z25pgp_s2k_decode_iterationsh:
  111|    572|{
  112|       |    // See RFC 4880 section 3.7.1.3
  113|    572|    return (16 + (c & 0x0F)) << ((c >> 4) + 6);
  114|    572|}

sha1_compression_states:
  465|   206k|{
  466|   206k|    uint32_t a = ihv[0], b = ihv[1], c = ihv[2], d = ihv[3], e = ihv[4];
  467|   206k|    uint32_t temp;
  468|       |
  469|       |#ifdef DOSTORESTATE00
  470|       |    SHA1_STORE_STATE(0)
  471|       |#endif
  472|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 0, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  473|       |
  474|       |#ifdef DOSTORESTATE01
  475|       |    SHA1_STORE_STATE(1)
  476|       |#endif
  477|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 1, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  478|       |
  479|       |#ifdef DOSTORESTATE02
  480|       |    SHA1_STORE_STATE(2)
  481|       |#endif
  482|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 2, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  483|       |
  484|       |#ifdef DOSTORESTATE03
  485|       |    SHA1_STORE_STATE(3)
  486|       |#endif
  487|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 3, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  488|       |
  489|       |#ifdef DOSTORESTATE04
  490|       |    SHA1_STORE_STATE(4)
  491|       |#endif
  492|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 4, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  493|       |
  494|       |#ifdef DOSTORESTATE05
  495|       |    SHA1_STORE_STATE(5)
  496|       |#endif
  497|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 5, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  498|       |
  499|       |#ifdef DOSTORESTATE06
  500|       |    SHA1_STORE_STATE(6)
  501|       |#endif
  502|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 6, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  503|       |
  504|       |#ifdef DOSTORESTATE07
  505|       |    SHA1_STORE_STATE(7)
  506|       |#endif
  507|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 7, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  508|       |
  509|       |#ifdef DOSTORESTATE08
  510|       |    SHA1_STORE_STATE(8)
  511|       |#endif
  512|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 8, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  513|       |
  514|       |#ifdef DOSTORESTATE09
  515|       |    SHA1_STORE_STATE(9)
  516|       |#endif
  517|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 9, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  518|       |
  519|       |#ifdef DOSTORESTATE10
  520|       |    SHA1_STORE_STATE(10)
  521|       |#endif
  522|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 10, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  523|       |
  524|       |#ifdef DOSTORESTATE11
  525|       |    SHA1_STORE_STATE(11)
  526|       |#endif
  527|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 11, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  528|       |
  529|       |#ifdef DOSTORESTATE12
  530|       |    SHA1_STORE_STATE(12)
  531|       |#endif
  532|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 12, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  533|       |
  534|       |#ifdef DOSTORESTATE13
  535|       |    SHA1_STORE_STATE(13)
  536|       |#endif
  537|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 13, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  538|       |
  539|       |#ifdef DOSTORESTATE14
  540|       |    SHA1_STORE_STATE(14)
  541|       |#endif
  542|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 14, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  543|       |
  544|       |#ifdef DOSTORESTATE15
  545|       |    SHA1_STORE_STATE(15)
  546|       |#endif
  547|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 15, temp);
  ------------------
  |  |  208|   206k|    {                                                                    \
  |  |  209|   206k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   206k|    {                         \
  |  |  |  |  153|   206k|        temp = m[t];          \
  |  |  |  |  154|   206k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   206k|    {                                                        \
  |  |  |  |  |  |  139|   206k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   206k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   206k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   206k|    }
  |  |  ------------------
  |  |  210|   206k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   206k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   206k|    }
  ------------------
  548|       |
  549|       |#ifdef DOSTORESTATE16
  550|       |    SHA1_STORE_STATE(16)
  551|       |#endif
  552|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(e, a, b, c, d, W, 16, temp);
  ------------------
  |  |  216|   206k|    {                                                                   \
  |  |  217|   206k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   206k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   206k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   206k|    }
  ------------------
  553|       |
  554|       |#ifdef DOSTORESTATE17
  555|       |    SHA1_STORE_STATE(17)
  556|       |#endif
  557|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(d, e, a, b, c, W, 17, temp);
  ------------------
  |  |  216|   206k|    {                                                                   \
  |  |  217|   206k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   206k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   206k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   206k|    }
  ------------------
  558|       |
  559|       |#ifdef DOSTORESTATE18
  560|       |    SHA1_STORE_STATE(18)
  561|       |#endif
  562|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(c, d, e, a, b, W, 18, temp);
  ------------------
  |  |  216|   206k|    {                                                                   \
  |  |  217|   206k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   206k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   206k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   206k|    }
  ------------------
  563|       |
  564|       |#ifdef DOSTORESTATE19
  565|       |    SHA1_STORE_STATE(19)
  566|       |#endif
  567|   206k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(b, c, d, e, a, W, 19, temp);
  ------------------
  |  |  216|   206k|    {                                                                   \
  |  |  217|   206k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   206k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   206k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   206k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   206k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   206k|    }
  ------------------
  568|       |
  569|       |#ifdef DOSTORESTATE20
  570|       |    SHA1_STORE_STATE(20)
  571|       |#endif
  572|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 20, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  573|       |
  574|       |#ifdef DOSTORESTATE21
  575|       |    SHA1_STORE_STATE(21)
  576|       |#endif
  577|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 21, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  578|       |
  579|       |#ifdef DOSTORESTATE22
  580|       |    SHA1_STORE_STATE(22)
  581|       |#endif
  582|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 22, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  583|       |
  584|       |#ifdef DOSTORESTATE23
  585|       |    SHA1_STORE_STATE(23)
  586|       |#endif
  587|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 23, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  588|       |
  589|       |#ifdef DOSTORESTATE24
  590|       |    SHA1_STORE_STATE(24)
  591|       |#endif
  592|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 24, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  593|       |
  594|       |#ifdef DOSTORESTATE25
  595|       |    SHA1_STORE_STATE(25)
  596|       |#endif
  597|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 25, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  598|       |
  599|       |#ifdef DOSTORESTATE26
  600|       |    SHA1_STORE_STATE(26)
  601|       |#endif
  602|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 26, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  603|       |
  604|       |#ifdef DOSTORESTATE27
  605|       |    SHA1_STORE_STATE(27)
  606|       |#endif
  607|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 27, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  608|       |
  609|       |#ifdef DOSTORESTATE28
  610|       |    SHA1_STORE_STATE(28)
  611|       |#endif
  612|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 28, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  613|       |
  614|       |#ifdef DOSTORESTATE29
  615|       |    SHA1_STORE_STATE(29)
  616|       |#endif
  617|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 29, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  618|       |
  619|       |#ifdef DOSTORESTATE30
  620|       |    SHA1_STORE_STATE(30)
  621|       |#endif
  622|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 30, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  623|       |
  624|       |#ifdef DOSTORESTATE31
  625|       |    SHA1_STORE_STATE(31)
  626|       |#endif
  627|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 31, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  628|       |
  629|       |#ifdef DOSTORESTATE32
  630|       |    SHA1_STORE_STATE(32)
  631|       |#endif
  632|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 32, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  633|       |
  634|       |#ifdef DOSTORESTATE33
  635|       |    SHA1_STORE_STATE(33)
  636|       |#endif
  637|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 33, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  638|       |
  639|       |#ifdef DOSTORESTATE34
  640|       |    SHA1_STORE_STATE(34)
  641|       |#endif
  642|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 34, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  643|       |
  644|       |#ifdef DOSTORESTATE35
  645|       |    SHA1_STORE_STATE(35)
  646|       |#endif
  647|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 35, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  648|       |
  649|       |#ifdef DOSTORESTATE36
  650|       |    SHA1_STORE_STATE(36)
  651|       |#endif
  652|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 36, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  653|       |
  654|       |#ifdef DOSTORESTATE37
  655|       |    SHA1_STORE_STATE(37)
  656|       |#endif
  657|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 37, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  658|       |
  659|       |#ifdef DOSTORESTATE38
  660|       |    SHA1_STORE_STATE(38)
  661|       |#endif
  662|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 38, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  663|       |
  664|       |#ifdef DOSTORESTATE39
  665|       |    SHA1_STORE_STATE(39)
  666|       |#endif
  667|   206k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 39, temp);
  ------------------
  |  |  224|   206k|    {                                                                  \
  |  |  225|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   206k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   206k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   206k|    }
  ------------------
  668|       |
  669|       |#ifdef DOSTORESTATE40
  670|       |    SHA1_STORE_STATE(40)
  671|       |#endif
  672|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 40, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  673|       |
  674|       |#ifdef DOSTORESTATE41
  675|       |    SHA1_STORE_STATE(41)
  676|       |#endif
  677|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 41, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  678|       |
  679|       |#ifdef DOSTORESTATE42
  680|       |    SHA1_STORE_STATE(42)
  681|       |#endif
  682|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 42, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  683|       |
  684|       |#ifdef DOSTORESTATE43
  685|       |    SHA1_STORE_STATE(43)
  686|       |#endif
  687|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 43, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  688|       |
  689|       |#ifdef DOSTORESTATE44
  690|       |    SHA1_STORE_STATE(44)
  691|       |#endif
  692|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 44, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  693|       |
  694|       |#ifdef DOSTORESTATE45
  695|       |    SHA1_STORE_STATE(45)
  696|       |#endif
  697|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 45, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  698|       |
  699|       |#ifdef DOSTORESTATE46
  700|       |    SHA1_STORE_STATE(46)
  701|       |#endif
  702|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 46, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  703|       |
  704|       |#ifdef DOSTORESTATE47
  705|       |    SHA1_STORE_STATE(47)
  706|       |#endif
  707|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 47, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  708|       |
  709|       |#ifdef DOSTORESTATE48
  710|       |    SHA1_STORE_STATE(48)
  711|       |#endif
  712|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 48, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  713|       |
  714|       |#ifdef DOSTORESTATE49
  715|       |    SHA1_STORE_STATE(49)
  716|       |#endif
  717|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 49, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  718|       |
  719|       |#ifdef DOSTORESTATE50
  720|       |    SHA1_STORE_STATE(50)
  721|       |#endif
  722|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 50, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  723|       |
  724|       |#ifdef DOSTORESTATE51
  725|       |    SHA1_STORE_STATE(51)
  726|       |#endif
  727|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 51, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  728|       |
  729|       |#ifdef DOSTORESTATE52
  730|       |    SHA1_STORE_STATE(52)
  731|       |#endif
  732|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 52, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  733|       |
  734|       |#ifdef DOSTORESTATE53
  735|       |    SHA1_STORE_STATE(53)
  736|       |#endif
  737|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 53, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  738|       |
  739|       |#ifdef DOSTORESTATE54
  740|       |    SHA1_STORE_STATE(54)
  741|       |#endif
  742|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 54, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  743|       |
  744|       |#ifdef DOSTORESTATE55
  745|       |    SHA1_STORE_STATE(55)
  746|       |#endif
  747|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 55, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  748|       |
  749|       |#ifdef DOSTORESTATE56
  750|       |    SHA1_STORE_STATE(56)
  751|       |#endif
  752|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 56, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  753|       |
  754|       |#ifdef DOSTORESTATE57
  755|       |    SHA1_STORE_STATE(57)
  756|       |#endif
  757|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 57, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  758|       |
  759|   206k|#ifdef DOSTORESTATE58
  760|   206k|    SHA1_STORE_STATE(58)
  ------------------
  |  |  248|   206k|    states[i][0] = a;       \
  |  |  249|   206k|    states[i][1] = b;       \
  |  |  250|   206k|    states[i][2] = c;       \
  |  |  251|   206k|    states[i][3] = d;       \
  |  |  252|   206k|    states[i][4] = e;
  ------------------
  761|   206k|#endif
  762|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 58, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  763|       |
  764|       |#ifdef DOSTORESTATE59
  765|       |    SHA1_STORE_STATE(59)
  766|       |#endif
  767|   206k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 59, temp);
  ------------------
  |  |  232|   206k|    {                                                                  \
  |  |  233|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   206k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   206k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   206k|    }
  ------------------
  768|       |
  769|       |#ifdef DOSTORESTATE60
  770|       |    SHA1_STORE_STATE(60)
  771|       |#endif
  772|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 60, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  773|       |
  774|       |#ifdef DOSTORESTATE61
  775|       |    SHA1_STORE_STATE(61)
  776|       |#endif
  777|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 61, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  778|       |
  779|       |#ifdef DOSTORESTATE62
  780|       |    SHA1_STORE_STATE(62)
  781|       |#endif
  782|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 62, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  783|       |
  784|       |#ifdef DOSTORESTATE63
  785|       |    SHA1_STORE_STATE(63)
  786|       |#endif
  787|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 63, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  788|       |
  789|       |#ifdef DOSTORESTATE64
  790|       |    SHA1_STORE_STATE(64)
  791|       |#endif
  792|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 64, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  793|       |
  794|   206k|#ifdef DOSTORESTATE65
  795|   206k|    SHA1_STORE_STATE(65)
  ------------------
  |  |  248|   206k|    states[i][0] = a;       \
  |  |  249|   206k|    states[i][1] = b;       \
  |  |  250|   206k|    states[i][2] = c;       \
  |  |  251|   206k|    states[i][3] = d;       \
  |  |  252|   206k|    states[i][4] = e;
  ------------------
  796|   206k|#endif
  797|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 65, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  798|       |
  799|       |#ifdef DOSTORESTATE66
  800|       |    SHA1_STORE_STATE(66)
  801|       |#endif
  802|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 66, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  803|       |
  804|       |#ifdef DOSTORESTATE67
  805|       |    SHA1_STORE_STATE(67)
  806|       |#endif
  807|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 67, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  808|       |
  809|       |#ifdef DOSTORESTATE68
  810|       |    SHA1_STORE_STATE(68)
  811|       |#endif
  812|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 68, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  813|       |
  814|       |#ifdef DOSTORESTATE69
  815|       |    SHA1_STORE_STATE(69)
  816|       |#endif
  817|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 69, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  818|       |
  819|       |#ifdef DOSTORESTATE70
  820|       |    SHA1_STORE_STATE(70)
  821|       |#endif
  822|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 70, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  823|       |
  824|       |#ifdef DOSTORESTATE71
  825|       |    SHA1_STORE_STATE(71)
  826|       |#endif
  827|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 71, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  828|       |
  829|       |#ifdef DOSTORESTATE72
  830|       |    SHA1_STORE_STATE(72)
  831|       |#endif
  832|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 72, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  833|       |
  834|       |#ifdef DOSTORESTATE73
  835|       |    SHA1_STORE_STATE(73)
  836|       |#endif
  837|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 73, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  838|       |
  839|       |#ifdef DOSTORESTATE74
  840|       |    SHA1_STORE_STATE(74)
  841|       |#endif
  842|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 74, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  843|       |
  844|       |#ifdef DOSTORESTATE75
  845|       |    SHA1_STORE_STATE(75)
  846|       |#endif
  847|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 75, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  848|       |
  849|       |#ifdef DOSTORESTATE76
  850|       |    SHA1_STORE_STATE(76)
  851|       |#endif
  852|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 76, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  853|       |
  854|       |#ifdef DOSTORESTATE77
  855|       |    SHA1_STORE_STATE(77)
  856|       |#endif
  857|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 77, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  858|       |
  859|       |#ifdef DOSTORESTATE78
  860|       |    SHA1_STORE_STATE(78)
  861|       |#endif
  862|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 78, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  863|       |
  864|       |#ifdef DOSTORESTATE79
  865|       |    SHA1_STORE_STATE(79)
  866|       |#endif
  867|   206k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 79, temp);
  ------------------
  |  |  240|   206k|    {                                                                  \
  |  |  241|   206k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   206k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   206k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   206k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   206k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   206k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   206k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   206k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   206k|    }
  ------------------
  868|       |
  869|   206k|    ihv[0] += a;
  870|   206k|    ihv[1] += b;
  871|   206k|    ihv[2] += c;
  872|   206k|    ihv[3] += d;
  873|   206k|    ihv[4] += e;
  874|   206k|}
SHA1DCInit:
 2019|  29.8k|{
 2020|  29.8k|    ctx->total = 0;
 2021|  29.8k|    ctx->ihv[0] = 0x67452301;
 2022|  29.8k|    ctx->ihv[1] = 0xEFCDAB89;
 2023|  29.8k|    ctx->ihv[2] = 0x98BADCFE;
 2024|  29.8k|    ctx->ihv[3] = 0x10325476;
 2025|  29.8k|    ctx->ihv[4] = 0xC3D2E1F0;
 2026|  29.8k|    ctx->found_collision = 0;
 2027|  29.8k|    ctx->safe_hash = SHA1DC_INIT_SAFE_HASH_DEFAULT;
  ------------------
  |  |   23|  29.8k|#define SHA1DC_INIT_SAFE_HASH_DEFAULT 1
  ------------------
 2028|  29.8k|    ctx->ubc_check = 1;
 2029|  29.8k|    ctx->detect_coll = 1;
 2030|  29.8k|    ctx->reduced_round_coll = 0;
 2031|       |    ctx->callback = NULL;
 2032|  29.8k|}
SHA1DCUpdate:
 2078|  89.4k|{
 2079|  89.4k|    unsigned left, fill;
 2080|       |
 2081|  89.4k|    if (len == 0)
  ------------------
  |  Branch (2081:9): [True: 0, False: 89.4k]
  ------------------
 2082|      0|        return;
 2083|       |
 2084|  89.4k|    left = ctx->total & 63;
 2085|  89.4k|    fill = 64 - left;
 2086|       |
 2087|  89.4k|    if (left && len >= fill) {
  ------------------
  |  Branch (2087:9): [True: 59.4k, False: 30.0k]
  |  Branch (2087:17): [True: 7.86k, False: 51.5k]
  ------------------
 2088|  7.86k|        ctx->total += fill;
 2089|  7.86k|        memcpy(ctx->buffer + left, buf, fill);
 2090|  7.86k|        sha1_process(ctx, (uint32_t *) (ctx->buffer));
 2091|  7.86k|        buf += fill;
 2092|  7.86k|        len -= fill;
 2093|  7.86k|        left = 0;
 2094|  7.86k|    }
 2095|   258k|    while (len >= 64) {
  ------------------
  |  Branch (2095:12): [True: 168k, False: 89.4k]
  ------------------
 2096|   168k|        ctx->total += 64;
 2097|       |
 2098|   168k|#if defined(SHA1DC_ALLOW_UNALIGNED_ACCESS)
 2099|   168k|        sha1_process(ctx, (uint32_t *) (buf));
 2100|       |#else
 2101|       |        memcpy(ctx->buffer, buf, 64);
 2102|       |        sha1_process(ctx, (uint32_t *) (ctx->buffer));
 2103|       |#endif /* defined(SHA1DC_ALLOW_UNALIGNED_ACCESS) */
 2104|   168k|        buf += 64;
 2105|   168k|        len -= 64;
 2106|   168k|    }
 2107|  89.4k|    if (len > 0) {
  ------------------
  |  Branch (2107:9): [True: 89.2k, False: 232]
  ------------------
 2108|  89.2k|        ctx->total += len;
 2109|  89.2k|        memcpy(ctx->buffer + left, buf, len);
 2110|  89.2k|    }
 2111|  89.4k|}
SHA1DCFinal:
 2120|  29.8k|{
 2121|  29.8k|    uint32_t last = ctx->total & 63;
 2122|  29.8k|    uint32_t padn = (last < 56) ? (56 - last) : (120 - last);
  ------------------
  |  Branch (2122:21): [True: 29.0k, False: 735]
  ------------------
 2123|  29.8k|    uint64_t total;
 2124|  29.8k|    SHA1DCUpdate(ctx, (const char *) (sha1_padding), padn);
 2125|       |
 2126|  29.8k|    total = ctx->total - padn;
 2127|  29.8k|    total <<= 3;
 2128|  29.8k|    ctx->buffer[56] = (unsigned char) (total >> 56);
 2129|  29.8k|    ctx->buffer[57] = (unsigned char) (total >> 48);
 2130|  29.8k|    ctx->buffer[58] = (unsigned char) (total >> 40);
 2131|  29.8k|    ctx->buffer[59] = (unsigned char) (total >> 32);
 2132|  29.8k|    ctx->buffer[60] = (unsigned char) (total >> 24);
 2133|  29.8k|    ctx->buffer[61] = (unsigned char) (total >> 16);
 2134|  29.8k|    ctx->buffer[62] = (unsigned char) (total >> 8);
 2135|  29.8k|    ctx->buffer[63] = (unsigned char) (total);
 2136|  29.8k|    sha1_process(ctx, (uint32_t *) (ctx->buffer));
 2137|  29.8k|    output[0] = (unsigned char) (ctx->ihv[0] >> 24);
 2138|  29.8k|    output[1] = (unsigned char) (ctx->ihv[0] >> 16);
 2139|  29.8k|    output[2] = (unsigned char) (ctx->ihv[0] >> 8);
 2140|  29.8k|    output[3] = (unsigned char) (ctx->ihv[0]);
 2141|  29.8k|    output[4] = (unsigned char) (ctx->ihv[1] >> 24);
 2142|  29.8k|    output[5] = (unsigned char) (ctx->ihv[1] >> 16);
 2143|  29.8k|    output[6] = (unsigned char) (ctx->ihv[1] >> 8);
 2144|  29.8k|    output[7] = (unsigned char) (ctx->ihv[1]);
 2145|  29.8k|    output[8] = (unsigned char) (ctx->ihv[2] >> 24);
 2146|  29.8k|    output[9] = (unsigned char) (ctx->ihv[2] >> 16);
 2147|  29.8k|    output[10] = (unsigned char) (ctx->ihv[2] >> 8);
 2148|  29.8k|    output[11] = (unsigned char) (ctx->ihv[2]);
 2149|  29.8k|    output[12] = (unsigned char) (ctx->ihv[3] >> 24);
 2150|  29.8k|    output[13] = (unsigned char) (ctx->ihv[3] >> 16);
 2151|  29.8k|    output[14] = (unsigned char) (ctx->ihv[3] >> 8);
 2152|  29.8k|    output[15] = (unsigned char) (ctx->ihv[3]);
 2153|  29.8k|    output[16] = (unsigned char) (ctx->ihv[4] >> 24);
 2154|  29.8k|    output[17] = (unsigned char) (ctx->ihv[4] >> 16);
 2155|  29.8k|    output[18] = (unsigned char) (ctx->ihv[4] >> 8);
 2156|  29.8k|    output[19] = (unsigned char) (ctx->ihv[4]);
 2157|  29.8k|    return ctx->found_collision;
 2158|  29.8k|}
sha1.c:sha1_process:
 1963|   206k|{
 1964|   206k|    unsigned i, j;
 1965|   206k|    uint32_t ubc_dv_mask[DVMASKSIZE] = {0xFFFFFFFF};
 1966|   206k|    uint32_t ihvtmp[5];
 1967|       |
 1968|   206k|    ctx->ihv1[0] = ctx->ihv[0];
 1969|   206k|    ctx->ihv1[1] = ctx->ihv[1];
 1970|   206k|    ctx->ihv1[2] = ctx->ihv[2];
 1971|   206k|    ctx->ihv1[3] = ctx->ihv[3];
 1972|   206k|    ctx->ihv1[4] = ctx->ihv[4];
 1973|       |
 1974|   206k|    sha1_compression_states(ctx->ihv, block, ctx->m1, ctx->states);
 1975|       |
 1976|   206k|    if (ctx->detect_coll) {
  ------------------
  |  Branch (1976:9): [True: 206k, False: 0]
  ------------------
 1977|   206k|        if (ctx->ubc_check) {
  ------------------
  |  Branch (1977:13): [True: 206k, False: 0]
  ------------------
 1978|   206k|            ubc_check(ctx->m1, ubc_dv_mask);
 1979|   206k|        }
 1980|       |
 1981|   206k|        if (ubc_dv_mask[0] != 0) {
  ------------------
  |  Branch (1981:13): [True: 16.8k, False: 189k]
  ------------------
 1982|   555k|            for (i = 0; sha1_dvs[i].dvType != 0; ++i) {
  ------------------
  |  Branch (1982:25): [True: 538k, False: 16.8k]
  ------------------
 1983|   538k|                if (ubc_dv_mask[0] & ((uint32_t)(1) << sha1_dvs[i].maskb)) {
  ------------------
  |  Branch (1983:21): [True: 18.4k, False: 519k]
  ------------------
 1984|  1.49M|                    for (j = 0; j < 80; ++j)
  ------------------
  |  Branch (1984:33): [True: 1.47M, False: 18.4k]
  ------------------
 1985|  1.47M|                        ctx->m2[j] = ctx->m1[j] ^ sha1_dvs[i].dm[j];
 1986|       |
 1987|  18.4k|                    sha1_recompression_step(sha1_dvs[i].testt,
 1988|  18.4k|                                            ctx->ihv2,
 1989|  18.4k|                                            ihvtmp,
 1990|  18.4k|                                            ctx->m2,
 1991|  18.4k|                                            ctx->states[sha1_dvs[i].testt]);
 1992|       |
 1993|       |                    /* to verify SHA-1 collision detection code with collisions for
 1994|       |                     * reduced-step SHA-1 */
 1995|  18.4k|                    if ((0 == ((ihvtmp[0] ^ ctx->ihv[0]) | (ihvtmp[1] ^ ctx->ihv[1]) |
  ------------------
  |  Branch (1995:25): [True: 0, False: 18.4k]
  ------------------
 1996|  18.4k|                               (ihvtmp[2] ^ ctx->ihv[2]) | (ihvtmp[3] ^ ctx->ihv[3]) |
 1997|  18.4k|                               (ihvtmp[4] ^ ctx->ihv[4]))) ||
 1998|  18.4k|                        (ctx->reduced_round_coll &&
  ------------------
  |  Branch (1998:26): [True: 0, False: 18.4k]
  ------------------
 1999|      0|                         0 == ((ctx->ihv1[0] ^ ctx->ihv2[0]) | (ctx->ihv1[1] ^ ctx->ihv2[1]) |
  ------------------
  |  Branch (1999:26): [True: 0, False: 0]
  ------------------
 2000|      0|                               (ctx->ihv1[2] ^ ctx->ihv2[2]) | (ctx->ihv1[3] ^ ctx->ihv2[3]) |
 2001|      0|                               (ctx->ihv1[4] ^ ctx->ihv2[4])))) {
 2002|      0|                        ctx->found_collision = 1;
 2003|       |
 2004|      0|                        if (ctx->safe_hash) {
  ------------------
  |  Branch (2004:29): [True: 0, False: 0]
  ------------------
 2005|      0|                            sha1_compression_W(ctx->ihv, ctx->m1);
 2006|      0|                            sha1_compression_W(ctx->ihv, ctx->m1);
 2007|      0|                        }
 2008|       |
 2009|      0|                        break;
 2010|      0|                    }
 2011|  18.4k|                }
 2012|   538k|            }
 2013|  16.8k|        }
 2014|   206k|    }
 2015|   206k|}
sha1.c:sha1_recompression_step:
 1554|  18.4k|{
 1555|  18.4k|    switch (step) {
 1556|       |#ifdef DOSTORESTATE0
 1557|       |    case 0:
 1558|       |        sha1recompress_fast_0(ihvin, ihvout, me2, state);
 1559|       |        break;
 1560|       |#endif
 1561|       |#ifdef DOSTORESTATE1
 1562|       |    case 1:
 1563|       |        sha1recompress_fast_1(ihvin, ihvout, me2, state);
 1564|       |        break;
 1565|       |#endif
 1566|       |#ifdef DOSTORESTATE2
 1567|       |    case 2:
 1568|       |        sha1recompress_fast_2(ihvin, ihvout, me2, state);
 1569|       |        break;
 1570|       |#endif
 1571|       |#ifdef DOSTORESTATE3
 1572|       |    case 3:
 1573|       |        sha1recompress_fast_3(ihvin, ihvout, me2, state);
 1574|       |        break;
 1575|       |#endif
 1576|       |#ifdef DOSTORESTATE4
 1577|       |    case 4:
 1578|       |        sha1recompress_fast_4(ihvin, ihvout, me2, state);
 1579|       |        break;
 1580|       |#endif
 1581|       |#ifdef DOSTORESTATE5
 1582|       |    case 5:
 1583|       |        sha1recompress_fast_5(ihvin, ihvout, me2, state);
 1584|       |        break;
 1585|       |#endif
 1586|       |#ifdef DOSTORESTATE6
 1587|       |    case 6:
 1588|       |        sha1recompress_fast_6(ihvin, ihvout, me2, state);
 1589|       |        break;
 1590|       |#endif
 1591|       |#ifdef DOSTORESTATE7
 1592|       |    case 7:
 1593|       |        sha1recompress_fast_7(ihvin, ihvout, me2, state);
 1594|       |        break;
 1595|       |#endif
 1596|       |#ifdef DOSTORESTATE8
 1597|       |    case 8:
 1598|       |        sha1recompress_fast_8(ihvin, ihvout, me2, state);
 1599|       |        break;
 1600|       |#endif
 1601|       |#ifdef DOSTORESTATE9
 1602|       |    case 9:
 1603|       |        sha1recompress_fast_9(ihvin, ihvout, me2, state);
 1604|       |        break;
 1605|       |#endif
 1606|       |#ifdef DOSTORESTATE10
 1607|       |    case 10:
 1608|       |        sha1recompress_fast_10(ihvin, ihvout, me2, state);
 1609|       |        break;
 1610|       |#endif
 1611|       |#ifdef DOSTORESTATE11
 1612|       |    case 11:
 1613|       |        sha1recompress_fast_11(ihvin, ihvout, me2, state);
 1614|       |        break;
 1615|       |#endif
 1616|       |#ifdef DOSTORESTATE12
 1617|       |    case 12:
 1618|       |        sha1recompress_fast_12(ihvin, ihvout, me2, state);
 1619|       |        break;
 1620|       |#endif
 1621|       |#ifdef DOSTORESTATE13
 1622|       |    case 13:
 1623|       |        sha1recompress_fast_13(ihvin, ihvout, me2, state);
 1624|       |        break;
 1625|       |#endif
 1626|       |#ifdef DOSTORESTATE14
 1627|       |    case 14:
 1628|       |        sha1recompress_fast_14(ihvin, ihvout, me2, state);
 1629|       |        break;
 1630|       |#endif
 1631|       |#ifdef DOSTORESTATE15
 1632|       |    case 15:
 1633|       |        sha1recompress_fast_15(ihvin, ihvout, me2, state);
 1634|       |        break;
 1635|       |#endif
 1636|       |#ifdef DOSTORESTATE16
 1637|       |    case 16:
 1638|       |        sha1recompress_fast_16(ihvin, ihvout, me2, state);
 1639|       |        break;
 1640|       |#endif
 1641|       |#ifdef DOSTORESTATE17
 1642|       |    case 17:
 1643|       |        sha1recompress_fast_17(ihvin, ihvout, me2, state);
 1644|       |        break;
 1645|       |#endif
 1646|       |#ifdef DOSTORESTATE18
 1647|       |    case 18:
 1648|       |        sha1recompress_fast_18(ihvin, ihvout, me2, state);
 1649|       |        break;
 1650|       |#endif
 1651|       |#ifdef DOSTORESTATE19
 1652|       |    case 19:
 1653|       |        sha1recompress_fast_19(ihvin, ihvout, me2, state);
 1654|       |        break;
 1655|       |#endif
 1656|       |#ifdef DOSTORESTATE20
 1657|       |    case 20:
 1658|       |        sha1recompress_fast_20(ihvin, ihvout, me2, state);
 1659|       |        break;
 1660|       |#endif
 1661|       |#ifdef DOSTORESTATE21
 1662|       |    case 21:
 1663|       |        sha1recompress_fast_21(ihvin, ihvout, me2, state);
 1664|       |        break;
 1665|       |#endif
 1666|       |#ifdef DOSTORESTATE22
 1667|       |    case 22:
 1668|       |        sha1recompress_fast_22(ihvin, ihvout, me2, state);
 1669|       |        break;
 1670|       |#endif
 1671|       |#ifdef DOSTORESTATE23
 1672|       |    case 23:
 1673|       |        sha1recompress_fast_23(ihvin, ihvout, me2, state);
 1674|       |        break;
 1675|       |#endif
 1676|       |#ifdef DOSTORESTATE24
 1677|       |    case 24:
 1678|       |        sha1recompress_fast_24(ihvin, ihvout, me2, state);
 1679|       |        break;
 1680|       |#endif
 1681|       |#ifdef DOSTORESTATE25
 1682|       |    case 25:
 1683|       |        sha1recompress_fast_25(ihvin, ihvout, me2, state);
 1684|       |        break;
 1685|       |#endif
 1686|       |#ifdef DOSTORESTATE26
 1687|       |    case 26:
 1688|       |        sha1recompress_fast_26(ihvin, ihvout, me2, state);
 1689|       |        break;
 1690|       |#endif
 1691|       |#ifdef DOSTORESTATE27
 1692|       |    case 27:
 1693|       |        sha1recompress_fast_27(ihvin, ihvout, me2, state);
 1694|       |        break;
 1695|       |#endif
 1696|       |#ifdef DOSTORESTATE28
 1697|       |    case 28:
 1698|       |        sha1recompress_fast_28(ihvin, ihvout, me2, state);
 1699|       |        break;
 1700|       |#endif
 1701|       |#ifdef DOSTORESTATE29
 1702|       |    case 29:
 1703|       |        sha1recompress_fast_29(ihvin, ihvout, me2, state);
 1704|       |        break;
 1705|       |#endif
 1706|       |#ifdef DOSTORESTATE30
 1707|       |    case 30:
 1708|       |        sha1recompress_fast_30(ihvin, ihvout, me2, state);
 1709|       |        break;
 1710|       |#endif
 1711|       |#ifdef DOSTORESTATE31
 1712|       |    case 31:
 1713|       |        sha1recompress_fast_31(ihvin, ihvout, me2, state);
 1714|       |        break;
 1715|       |#endif
 1716|       |#ifdef DOSTORESTATE32
 1717|       |    case 32:
 1718|       |        sha1recompress_fast_32(ihvin, ihvout, me2, state);
 1719|       |        break;
 1720|       |#endif
 1721|       |#ifdef DOSTORESTATE33
 1722|       |    case 33:
 1723|       |        sha1recompress_fast_33(ihvin, ihvout, me2, state);
 1724|       |        break;
 1725|       |#endif
 1726|       |#ifdef DOSTORESTATE34
 1727|       |    case 34:
 1728|       |        sha1recompress_fast_34(ihvin, ihvout, me2, state);
 1729|       |        break;
 1730|       |#endif
 1731|       |#ifdef DOSTORESTATE35
 1732|       |    case 35:
 1733|       |        sha1recompress_fast_35(ihvin, ihvout, me2, state);
 1734|       |        break;
 1735|       |#endif
 1736|       |#ifdef DOSTORESTATE36
 1737|       |    case 36:
 1738|       |        sha1recompress_fast_36(ihvin, ihvout, me2, state);
 1739|       |        break;
 1740|       |#endif
 1741|       |#ifdef DOSTORESTATE37
 1742|       |    case 37:
 1743|       |        sha1recompress_fast_37(ihvin, ihvout, me2, state);
 1744|       |        break;
 1745|       |#endif
 1746|       |#ifdef DOSTORESTATE38
 1747|       |    case 38:
 1748|       |        sha1recompress_fast_38(ihvin, ihvout, me2, state);
 1749|       |        break;
 1750|       |#endif
 1751|       |#ifdef DOSTORESTATE39
 1752|       |    case 39:
 1753|       |        sha1recompress_fast_39(ihvin, ihvout, me2, state);
 1754|       |        break;
 1755|       |#endif
 1756|       |#ifdef DOSTORESTATE40
 1757|       |    case 40:
 1758|       |        sha1recompress_fast_40(ihvin, ihvout, me2, state);
 1759|       |        break;
 1760|       |#endif
 1761|       |#ifdef DOSTORESTATE41
 1762|       |    case 41:
 1763|       |        sha1recompress_fast_41(ihvin, ihvout, me2, state);
 1764|       |        break;
 1765|       |#endif
 1766|       |#ifdef DOSTORESTATE42
 1767|       |    case 42:
 1768|       |        sha1recompress_fast_42(ihvin, ihvout, me2, state);
 1769|       |        break;
 1770|       |#endif
 1771|       |#ifdef DOSTORESTATE43
 1772|       |    case 43:
 1773|       |        sha1recompress_fast_43(ihvin, ihvout, me2, state);
 1774|       |        break;
 1775|       |#endif
 1776|       |#ifdef DOSTORESTATE44
 1777|       |    case 44:
 1778|       |        sha1recompress_fast_44(ihvin, ihvout, me2, state);
 1779|       |        break;
 1780|       |#endif
 1781|       |#ifdef DOSTORESTATE45
 1782|       |    case 45:
 1783|       |        sha1recompress_fast_45(ihvin, ihvout, me2, state);
 1784|       |        break;
 1785|       |#endif
 1786|       |#ifdef DOSTORESTATE46
 1787|       |    case 46:
 1788|       |        sha1recompress_fast_46(ihvin, ihvout, me2, state);
 1789|       |        break;
 1790|       |#endif
 1791|       |#ifdef DOSTORESTATE47
 1792|       |    case 47:
 1793|       |        sha1recompress_fast_47(ihvin, ihvout, me2, state);
 1794|       |        break;
 1795|       |#endif
 1796|       |#ifdef DOSTORESTATE48
 1797|       |    case 48:
 1798|       |        sha1recompress_fast_48(ihvin, ihvout, me2, state);
 1799|       |        break;
 1800|       |#endif
 1801|       |#ifdef DOSTORESTATE49
 1802|       |    case 49:
 1803|       |        sha1recompress_fast_49(ihvin, ihvout, me2, state);
 1804|       |        break;
 1805|       |#endif
 1806|       |#ifdef DOSTORESTATE50
 1807|       |    case 50:
 1808|       |        sha1recompress_fast_50(ihvin, ihvout, me2, state);
 1809|       |        break;
 1810|       |#endif
 1811|       |#ifdef DOSTORESTATE51
 1812|       |    case 51:
 1813|       |        sha1recompress_fast_51(ihvin, ihvout, me2, state);
 1814|       |        break;
 1815|       |#endif
 1816|       |#ifdef DOSTORESTATE52
 1817|       |    case 52:
 1818|       |        sha1recompress_fast_52(ihvin, ihvout, me2, state);
 1819|       |        break;
 1820|       |#endif
 1821|       |#ifdef DOSTORESTATE53
 1822|       |    case 53:
 1823|       |        sha1recompress_fast_53(ihvin, ihvout, me2, state);
 1824|       |        break;
 1825|       |#endif
 1826|       |#ifdef DOSTORESTATE54
 1827|       |    case 54:
 1828|       |        sha1recompress_fast_54(ihvin, ihvout, me2, state);
 1829|       |        break;
 1830|       |#endif
 1831|       |#ifdef DOSTORESTATE55
 1832|       |    case 55:
 1833|       |        sha1recompress_fast_55(ihvin, ihvout, me2, state);
 1834|       |        break;
 1835|       |#endif
 1836|       |#ifdef DOSTORESTATE56
 1837|       |    case 56:
 1838|       |        sha1recompress_fast_56(ihvin, ihvout, me2, state);
 1839|       |        break;
 1840|       |#endif
 1841|       |#ifdef DOSTORESTATE57
 1842|       |    case 57:
 1843|       |        sha1recompress_fast_57(ihvin, ihvout, me2, state);
 1844|       |        break;
 1845|       |#endif
 1846|      0|#ifdef DOSTORESTATE58
 1847|  13.4k|    case 58:
  ------------------
  |  Branch (1847:5): [True: 13.4k, False: 4.97k]
  ------------------
 1848|  13.4k|        sha1recompress_fast_58(ihvin, ihvout, me2, state);
 1849|  13.4k|        break;
 1850|      0|#endif
 1851|       |#ifdef DOSTORESTATE59
 1852|       |    case 59:
 1853|       |        sha1recompress_fast_59(ihvin, ihvout, me2, state);
 1854|       |        break;
 1855|       |#endif
 1856|       |#ifdef DOSTORESTATE60
 1857|       |    case 60:
 1858|       |        sha1recompress_fast_60(ihvin, ihvout, me2, state);
 1859|       |        break;
 1860|       |#endif
 1861|       |#ifdef DOSTORESTATE61
 1862|       |    case 61:
 1863|       |        sha1recompress_fast_61(ihvin, ihvout, me2, state);
 1864|       |        break;
 1865|       |#endif
 1866|       |#ifdef DOSTORESTATE62
 1867|       |    case 62:
 1868|       |        sha1recompress_fast_62(ihvin, ihvout, me2, state);
 1869|       |        break;
 1870|       |#endif
 1871|       |#ifdef DOSTORESTATE63
 1872|       |    case 63:
 1873|       |        sha1recompress_fast_63(ihvin, ihvout, me2, state);
 1874|       |        break;
 1875|       |#endif
 1876|       |#ifdef DOSTORESTATE64
 1877|       |    case 64:
 1878|       |        sha1recompress_fast_64(ihvin, ihvout, me2, state);
 1879|       |        break;
 1880|       |#endif
 1881|      0|#ifdef DOSTORESTATE65
 1882|  4.97k|    case 65:
  ------------------
  |  Branch (1882:5): [True: 4.97k, False: 13.4k]
  ------------------
 1883|  4.97k|        sha1recompress_fast_65(ihvin, ihvout, me2, state);
 1884|  4.97k|        break;
 1885|      0|#endif
 1886|       |#ifdef DOSTORESTATE66
 1887|       |    case 66:
 1888|       |        sha1recompress_fast_66(ihvin, ihvout, me2, state);
 1889|       |        break;
 1890|       |#endif
 1891|       |#ifdef DOSTORESTATE67
 1892|       |    case 67:
 1893|       |        sha1recompress_fast_67(ihvin, ihvout, me2, state);
 1894|       |        break;
 1895|       |#endif
 1896|       |#ifdef DOSTORESTATE68
 1897|       |    case 68:
 1898|       |        sha1recompress_fast_68(ihvin, ihvout, me2, state);
 1899|       |        break;
 1900|       |#endif
 1901|       |#ifdef DOSTORESTATE69
 1902|       |    case 69:
 1903|       |        sha1recompress_fast_69(ihvin, ihvout, me2, state);
 1904|       |        break;
 1905|       |#endif
 1906|       |#ifdef DOSTORESTATE70
 1907|       |    case 70:
 1908|       |        sha1recompress_fast_70(ihvin, ihvout, me2, state);
 1909|       |        break;
 1910|       |#endif
 1911|       |#ifdef DOSTORESTATE71
 1912|       |    case 71:
 1913|       |        sha1recompress_fast_71(ihvin, ihvout, me2, state);
 1914|       |        break;
 1915|       |#endif
 1916|       |#ifdef DOSTORESTATE72
 1917|       |    case 72:
 1918|       |        sha1recompress_fast_72(ihvin, ihvout, me2, state);
 1919|       |        break;
 1920|       |#endif
 1921|       |#ifdef DOSTORESTATE73
 1922|       |    case 73:
 1923|       |        sha1recompress_fast_73(ihvin, ihvout, me2, state);
 1924|       |        break;
 1925|       |#endif
 1926|       |#ifdef DOSTORESTATE74
 1927|       |    case 74:
 1928|       |        sha1recompress_fast_74(ihvin, ihvout, me2, state);
 1929|       |        break;
 1930|       |#endif
 1931|       |#ifdef DOSTORESTATE75
 1932|       |    case 75:
 1933|       |        sha1recompress_fast_75(ihvin, ihvout, me2, state);
 1934|       |        break;
 1935|       |#endif
 1936|       |#ifdef DOSTORESTATE76
 1937|       |    case 76:
 1938|       |        sha1recompress_fast_76(ihvin, ihvout, me2, state);
 1939|       |        break;
 1940|       |#endif
 1941|       |#ifdef DOSTORESTATE77
 1942|       |    case 77:
 1943|       |        sha1recompress_fast_77(ihvin, ihvout, me2, state);
 1944|       |        break;
 1945|       |#endif
 1946|       |#ifdef DOSTORESTATE78
 1947|       |    case 78:
 1948|       |        sha1recompress_fast_78(ihvin, ihvout, me2, state);
 1949|       |        break;
 1950|       |#endif
 1951|       |#ifdef DOSTORESTATE79
 1952|       |    case 79:
 1953|       |        sha1recompress_fast_79(ihvin, ihvout, me2, state);
 1954|       |        break;
 1955|       |#endif
 1956|      0|    default:
  ------------------
  |  Branch (1956:5): [True: 0, False: 18.4k]
  ------------------
 1957|      0|        abort();
 1958|  18.4k|    }
 1959|  18.4k|}
sha1.c:sha1recompress_fast_58:
  879|  13.4k|    {                                                                                         \
  880|  13.4k|        uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];        \
  881|  13.4k|        if (t > 79)                                                                           \
  ------------------
  |  Branch (881:13): [Folded, False: 13.4k]
  ------------------
  882|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 79);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  883|  13.4k|        if (t > 78)                                                                           \
  ------------------
  |  Branch (883:13): [Folded, False: 13.4k]
  ------------------
  884|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 78);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  885|  13.4k|        if (t > 77)                                                                           \
  ------------------
  |  Branch (885:13): [Folded, False: 13.4k]
  ------------------
  886|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 77);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  887|  13.4k|        if (t > 76)                                                                           \
  ------------------
  |  Branch (887:13): [Folded, False: 13.4k]
  ------------------
  888|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 76);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  889|  13.4k|        if (t > 75)                                                                           \
  ------------------
  |  Branch (889:13): [Folded, False: 13.4k]
  ------------------
  890|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 75);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  891|  13.4k|        if (t > 74)                                                                           \
  ------------------
  |  Branch (891:13): [Folded, False: 13.4k]
  ------------------
  892|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 74);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  893|  13.4k|        if (t > 73)                                                                           \
  ------------------
  |  Branch (893:13): [Folded, False: 13.4k]
  ------------------
  894|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 73);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  895|  13.4k|        if (t > 72)                                                                           \
  ------------------
  |  Branch (895:13): [Folded, False: 13.4k]
  ------------------
  896|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 72);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  897|  13.4k|        if (t > 71)                                                                           \
  ------------------
  |  Branch (897:13): [Folded, False: 13.4k]
  ------------------
  898|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 71);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  899|  13.4k|        if (t > 70)                                                                           \
  ------------------
  |  Branch (899:13): [Folded, False: 13.4k]
  ------------------
  900|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 70);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  901|  13.4k|        if (t > 69)                                                                           \
  ------------------
  |  Branch (901:13): [Folded, False: 13.4k]
  ------------------
  902|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 69);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  903|  13.4k|        if (t > 68)                                                                           \
  ------------------
  |  Branch (903:13): [Folded, False: 13.4k]
  ------------------
  904|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 68);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  905|  13.4k|        if (t > 67)                                                                           \
  ------------------
  |  Branch (905:13): [Folded, False: 13.4k]
  ------------------
  906|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 67);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  907|  13.4k|        if (t > 66)                                                                           \
  ------------------
  |  Branch (907:13): [Folded, False: 13.4k]
  ------------------
  908|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 66);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  909|  13.4k|        if (t > 65)                                                                           \
  ------------------
  |  Branch (909:13): [Folded, False: 13.4k]
  ------------------
  910|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 65);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  911|  13.4k|        if (t > 64)                                                                           \
  ------------------
  |  Branch (911:13): [Folded, False: 13.4k]
  ------------------
  912|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 64);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  913|  13.4k|        if (t > 63)                                                                           \
  ------------------
  |  Branch (913:13): [Folded, False: 13.4k]
  ------------------
  914|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 63);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  915|  13.4k|        if (t > 62)                                                                           \
  ------------------
  |  Branch (915:13): [Folded, False: 13.4k]
  ------------------
  916|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 62);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  917|  13.4k|        if (t > 61)                                                                           \
  ------------------
  |  Branch (917:13): [Folded, False: 13.4k]
  ------------------
  918|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 61);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  919|  13.4k|        if (t > 60)                                                                           \
  ------------------
  |  Branch (919:13): [Folded, False: 13.4k]
  ------------------
  920|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 60);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  921|  13.4k|        if (t > 59)                                                                           \
  ------------------
  |  Branch (921:13): [Folded, False: 13.4k]
  ------------------
  922|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 59);                    \
  ------------------
  |  |  197|      0|    {                                                                  \
  |  |  198|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|      0|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|      0|    }
  ------------------
  923|  13.4k|        if (t > 58)                                                                           \
  ------------------
  |  Branch (923:13): [Folded, False: 13.4k]
  ------------------
  924|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 58);                    \
  ------------------
  |  |  197|      0|    {                                                                  \
  |  |  198|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|      0|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|      0|    }
  ------------------
  925|  13.4k|        if (t > 57)                                                                           \
  ------------------
  |  Branch (925:13): [True: 13.4k, Folded]
  ------------------
  926|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 57);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  927|  13.4k|        if (t > 56)                                                                           \
  ------------------
  |  Branch (927:13): [True: 13.4k, Folded]
  ------------------
  928|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 56);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  929|  13.4k|        if (t > 55)                                                                           \
  ------------------
  |  Branch (929:13): [True: 13.4k, Folded]
  ------------------
  930|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 55);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  931|  13.4k|        if (t > 54)                                                                           \
  ------------------
  |  Branch (931:13): [True: 13.4k, Folded]
  ------------------
  932|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 54);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  933|  13.4k|        if (t > 53)                                                                           \
  ------------------
  |  Branch (933:13): [True: 13.4k, Folded]
  ------------------
  934|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 53);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  935|  13.4k|        if (t > 52)                                                                           \
  ------------------
  |  Branch (935:13): [True: 13.4k, Folded]
  ------------------
  936|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 52);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  937|  13.4k|        if (t > 51)                                                                           \
  ------------------
  |  Branch (937:13): [True: 13.4k, Folded]
  ------------------
  938|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 51);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  939|  13.4k|        if (t > 50)                                                                           \
  ------------------
  |  Branch (939:13): [True: 13.4k, Folded]
  ------------------
  940|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 50);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  941|  13.4k|        if (t > 49)                                                                           \
  ------------------
  |  Branch (941:13): [True: 13.4k, Folded]
  ------------------
  942|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 49);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  943|  13.4k|        if (t > 48)                                                                           \
  ------------------
  |  Branch (943:13): [True: 13.4k, Folded]
  ------------------
  944|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 48);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  945|  13.4k|        if (t > 47)                                                                           \
  ------------------
  |  Branch (945:13): [True: 13.4k, Folded]
  ------------------
  946|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 47);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  947|  13.4k|        if (t > 46)                                                                           \
  ------------------
  |  Branch (947:13): [True: 13.4k, Folded]
  ------------------
  948|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 46);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  949|  13.4k|        if (t > 45)                                                                           \
  ------------------
  |  Branch (949:13): [True: 13.4k, Folded]
  ------------------
  950|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 45);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  951|  13.4k|        if (t > 44)                                                                           \
  ------------------
  |  Branch (951:13): [True: 13.4k, Folded]
  ------------------
  952|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 44);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  953|  13.4k|        if (t > 43)                                                                           \
  ------------------
  |  Branch (953:13): [True: 13.4k, Folded]
  ------------------
  954|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 43);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  955|  13.4k|        if (t > 42)                                                                           \
  ------------------
  |  Branch (955:13): [True: 13.4k, Folded]
  ------------------
  956|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 42);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  957|  13.4k|        if (t > 41)                                                                           \
  ------------------
  |  Branch (957:13): [True: 13.4k, Folded]
  ------------------
  958|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 41);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  959|  13.4k|        if (t > 40)                                                                           \
  ------------------
  |  Branch (959:13): [True: 13.4k, Folded]
  ------------------
  960|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 40);                    \
  ------------------
  |  |  197|  13.4k|    {                                                                  \
  |  |  198|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  13.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  13.4k|    }
  ------------------
  961|  13.4k|        if (t > 39)                                                                           \
  ------------------
  |  Branch (961:13): [True: 13.4k, Folded]
  ------------------
  962|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 39);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  963|  13.4k|        if (t > 38)                                                                           \
  ------------------
  |  Branch (963:13): [True: 13.4k, Folded]
  ------------------
  964|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 38);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  965|  13.4k|        if (t > 37)                                                                           \
  ------------------
  |  Branch (965:13): [True: 13.4k, Folded]
  ------------------
  966|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 37);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  967|  13.4k|        if (t > 36)                                                                           \
  ------------------
  |  Branch (967:13): [True: 13.4k, Folded]
  ------------------
  968|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 36);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  969|  13.4k|        if (t > 35)                                                                           \
  ------------------
  |  Branch (969:13): [True: 13.4k, Folded]
  ------------------
  970|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 35);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  971|  13.4k|        if (t > 34)                                                                           \
  ------------------
  |  Branch (971:13): [True: 13.4k, Folded]
  ------------------
  972|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 34);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  973|  13.4k|        if (t > 33)                                                                           \
  ------------------
  |  Branch (973:13): [True: 13.4k, Folded]
  ------------------
  974|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 33);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  975|  13.4k|        if (t > 32)                                                                           \
  ------------------
  |  Branch (975:13): [True: 13.4k, Folded]
  ------------------
  976|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 32);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  977|  13.4k|        if (t > 31)                                                                           \
  ------------------
  |  Branch (977:13): [True: 13.4k, Folded]
  ------------------
  978|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 31);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  979|  13.4k|        if (t > 30)                                                                           \
  ------------------
  |  Branch (979:13): [True: 13.4k, Folded]
  ------------------
  980|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 30);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  981|  13.4k|        if (t > 29)                                                                           \
  ------------------
  |  Branch (981:13): [True: 13.4k, Folded]
  ------------------
  982|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 29);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  983|  13.4k|        if (t > 28)                                                                           \
  ------------------
  |  Branch (983:13): [True: 13.4k, Folded]
  ------------------
  984|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 28);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  985|  13.4k|        if (t > 27)                                                                           \
  ------------------
  |  Branch (985:13): [True: 13.4k, Folded]
  ------------------
  986|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 27);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  987|  13.4k|        if (t > 26)                                                                           \
  ------------------
  |  Branch (987:13): [True: 13.4k, Folded]
  ------------------
  988|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 26);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  989|  13.4k|        if (t > 25)                                                                           \
  ------------------
  |  Branch (989:13): [True: 13.4k, Folded]
  ------------------
  990|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 25);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  991|  13.4k|        if (t > 24)                                                                           \
  ------------------
  |  Branch (991:13): [True: 13.4k, Folded]
  ------------------
  992|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 24);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  993|  13.4k|        if (t > 23)                                                                           \
  ------------------
  |  Branch (993:13): [True: 13.4k, Folded]
  ------------------
  994|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 23);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  995|  13.4k|        if (t > 22)                                                                           \
  ------------------
  |  Branch (995:13): [True: 13.4k, Folded]
  ------------------
  996|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 22);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  997|  13.4k|        if (t > 21)                                                                           \
  ------------------
  |  Branch (997:13): [True: 13.4k, Folded]
  ------------------
  998|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 21);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
  999|  13.4k|        if (t > 20)                                                                           \
  ------------------
  |  Branch (999:13): [True: 13.4k, Folded]
  ------------------
 1000|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 20);                    \
  ------------------
  |  |  192|  13.4k|    {                                                                  \
  |  |  193|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  13.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  13.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  13.4k|    }
  ------------------
 1001|  13.4k|        if (t > 19)                                                                           \
  ------------------
  |  Branch (1001:13): [True: 13.4k, Folded]
  ------------------
 1002|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 19);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1003|  13.4k|        if (t > 18)                                                                           \
  ------------------
  |  Branch (1003:13): [True: 13.4k, Folded]
  ------------------
 1004|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 18);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1005|  13.4k|        if (t > 17)                                                                           \
  ------------------
  |  Branch (1005:13): [True: 13.4k, Folded]
  ------------------
 1006|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 17);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1007|  13.4k|        if (t > 16)                                                                           \
  ------------------
  |  Branch (1007:13): [True: 13.4k, Folded]
  ------------------
 1008|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 16);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1009|  13.4k|        if (t > 15)                                                                           \
  ------------------
  |  Branch (1009:13): [True: 13.4k, Folded]
  ------------------
 1010|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 15);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1011|  13.4k|        if (t > 14)                                                                           \
  ------------------
  |  Branch (1011:13): [True: 13.4k, Folded]
  ------------------
 1012|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 14);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1013|  13.4k|        if (t > 13)                                                                           \
  ------------------
  |  Branch (1013:13): [True: 13.4k, Folded]
  ------------------
 1014|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 13);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1015|  13.4k|        if (t > 12)                                                                           \
  ------------------
  |  Branch (1015:13): [True: 13.4k, Folded]
  ------------------
 1016|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 12);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1017|  13.4k|        if (t > 11)                                                                           \
  ------------------
  |  Branch (1017:13): [True: 13.4k, Folded]
  ------------------
 1018|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 11);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1019|  13.4k|        if (t > 10)                                                                           \
  ------------------
  |  Branch (1019:13): [True: 13.4k, Folded]
  ------------------
 1020|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 10);                    \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1021|  13.4k|        if (t > 9)                                                                            \
  ------------------
  |  Branch (1021:13): [True: 13.4k, Folded]
  ------------------
 1022|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 9);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1023|  13.4k|        if (t > 8)                                                                            \
  ------------------
  |  Branch (1023:13): [True: 13.4k, Folded]
  ------------------
 1024|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 8);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1025|  13.4k|        if (t > 7)                                                                            \
  ------------------
  |  Branch (1025:13): [True: 13.4k, Folded]
  ------------------
 1026|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 7);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1027|  13.4k|        if (t > 6)                                                                            \
  ------------------
  |  Branch (1027:13): [True: 13.4k, Folded]
  ------------------
 1028|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 6);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1029|  13.4k|        if (t > 5)                                                                            \
  ------------------
  |  Branch (1029:13): [True: 13.4k, Folded]
  ------------------
 1030|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 5);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1031|  13.4k|        if (t > 4)                                                                            \
  ------------------
  |  Branch (1031:13): [True: 13.4k, Folded]
  ------------------
 1032|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 4);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1033|  13.4k|        if (t > 3)                                                                            \
  ------------------
  |  Branch (1033:13): [True: 13.4k, Folded]
  ------------------
 1034|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 3);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1035|  13.4k|        if (t > 2)                                                                            \
  ------------------
  |  Branch (1035:13): [True: 13.4k, Folded]
  ------------------
 1036|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 2);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1037|  13.4k|        if (t > 1)                                                                            \
  ------------------
  |  Branch (1037:13): [True: 13.4k, Folded]
  ------------------
 1038|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 1);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1039|  13.4k|        if (t > 0)                                                                            \
  ------------------
  |  Branch (1039:13): [True: 13.4k, Folded]
  ------------------
 1040|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 0);                     \
  ------------------
  |  |  187|  13.4k|    {                                                                  \
  |  |  188|  13.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  13.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  13.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  13.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  13.4k|    }
  ------------------
 1041|  13.4k|        ihvin[0] = a;                                                                         \
 1042|  13.4k|        ihvin[1] = b;                                                                         \
 1043|  13.4k|        ihvin[2] = c;                                                                         \
 1044|  13.4k|        ihvin[3] = d;                                                                         \
 1045|  13.4k|        ihvin[4] = e;                                                                         \
 1046|  13.4k|        a = state[0];                                                                         \
 1047|  13.4k|        b = state[1];                                                                         \
 1048|  13.4k|        c = state[2];                                                                         \
 1049|  13.4k|        d = state[3];                                                                         \
 1050|  13.4k|        e = state[4];                                                                         \
 1051|  13.4k|        if (t <= 0)                                                                           \
  ------------------
  |  Branch (1051:13): [Folded, False: 13.4k]
  ------------------
 1052|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 0);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1053|  13.4k|        if (t <= 1)                                                                           \
  ------------------
  |  Branch (1053:13): [Folded, False: 13.4k]
  ------------------
 1054|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 1);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1055|  13.4k|        if (t <= 2)                                                                           \
  ------------------
  |  Branch (1055:13): [Folded, False: 13.4k]
  ------------------
 1056|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 2);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1057|  13.4k|        if (t <= 3)                                                                           \
  ------------------
  |  Branch (1057:13): [Folded, False: 13.4k]
  ------------------
 1058|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 3);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1059|  13.4k|        if (t <= 4)                                                                           \
  ------------------
  |  Branch (1059:13): [Folded, False: 13.4k]
  ------------------
 1060|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 4);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1061|  13.4k|        if (t <= 5)                                                                           \
  ------------------
  |  Branch (1061:13): [Folded, False: 13.4k]
  ------------------
 1062|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 5);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1063|  13.4k|        if (t <= 6)                                                                           \
  ------------------
  |  Branch (1063:13): [Folded, False: 13.4k]
  ------------------
 1064|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 6);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1065|  13.4k|        if (t <= 7)                                                                           \
  ------------------
  |  Branch (1065:13): [Folded, False: 13.4k]
  ------------------
 1066|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 7);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1067|  13.4k|        if (t <= 8)                                                                           \
  ------------------
  |  Branch (1067:13): [Folded, False: 13.4k]
  ------------------
 1068|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 8);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1069|  13.4k|        if (t <= 9)                                                                           \
  ------------------
  |  Branch (1069:13): [Folded, False: 13.4k]
  ------------------
 1070|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 9);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1071|  13.4k|        if (t <= 10)                                                                          \
  ------------------
  |  Branch (1071:13): [Folded, False: 13.4k]
  ------------------
 1072|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 10);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1073|  13.4k|        if (t <= 11)                                                                          \
  ------------------
  |  Branch (1073:13): [Folded, False: 13.4k]
  ------------------
 1074|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 11);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1075|  13.4k|        if (t <= 12)                                                                          \
  ------------------
  |  Branch (1075:13): [Folded, False: 13.4k]
  ------------------
 1076|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 12);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1077|  13.4k|        if (t <= 13)                                                                          \
  ------------------
  |  Branch (1077:13): [Folded, False: 13.4k]
  ------------------
 1078|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 13);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1079|  13.4k|        if (t <= 14)                                                                          \
  ------------------
  |  Branch (1079:13): [Folded, False: 13.4k]
  ------------------
 1080|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 14);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1081|  13.4k|        if (t <= 15)                                                                          \
  ------------------
  |  Branch (1081:13): [Folded, False: 13.4k]
  ------------------
 1082|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 15);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1083|  13.4k|        if (t <= 16)                                                                          \
  ------------------
  |  Branch (1083:13): [Folded, False: 13.4k]
  ------------------
 1084|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 16);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1085|  13.4k|        if (t <= 17)                                                                          \
  ------------------
  |  Branch (1085:13): [Folded, False: 13.4k]
  ------------------
 1086|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 17);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1087|  13.4k|        if (t <= 18)                                                                          \
  ------------------
  |  Branch (1087:13): [Folded, False: 13.4k]
  ------------------
 1088|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 18);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1089|  13.4k|        if (t <= 19)                                                                          \
  ------------------
  |  Branch (1089:13): [Folded, False: 13.4k]
  ------------------
 1090|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 19);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1091|  13.4k|        if (t <= 20)                                                                          \
  ------------------
  |  Branch (1091:13): [Folded, False: 13.4k]
  ------------------
 1092|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 20);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1093|  13.4k|        if (t <= 21)                                                                          \
  ------------------
  |  Branch (1093:13): [Folded, False: 13.4k]
  ------------------
 1094|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 21);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1095|  13.4k|        if (t <= 22)                                                                          \
  ------------------
  |  Branch (1095:13): [Folded, False: 13.4k]
  ------------------
 1096|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 22);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1097|  13.4k|        if (t <= 23)                                                                          \
  ------------------
  |  Branch (1097:13): [Folded, False: 13.4k]
  ------------------
 1098|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 23);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1099|  13.4k|        if (t <= 24)                                                                          \
  ------------------
  |  Branch (1099:13): [Folded, False: 13.4k]
  ------------------
 1100|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 24);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1101|  13.4k|        if (t <= 25)                                                                          \
  ------------------
  |  Branch (1101:13): [Folded, False: 13.4k]
  ------------------
 1102|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 25);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1103|  13.4k|        if (t <= 26)                                                                          \
  ------------------
  |  Branch (1103:13): [Folded, False: 13.4k]
  ------------------
 1104|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 26);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1105|  13.4k|        if (t <= 27)                                                                          \
  ------------------
  |  Branch (1105:13): [Folded, False: 13.4k]
  ------------------
 1106|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 27);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1107|  13.4k|        if (t <= 28)                                                                          \
  ------------------
  |  Branch (1107:13): [Folded, False: 13.4k]
  ------------------
 1108|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 28);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1109|  13.4k|        if (t <= 29)                                                                          \
  ------------------
  |  Branch (1109:13): [Folded, False: 13.4k]
  ------------------
 1110|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 29);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1111|  13.4k|        if (t <= 30)                                                                          \
  ------------------
  |  Branch (1111:13): [Folded, False: 13.4k]
  ------------------
 1112|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 30);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1113|  13.4k|        if (t <= 31)                                                                          \
  ------------------
  |  Branch (1113:13): [Folded, False: 13.4k]
  ------------------
 1114|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 31);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1115|  13.4k|        if (t <= 32)                                                                          \
  ------------------
  |  Branch (1115:13): [Folded, False: 13.4k]
  ------------------
 1116|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 32);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1117|  13.4k|        if (t <= 33)                                                                          \
  ------------------
  |  Branch (1117:13): [Folded, False: 13.4k]
  ------------------
 1118|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 33);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1119|  13.4k|        if (t <= 34)                                                                          \
  ------------------
  |  Branch (1119:13): [Folded, False: 13.4k]
  ------------------
 1120|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 34);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1121|  13.4k|        if (t <= 35)                                                                          \
  ------------------
  |  Branch (1121:13): [Folded, False: 13.4k]
  ------------------
 1122|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 35);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1123|  13.4k|        if (t <= 36)                                                                          \
  ------------------
  |  Branch (1123:13): [Folded, False: 13.4k]
  ------------------
 1124|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 36);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1125|  13.4k|        if (t <= 37)                                                                          \
  ------------------
  |  Branch (1125:13): [Folded, False: 13.4k]
  ------------------
 1126|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 37);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1127|  13.4k|        if (t <= 38)                                                                          \
  ------------------
  |  Branch (1127:13): [Folded, False: 13.4k]
  ------------------
 1128|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 38);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1129|  13.4k|        if (t <= 39)                                                                          \
  ------------------
  |  Branch (1129:13): [Folded, False: 13.4k]
  ------------------
 1130|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 39);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1131|  13.4k|        if (t <= 40)                                                                          \
  ------------------
  |  Branch (1131:13): [Folded, False: 13.4k]
  ------------------
 1132|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 40);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1133|  13.4k|        if (t <= 41)                                                                          \
  ------------------
  |  Branch (1133:13): [Folded, False: 13.4k]
  ------------------
 1134|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 41);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1135|  13.4k|        if (t <= 42)                                                                          \
  ------------------
  |  Branch (1135:13): [Folded, False: 13.4k]
  ------------------
 1136|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 42);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1137|  13.4k|        if (t <= 43)                                                                          \
  ------------------
  |  Branch (1137:13): [Folded, False: 13.4k]
  ------------------
 1138|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 43);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1139|  13.4k|        if (t <= 44)                                                                          \
  ------------------
  |  Branch (1139:13): [Folded, False: 13.4k]
  ------------------
 1140|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 44);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1141|  13.4k|        if (t <= 45)                                                                          \
  ------------------
  |  Branch (1141:13): [Folded, False: 13.4k]
  ------------------
 1142|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 45);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1143|  13.4k|        if (t <= 46)                                                                          \
  ------------------
  |  Branch (1143:13): [Folded, False: 13.4k]
  ------------------
 1144|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 46);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1145|  13.4k|        if (t <= 47)                                                                          \
  ------------------
  |  Branch (1145:13): [Folded, False: 13.4k]
  ------------------
 1146|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 47);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1147|  13.4k|        if (t <= 48)                                                                          \
  ------------------
  |  Branch (1147:13): [Folded, False: 13.4k]
  ------------------
 1148|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 48);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1149|  13.4k|        if (t <= 49)                                                                          \
  ------------------
  |  Branch (1149:13): [Folded, False: 13.4k]
  ------------------
 1150|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 49);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1151|  13.4k|        if (t <= 50)                                                                          \
  ------------------
  |  Branch (1151:13): [Folded, False: 13.4k]
  ------------------
 1152|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 50);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1153|  13.4k|        if (t <= 51)                                                                          \
  ------------------
  |  Branch (1153:13): [Folded, False: 13.4k]
  ------------------
 1154|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 51);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1155|  13.4k|        if (t <= 52)                                                                          \
  ------------------
  |  Branch (1155:13): [Folded, False: 13.4k]
  ------------------
 1156|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 52);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1157|  13.4k|        if (t <= 53)                                                                          \
  ------------------
  |  Branch (1157:13): [Folded, False: 13.4k]
  ------------------
 1158|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 53);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1159|  13.4k|        if (t <= 54)                                                                          \
  ------------------
  |  Branch (1159:13): [Folded, False: 13.4k]
  ------------------
 1160|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 54);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1161|  13.4k|        if (t <= 55)                                                                          \
  ------------------
  |  Branch (1161:13): [Folded, False: 13.4k]
  ------------------
 1162|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 55);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1163|  13.4k|        if (t <= 56)                                                                          \
  ------------------
  |  Branch (1163:13): [Folded, False: 13.4k]
  ------------------
 1164|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 56);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1165|  13.4k|        if (t <= 57)                                                                          \
  ------------------
  |  Branch (1165:13): [Folded, False: 13.4k]
  ------------------
 1166|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 57);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1167|  13.4k|        if (t <= 58)                                                                          \
  ------------------
  |  Branch (1167:13): [True: 13.4k, Folded]
  ------------------
 1168|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 58);                       \
  ------------------
  |  |  176|  13.4k|    {                                                                  \
  |  |  177|  13.4k|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|  13.4k|    }
  ------------------
 1169|  13.4k|        if (t <= 59)                                                                          \
  ------------------
  |  Branch (1169:13): [True: 13.4k, Folded]
  ------------------
 1170|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 59);                       \
  ------------------
  |  |  176|  13.4k|    {                                                                  \
  |  |  177|  13.4k|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  13.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|  13.4k|    }
  ------------------
 1171|  13.4k|        if (t <= 60)                                                                          \
  ------------------
  |  Branch (1171:13): [True: 13.4k, Folded]
  ------------------
 1172|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 60);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1173|  13.4k|        if (t <= 61)                                                                          \
  ------------------
  |  Branch (1173:13): [True: 13.4k, Folded]
  ------------------
 1174|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 61);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1175|  13.4k|        if (t <= 62)                                                                          \
  ------------------
  |  Branch (1175:13): [True: 13.4k, Folded]
  ------------------
 1176|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 62);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1177|  13.4k|        if (t <= 63)                                                                          \
  ------------------
  |  Branch (1177:13): [True: 13.4k, Folded]
  ------------------
 1178|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 63);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1179|  13.4k|        if (t <= 64)                                                                          \
  ------------------
  |  Branch (1179:13): [True: 13.4k, Folded]
  ------------------
 1180|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 64);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1181|  13.4k|        if (t <= 65)                                                                          \
  ------------------
  |  Branch (1181:13): [True: 13.4k, Folded]
  ------------------
 1182|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 65);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1183|  13.4k|        if (t <= 66)                                                                          \
  ------------------
  |  Branch (1183:13): [True: 13.4k, Folded]
  ------------------
 1184|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 66);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1185|  13.4k|        if (t <= 67)                                                                          \
  ------------------
  |  Branch (1185:13): [True: 13.4k, Folded]
  ------------------
 1186|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 67);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1187|  13.4k|        if (t <= 68)                                                                          \
  ------------------
  |  Branch (1187:13): [True: 13.4k, Folded]
  ------------------
 1188|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 68);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1189|  13.4k|        if (t <= 69)                                                                          \
  ------------------
  |  Branch (1189:13): [True: 13.4k, Folded]
  ------------------
 1190|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 69);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1191|  13.4k|        if (t <= 70)                                                                          \
  ------------------
  |  Branch (1191:13): [True: 13.4k, Folded]
  ------------------
 1192|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 70);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1193|  13.4k|        if (t <= 71)                                                                          \
  ------------------
  |  Branch (1193:13): [True: 13.4k, Folded]
  ------------------
 1194|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 71);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1195|  13.4k|        if (t <= 72)                                                                          \
  ------------------
  |  Branch (1195:13): [True: 13.4k, Folded]
  ------------------
 1196|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 72);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1197|  13.4k|        if (t <= 73)                                                                          \
  ------------------
  |  Branch (1197:13): [True: 13.4k, Folded]
  ------------------
 1198|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 73);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1199|  13.4k|        if (t <= 74)                                                                          \
  ------------------
  |  Branch (1199:13): [True: 13.4k, Folded]
  ------------------
 1200|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 74);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1201|  13.4k|        if (t <= 75)                                                                          \
  ------------------
  |  Branch (1201:13): [True: 13.4k, Folded]
  ------------------
 1202|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 75);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1203|  13.4k|        if (t <= 76)                                                                          \
  ------------------
  |  Branch (1203:13): [True: 13.4k, Folded]
  ------------------
 1204|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 76);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1205|  13.4k|        if (t <= 77)                                                                          \
  ------------------
  |  Branch (1205:13): [True: 13.4k, Folded]
  ------------------
 1206|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 77);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1207|  13.4k|        if (t <= 78)                                                                          \
  ------------------
  |  Branch (1207:13): [True: 13.4k, Folded]
  ------------------
 1208|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 78);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1209|  13.4k|        if (t <= 79)                                                                          \
  ------------------
  |  Branch (1209:13): [True: 13.4k, Folded]
  ------------------
 1210|  13.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 79);                       \
  ------------------
  |  |  181|  13.4k|    {                                                                  \
  |  |  182|  13.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  13.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  13.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  13.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  13.4k|    }
  ------------------
 1211|  13.4k|        ihvout[0] = ihvin[0] + a;                                                             \
 1212|  13.4k|        ihvout[1] = ihvin[1] + b;                                                             \
 1213|  13.4k|        ihvout[2] = ihvin[2] + c;                                                             \
 1214|  13.4k|        ihvout[3] = ihvin[3] + d;                                                             \
 1215|  13.4k|        ihvout[4] = ihvin[4] + e;                                                             \
 1216|  13.4k|    }
sha1.c:sha1recompress_fast_65:
  879|  4.97k|    {                                                                                         \
  880|  4.97k|        uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];        \
  881|  4.97k|        if (t > 79)                                                                           \
  ------------------
  |  Branch (881:13): [Folded, False: 4.97k]
  ------------------
  882|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 79);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  883|  4.97k|        if (t > 78)                                                                           \
  ------------------
  |  Branch (883:13): [Folded, False: 4.97k]
  ------------------
  884|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 78);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  885|  4.97k|        if (t > 77)                                                                           \
  ------------------
  |  Branch (885:13): [Folded, False: 4.97k]
  ------------------
  886|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 77);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  887|  4.97k|        if (t > 76)                                                                           \
  ------------------
  |  Branch (887:13): [Folded, False: 4.97k]
  ------------------
  888|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 76);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  889|  4.97k|        if (t > 75)                                                                           \
  ------------------
  |  Branch (889:13): [Folded, False: 4.97k]
  ------------------
  890|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 75);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  891|  4.97k|        if (t > 74)                                                                           \
  ------------------
  |  Branch (891:13): [Folded, False: 4.97k]
  ------------------
  892|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 74);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  893|  4.97k|        if (t > 73)                                                                           \
  ------------------
  |  Branch (893:13): [Folded, False: 4.97k]
  ------------------
  894|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 73);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  895|  4.97k|        if (t > 72)                                                                           \
  ------------------
  |  Branch (895:13): [Folded, False: 4.97k]
  ------------------
  896|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 72);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  897|  4.97k|        if (t > 71)                                                                           \
  ------------------
  |  Branch (897:13): [Folded, False: 4.97k]
  ------------------
  898|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 71);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  899|  4.97k|        if (t > 70)                                                                           \
  ------------------
  |  Branch (899:13): [Folded, False: 4.97k]
  ------------------
  900|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 70);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  901|  4.97k|        if (t > 69)                                                                           \
  ------------------
  |  Branch (901:13): [Folded, False: 4.97k]
  ------------------
  902|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 69);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  903|  4.97k|        if (t > 68)                                                                           \
  ------------------
  |  Branch (903:13): [Folded, False: 4.97k]
  ------------------
  904|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 68);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  905|  4.97k|        if (t > 67)                                                                           \
  ------------------
  |  Branch (905:13): [Folded, False: 4.97k]
  ------------------
  906|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 67);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  907|  4.97k|        if (t > 66)                                                                           \
  ------------------
  |  Branch (907:13): [Folded, False: 4.97k]
  ------------------
  908|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 66);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  909|  4.97k|        if (t > 65)                                                                           \
  ------------------
  |  Branch (909:13): [Folded, False: 4.97k]
  ------------------
  910|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 65);                    \
  ------------------
  |  |  202|      0|    {                                                                  \
  |  |  203|      0|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|      0|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|      0|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|      0|    }
  ------------------
  911|  4.97k|        if (t > 64)                                                                           \
  ------------------
  |  Branch (911:13): [True: 4.97k, Folded]
  ------------------
  912|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 64);                    \
  ------------------
  |  |  202|  4.97k|    {                                                                  \
  |  |  203|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  4.97k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  4.97k|    }
  ------------------
  913|  4.97k|        if (t > 63)                                                                           \
  ------------------
  |  Branch (913:13): [True: 4.97k, Folded]
  ------------------
  914|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 63);                    \
  ------------------
  |  |  202|  4.97k|    {                                                                  \
  |  |  203|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  4.97k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  4.97k|    }
  ------------------
  915|  4.97k|        if (t > 62)                                                                           \
  ------------------
  |  Branch (915:13): [True: 4.97k, Folded]
  ------------------
  916|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 62);                    \
  ------------------
  |  |  202|  4.97k|    {                                                                  \
  |  |  203|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  4.97k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  4.97k|    }
  ------------------
  917|  4.97k|        if (t > 61)                                                                           \
  ------------------
  |  Branch (917:13): [True: 4.97k, Folded]
  ------------------
  918|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 61);                    \
  ------------------
  |  |  202|  4.97k|    {                                                                  \
  |  |  203|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  4.97k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  4.97k|    }
  ------------------
  919|  4.97k|        if (t > 60)                                                                           \
  ------------------
  |  Branch (919:13): [True: 4.97k, Folded]
  ------------------
  920|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 60);                    \
  ------------------
  |  |  202|  4.97k|    {                                                                  \
  |  |  203|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  4.97k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  4.97k|    }
  ------------------
  921|  4.97k|        if (t > 59)                                                                           \
  ------------------
  |  Branch (921:13): [True: 4.97k, Folded]
  ------------------
  922|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 59);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  923|  4.97k|        if (t > 58)                                                                           \
  ------------------
  |  Branch (923:13): [True: 4.97k, Folded]
  ------------------
  924|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 58);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  925|  4.97k|        if (t > 57)                                                                           \
  ------------------
  |  Branch (925:13): [True: 4.97k, Folded]
  ------------------
  926|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 57);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  927|  4.97k|        if (t > 56)                                                                           \
  ------------------
  |  Branch (927:13): [True: 4.97k, Folded]
  ------------------
  928|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 56);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  929|  4.97k|        if (t > 55)                                                                           \
  ------------------
  |  Branch (929:13): [True: 4.97k, Folded]
  ------------------
  930|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 55);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  931|  4.97k|        if (t > 54)                                                                           \
  ------------------
  |  Branch (931:13): [True: 4.97k, Folded]
  ------------------
  932|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 54);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  933|  4.97k|        if (t > 53)                                                                           \
  ------------------
  |  Branch (933:13): [True: 4.97k, Folded]
  ------------------
  934|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 53);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  935|  4.97k|        if (t > 52)                                                                           \
  ------------------
  |  Branch (935:13): [True: 4.97k, Folded]
  ------------------
  936|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 52);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  937|  4.97k|        if (t > 51)                                                                           \
  ------------------
  |  Branch (937:13): [True: 4.97k, Folded]
  ------------------
  938|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 51);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  939|  4.97k|        if (t > 50)                                                                           \
  ------------------
  |  Branch (939:13): [True: 4.97k, Folded]
  ------------------
  940|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 50);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  941|  4.97k|        if (t > 49)                                                                           \
  ------------------
  |  Branch (941:13): [True: 4.97k, Folded]
  ------------------
  942|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 49);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  943|  4.97k|        if (t > 48)                                                                           \
  ------------------
  |  Branch (943:13): [True: 4.97k, Folded]
  ------------------
  944|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 48);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  945|  4.97k|        if (t > 47)                                                                           \
  ------------------
  |  Branch (945:13): [True: 4.97k, Folded]
  ------------------
  946|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 47);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  947|  4.97k|        if (t > 46)                                                                           \
  ------------------
  |  Branch (947:13): [True: 4.97k, Folded]
  ------------------
  948|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 46);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  949|  4.97k|        if (t > 45)                                                                           \
  ------------------
  |  Branch (949:13): [True: 4.97k, Folded]
  ------------------
  950|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 45);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  951|  4.97k|        if (t > 44)                                                                           \
  ------------------
  |  Branch (951:13): [True: 4.97k, Folded]
  ------------------
  952|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 44);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  953|  4.97k|        if (t > 43)                                                                           \
  ------------------
  |  Branch (953:13): [True: 4.97k, Folded]
  ------------------
  954|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 43);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  955|  4.97k|        if (t > 42)                                                                           \
  ------------------
  |  Branch (955:13): [True: 4.97k, Folded]
  ------------------
  956|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 42);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  957|  4.97k|        if (t > 41)                                                                           \
  ------------------
  |  Branch (957:13): [True: 4.97k, Folded]
  ------------------
  958|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 41);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  959|  4.97k|        if (t > 40)                                                                           \
  ------------------
  |  Branch (959:13): [True: 4.97k, Folded]
  ------------------
  960|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 40);                    \
  ------------------
  |  |  197|  4.97k|    {                                                                  \
  |  |  198|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  4.97k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  4.97k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  4.97k|    }
  ------------------
  961|  4.97k|        if (t > 39)                                                                           \
  ------------------
  |  Branch (961:13): [True: 4.97k, Folded]
  ------------------
  962|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 39);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  963|  4.97k|        if (t > 38)                                                                           \
  ------------------
  |  Branch (963:13): [True: 4.97k, Folded]
  ------------------
  964|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 38);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  965|  4.97k|        if (t > 37)                                                                           \
  ------------------
  |  Branch (965:13): [True: 4.97k, Folded]
  ------------------
  966|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 37);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  967|  4.97k|        if (t > 36)                                                                           \
  ------------------
  |  Branch (967:13): [True: 4.97k, Folded]
  ------------------
  968|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 36);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  969|  4.97k|        if (t > 35)                                                                           \
  ------------------
  |  Branch (969:13): [True: 4.97k, Folded]
  ------------------
  970|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 35);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  971|  4.97k|        if (t > 34)                                                                           \
  ------------------
  |  Branch (971:13): [True: 4.97k, Folded]
  ------------------
  972|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 34);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  973|  4.97k|        if (t > 33)                                                                           \
  ------------------
  |  Branch (973:13): [True: 4.97k, Folded]
  ------------------
  974|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 33);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  975|  4.97k|        if (t > 32)                                                                           \
  ------------------
  |  Branch (975:13): [True: 4.97k, Folded]
  ------------------
  976|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 32);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  977|  4.97k|        if (t > 31)                                                                           \
  ------------------
  |  Branch (977:13): [True: 4.97k, Folded]
  ------------------
  978|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 31);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  979|  4.97k|        if (t > 30)                                                                           \
  ------------------
  |  Branch (979:13): [True: 4.97k, Folded]
  ------------------
  980|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 30);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  981|  4.97k|        if (t > 29)                                                                           \
  ------------------
  |  Branch (981:13): [True: 4.97k, Folded]
  ------------------
  982|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 29);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  983|  4.97k|        if (t > 28)                                                                           \
  ------------------
  |  Branch (983:13): [True: 4.97k, Folded]
  ------------------
  984|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 28);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  985|  4.97k|        if (t > 27)                                                                           \
  ------------------
  |  Branch (985:13): [True: 4.97k, Folded]
  ------------------
  986|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 27);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  987|  4.97k|        if (t > 26)                                                                           \
  ------------------
  |  Branch (987:13): [True: 4.97k, Folded]
  ------------------
  988|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 26);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  989|  4.97k|        if (t > 25)                                                                           \
  ------------------
  |  Branch (989:13): [True: 4.97k, Folded]
  ------------------
  990|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 25);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  991|  4.97k|        if (t > 24)                                                                           \
  ------------------
  |  Branch (991:13): [True: 4.97k, Folded]
  ------------------
  992|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 24);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  993|  4.97k|        if (t > 23)                                                                           \
  ------------------
  |  Branch (993:13): [True: 4.97k, Folded]
  ------------------
  994|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 23);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  995|  4.97k|        if (t > 22)                                                                           \
  ------------------
  |  Branch (995:13): [True: 4.97k, Folded]
  ------------------
  996|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 22);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  997|  4.97k|        if (t > 21)                                                                           \
  ------------------
  |  Branch (997:13): [True: 4.97k, Folded]
  ------------------
  998|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 21);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
  999|  4.97k|        if (t > 20)                                                                           \
  ------------------
  |  Branch (999:13): [True: 4.97k, Folded]
  ------------------
 1000|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 20);                    \
  ------------------
  |  |  192|  4.97k|    {                                                                  \
  |  |  193|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  4.97k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  4.97k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  4.97k|    }
  ------------------
 1001|  4.97k|        if (t > 19)                                                                           \
  ------------------
  |  Branch (1001:13): [True: 4.97k, Folded]
  ------------------
 1002|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 19);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1003|  4.97k|        if (t > 18)                                                                           \
  ------------------
  |  Branch (1003:13): [True: 4.97k, Folded]
  ------------------
 1004|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 18);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1005|  4.97k|        if (t > 17)                                                                           \
  ------------------
  |  Branch (1005:13): [True: 4.97k, Folded]
  ------------------
 1006|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 17);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1007|  4.97k|        if (t > 16)                                                                           \
  ------------------
  |  Branch (1007:13): [True: 4.97k, Folded]
  ------------------
 1008|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 16);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1009|  4.97k|        if (t > 15)                                                                           \
  ------------------
  |  Branch (1009:13): [True: 4.97k, Folded]
  ------------------
 1010|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 15);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1011|  4.97k|        if (t > 14)                                                                           \
  ------------------
  |  Branch (1011:13): [True: 4.97k, Folded]
  ------------------
 1012|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 14);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1013|  4.97k|        if (t > 13)                                                                           \
  ------------------
  |  Branch (1013:13): [True: 4.97k, Folded]
  ------------------
 1014|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 13);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1015|  4.97k|        if (t > 12)                                                                           \
  ------------------
  |  Branch (1015:13): [True: 4.97k, Folded]
  ------------------
 1016|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 12);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1017|  4.97k|        if (t > 11)                                                                           \
  ------------------
  |  Branch (1017:13): [True: 4.97k, Folded]
  ------------------
 1018|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 11);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1019|  4.97k|        if (t > 10)                                                                           \
  ------------------
  |  Branch (1019:13): [True: 4.97k, Folded]
  ------------------
 1020|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 10);                    \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1021|  4.97k|        if (t > 9)                                                                            \
  ------------------
  |  Branch (1021:13): [True: 4.97k, Folded]
  ------------------
 1022|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 9);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1023|  4.97k|        if (t > 8)                                                                            \
  ------------------
  |  Branch (1023:13): [True: 4.97k, Folded]
  ------------------
 1024|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 8);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1025|  4.97k|        if (t > 7)                                                                            \
  ------------------
  |  Branch (1025:13): [True: 4.97k, Folded]
  ------------------
 1026|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 7);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1027|  4.97k|        if (t > 6)                                                                            \
  ------------------
  |  Branch (1027:13): [True: 4.97k, Folded]
  ------------------
 1028|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 6);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1029|  4.97k|        if (t > 5)                                                                            \
  ------------------
  |  Branch (1029:13): [True: 4.97k, Folded]
  ------------------
 1030|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 5);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1031|  4.97k|        if (t > 4)                                                                            \
  ------------------
  |  Branch (1031:13): [True: 4.97k, Folded]
  ------------------
 1032|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 4);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1033|  4.97k|        if (t > 3)                                                                            \
  ------------------
  |  Branch (1033:13): [True: 4.97k, Folded]
  ------------------
 1034|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 3);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1035|  4.97k|        if (t > 2)                                                                            \
  ------------------
  |  Branch (1035:13): [True: 4.97k, Folded]
  ------------------
 1036|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 2);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1037|  4.97k|        if (t > 1)                                                                            \
  ------------------
  |  Branch (1037:13): [True: 4.97k, Folded]
  ------------------
 1038|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 1);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1039|  4.97k|        if (t > 0)                                                                            \
  ------------------
  |  Branch (1039:13): [True: 4.97k, Folded]
  ------------------
 1040|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 0);                     \
  ------------------
  |  |  187|  4.97k|    {                                                                  \
  |  |  188|  4.97k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  4.97k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  4.97k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  4.97k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  4.97k|    }
  ------------------
 1041|  4.97k|        ihvin[0] = a;                                                                         \
 1042|  4.97k|        ihvin[1] = b;                                                                         \
 1043|  4.97k|        ihvin[2] = c;                                                                         \
 1044|  4.97k|        ihvin[3] = d;                                                                         \
 1045|  4.97k|        ihvin[4] = e;                                                                         \
 1046|  4.97k|        a = state[0];                                                                         \
 1047|  4.97k|        b = state[1];                                                                         \
 1048|  4.97k|        c = state[2];                                                                         \
 1049|  4.97k|        d = state[3];                                                                         \
 1050|  4.97k|        e = state[4];                                                                         \
 1051|  4.97k|        if (t <= 0)                                                                           \
  ------------------
  |  Branch (1051:13): [Folded, False: 4.97k]
  ------------------
 1052|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 0);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1053|  4.97k|        if (t <= 1)                                                                           \
  ------------------
  |  Branch (1053:13): [Folded, False: 4.97k]
  ------------------
 1054|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 1);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1055|  4.97k|        if (t <= 2)                                                                           \
  ------------------
  |  Branch (1055:13): [Folded, False: 4.97k]
  ------------------
 1056|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 2);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1057|  4.97k|        if (t <= 3)                                                                           \
  ------------------
  |  Branch (1057:13): [Folded, False: 4.97k]
  ------------------
 1058|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 3);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1059|  4.97k|        if (t <= 4)                                                                           \
  ------------------
  |  Branch (1059:13): [Folded, False: 4.97k]
  ------------------
 1060|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 4);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1061|  4.97k|        if (t <= 5)                                                                           \
  ------------------
  |  Branch (1061:13): [Folded, False: 4.97k]
  ------------------
 1062|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 5);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1063|  4.97k|        if (t <= 6)                                                                           \
  ------------------
  |  Branch (1063:13): [Folded, False: 4.97k]
  ------------------
 1064|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 6);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1065|  4.97k|        if (t <= 7)                                                                           \
  ------------------
  |  Branch (1065:13): [Folded, False: 4.97k]
  ------------------
 1066|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 7);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1067|  4.97k|        if (t <= 8)                                                                           \
  ------------------
  |  Branch (1067:13): [Folded, False: 4.97k]
  ------------------
 1068|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 8);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1069|  4.97k|        if (t <= 9)                                                                           \
  ------------------
  |  Branch (1069:13): [Folded, False: 4.97k]
  ------------------
 1070|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 9);                        \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1071|  4.97k|        if (t <= 10)                                                                          \
  ------------------
  |  Branch (1071:13): [Folded, False: 4.97k]
  ------------------
 1072|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 10);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1073|  4.97k|        if (t <= 11)                                                                          \
  ------------------
  |  Branch (1073:13): [Folded, False: 4.97k]
  ------------------
 1074|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 11);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1075|  4.97k|        if (t <= 12)                                                                          \
  ------------------
  |  Branch (1075:13): [Folded, False: 4.97k]
  ------------------
 1076|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 12);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1077|  4.97k|        if (t <= 13)                                                                          \
  ------------------
  |  Branch (1077:13): [Folded, False: 4.97k]
  ------------------
 1078|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 13);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1079|  4.97k|        if (t <= 14)                                                                          \
  ------------------
  |  Branch (1079:13): [Folded, False: 4.97k]
  ------------------
 1080|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 14);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1081|  4.97k|        if (t <= 15)                                                                          \
  ------------------
  |  Branch (1081:13): [Folded, False: 4.97k]
  ------------------
 1082|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 15);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1083|  4.97k|        if (t <= 16)                                                                          \
  ------------------
  |  Branch (1083:13): [Folded, False: 4.97k]
  ------------------
 1084|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 16);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1085|  4.97k|        if (t <= 17)                                                                          \
  ------------------
  |  Branch (1085:13): [Folded, False: 4.97k]
  ------------------
 1086|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 17);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1087|  4.97k|        if (t <= 18)                                                                          \
  ------------------
  |  Branch (1087:13): [Folded, False: 4.97k]
  ------------------
 1088|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 18);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1089|  4.97k|        if (t <= 19)                                                                          \
  ------------------
  |  Branch (1089:13): [Folded, False: 4.97k]
  ------------------
 1090|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 19);                       \
  ------------------
  |  |  166|      0|    {                                                                  \
  |  |  167|      0|        e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|      0|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  168|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  169|      0|    }
  ------------------
 1091|  4.97k|        if (t <= 20)                                                                          \
  ------------------
  |  Branch (1091:13): [Folded, False: 4.97k]
  ------------------
 1092|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 20);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1093|  4.97k|        if (t <= 21)                                                                          \
  ------------------
  |  Branch (1093:13): [Folded, False: 4.97k]
  ------------------
 1094|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 21);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1095|  4.97k|        if (t <= 22)                                                                          \
  ------------------
  |  Branch (1095:13): [Folded, False: 4.97k]
  ------------------
 1096|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 22);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1097|  4.97k|        if (t <= 23)                                                                          \
  ------------------
  |  Branch (1097:13): [Folded, False: 4.97k]
  ------------------
 1098|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 23);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1099|  4.97k|        if (t <= 24)                                                                          \
  ------------------
  |  Branch (1099:13): [Folded, False: 4.97k]
  ------------------
 1100|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 24);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1101|  4.97k|        if (t <= 25)                                                                          \
  ------------------
  |  Branch (1101:13): [Folded, False: 4.97k]
  ------------------
 1102|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 25);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1103|  4.97k|        if (t <= 26)                                                                          \
  ------------------
  |  Branch (1103:13): [Folded, False: 4.97k]
  ------------------
 1104|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 26);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1105|  4.97k|        if (t <= 27)                                                                          \
  ------------------
  |  Branch (1105:13): [Folded, False: 4.97k]
  ------------------
 1106|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 27);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1107|  4.97k|        if (t <= 28)                                                                          \
  ------------------
  |  Branch (1107:13): [Folded, False: 4.97k]
  ------------------
 1108|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 28);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1109|  4.97k|        if (t <= 29)                                                                          \
  ------------------
  |  Branch (1109:13): [Folded, False: 4.97k]
  ------------------
 1110|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 29);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1111|  4.97k|        if (t <= 30)                                                                          \
  ------------------
  |  Branch (1111:13): [Folded, False: 4.97k]
  ------------------
 1112|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 30);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1113|  4.97k|        if (t <= 31)                                                                          \
  ------------------
  |  Branch (1113:13): [Folded, False: 4.97k]
  ------------------
 1114|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 31);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1115|  4.97k|        if (t <= 32)                                                                          \
  ------------------
  |  Branch (1115:13): [Folded, False: 4.97k]
  ------------------
 1116|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 32);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1117|  4.97k|        if (t <= 33)                                                                          \
  ------------------
  |  Branch (1117:13): [Folded, False: 4.97k]
  ------------------
 1118|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 33);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1119|  4.97k|        if (t <= 34)                                                                          \
  ------------------
  |  Branch (1119:13): [Folded, False: 4.97k]
  ------------------
 1120|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 34);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1121|  4.97k|        if (t <= 35)                                                                          \
  ------------------
  |  Branch (1121:13): [Folded, False: 4.97k]
  ------------------
 1122|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 35);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1123|  4.97k|        if (t <= 36)                                                                          \
  ------------------
  |  Branch (1123:13): [Folded, False: 4.97k]
  ------------------
 1124|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 36);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1125|  4.97k|        if (t <= 37)                                                                          \
  ------------------
  |  Branch (1125:13): [Folded, False: 4.97k]
  ------------------
 1126|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 37);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1127|  4.97k|        if (t <= 38)                                                                          \
  ------------------
  |  Branch (1127:13): [Folded, False: 4.97k]
  ------------------
 1128|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 38);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1129|  4.97k|        if (t <= 39)                                                                          \
  ------------------
  |  Branch (1129:13): [Folded, False: 4.97k]
  ------------------
 1130|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 39);                       \
  ------------------
  |  |  171|      0|    {                                                                  \
  |  |  172|      0|        e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|      0|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  173|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  174|      0|    }
  ------------------
 1131|  4.97k|        if (t <= 40)                                                                          \
  ------------------
  |  Branch (1131:13): [Folded, False: 4.97k]
  ------------------
 1132|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 40);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1133|  4.97k|        if (t <= 41)                                                                          \
  ------------------
  |  Branch (1133:13): [Folded, False: 4.97k]
  ------------------
 1134|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 41);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1135|  4.97k|        if (t <= 42)                                                                          \
  ------------------
  |  Branch (1135:13): [Folded, False: 4.97k]
  ------------------
 1136|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 42);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1137|  4.97k|        if (t <= 43)                                                                          \
  ------------------
  |  Branch (1137:13): [Folded, False: 4.97k]
  ------------------
 1138|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 43);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1139|  4.97k|        if (t <= 44)                                                                          \
  ------------------
  |  Branch (1139:13): [Folded, False: 4.97k]
  ------------------
 1140|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 44);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1141|  4.97k|        if (t <= 45)                                                                          \
  ------------------
  |  Branch (1141:13): [Folded, False: 4.97k]
  ------------------
 1142|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 45);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1143|  4.97k|        if (t <= 46)                                                                          \
  ------------------
  |  Branch (1143:13): [Folded, False: 4.97k]
  ------------------
 1144|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 46);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1145|  4.97k|        if (t <= 47)                                                                          \
  ------------------
  |  Branch (1145:13): [Folded, False: 4.97k]
  ------------------
 1146|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 47);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1147|  4.97k|        if (t <= 48)                                                                          \
  ------------------
  |  Branch (1147:13): [Folded, False: 4.97k]
  ------------------
 1148|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 48);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1149|  4.97k|        if (t <= 49)                                                                          \
  ------------------
  |  Branch (1149:13): [Folded, False: 4.97k]
  ------------------
 1150|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 49);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1151|  4.97k|        if (t <= 50)                                                                          \
  ------------------
  |  Branch (1151:13): [Folded, False: 4.97k]
  ------------------
 1152|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 50);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1153|  4.97k|        if (t <= 51)                                                                          \
  ------------------
  |  Branch (1153:13): [Folded, False: 4.97k]
  ------------------
 1154|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 51);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1155|  4.97k|        if (t <= 52)                                                                          \
  ------------------
  |  Branch (1155:13): [Folded, False: 4.97k]
  ------------------
 1156|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 52);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1157|  4.97k|        if (t <= 53)                                                                          \
  ------------------
  |  Branch (1157:13): [Folded, False: 4.97k]
  ------------------
 1158|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 53);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1159|  4.97k|        if (t <= 54)                                                                          \
  ------------------
  |  Branch (1159:13): [Folded, False: 4.97k]
  ------------------
 1160|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 54);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1161|  4.97k|        if (t <= 55)                                                                          \
  ------------------
  |  Branch (1161:13): [Folded, False: 4.97k]
  ------------------
 1162|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 55);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1163|  4.97k|        if (t <= 56)                                                                          \
  ------------------
  |  Branch (1163:13): [Folded, False: 4.97k]
  ------------------
 1164|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 56);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1165|  4.97k|        if (t <= 57)                                                                          \
  ------------------
  |  Branch (1165:13): [Folded, False: 4.97k]
  ------------------
 1166|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 57);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1167|  4.97k|        if (t <= 58)                                                                          \
  ------------------
  |  Branch (1167:13): [Folded, False: 4.97k]
  ------------------
 1168|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 58);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1169|  4.97k|        if (t <= 59)                                                                          \
  ------------------
  |  Branch (1169:13): [Folded, False: 4.97k]
  ------------------
 1170|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 59);                       \
  ------------------
  |  |  176|      0|    {                                                                  \
  |  |  177|      0|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|      0|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|      0|    }
  ------------------
 1171|  4.97k|        if (t <= 60)                                                                          \
  ------------------
  |  Branch (1171:13): [Folded, False: 4.97k]
  ------------------
 1172|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 60);                       \
  ------------------
  |  |  181|      0|    {                                                                  \
  |  |  182|      0|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|      0|    }
  ------------------
 1173|  4.97k|        if (t <= 61)                                                                          \
  ------------------
  |  Branch (1173:13): [Folded, False: 4.97k]
  ------------------
 1174|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 61);                       \
  ------------------
  |  |  181|      0|    {                                                                  \
  |  |  182|      0|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|      0|    }
  ------------------
 1175|  4.97k|        if (t <= 62)                                                                          \
  ------------------
  |  Branch (1175:13): [Folded, False: 4.97k]
  ------------------
 1176|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 62);                       \
  ------------------
  |  |  181|      0|    {                                                                  \
  |  |  182|      0|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|      0|    }
  ------------------
 1177|  4.97k|        if (t <= 63)                                                                          \
  ------------------
  |  Branch (1177:13): [Folded, False: 4.97k]
  ------------------
 1178|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 63);                       \
  ------------------
  |  |  181|      0|    {                                                                  \
  |  |  182|      0|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|      0|    }
  ------------------
 1179|  4.97k|        if (t <= 64)                                                                          \
  ------------------
  |  Branch (1179:13): [Folded, False: 4.97k]
  ------------------
 1180|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 64);                       \
  ------------------
  |  |  181|      0|    {                                                                  \
  |  |  182|      0|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|      0|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|      0|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|      0|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|      0|    }
  ------------------
 1181|  4.97k|        if (t <= 65)                                                                          \
  ------------------
  |  Branch (1181:13): [True: 4.97k, Folded]
  ------------------
 1182|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 65);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1183|  4.97k|        if (t <= 66)                                                                          \
  ------------------
  |  Branch (1183:13): [True: 4.97k, Folded]
  ------------------
 1184|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 66);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1185|  4.97k|        if (t <= 67)                                                                          \
  ------------------
  |  Branch (1185:13): [True: 4.97k, Folded]
  ------------------
 1186|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 67);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1187|  4.97k|        if (t <= 68)                                                                          \
  ------------------
  |  Branch (1187:13): [True: 4.97k, Folded]
  ------------------
 1188|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 68);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1189|  4.97k|        if (t <= 69)                                                                          \
  ------------------
  |  Branch (1189:13): [True: 4.97k, Folded]
  ------------------
 1190|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 69);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1191|  4.97k|        if (t <= 70)                                                                          \
  ------------------
  |  Branch (1191:13): [True: 4.97k, Folded]
  ------------------
 1192|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 70);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1193|  4.97k|        if (t <= 71)                                                                          \
  ------------------
  |  Branch (1193:13): [True: 4.97k, Folded]
  ------------------
 1194|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 71);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1195|  4.97k|        if (t <= 72)                                                                          \
  ------------------
  |  Branch (1195:13): [True: 4.97k, Folded]
  ------------------
 1196|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 72);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1197|  4.97k|        if (t <= 73)                                                                          \
  ------------------
  |  Branch (1197:13): [True: 4.97k, Folded]
  ------------------
 1198|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 73);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1199|  4.97k|        if (t <= 74)                                                                          \
  ------------------
  |  Branch (1199:13): [True: 4.97k, Folded]
  ------------------
 1200|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 74);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1201|  4.97k|        if (t <= 75)                                                                          \
  ------------------
  |  Branch (1201:13): [True: 4.97k, Folded]
  ------------------
 1202|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 75);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1203|  4.97k|        if (t <= 76)                                                                          \
  ------------------
  |  Branch (1203:13): [True: 4.97k, Folded]
  ------------------
 1204|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 76);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1205|  4.97k|        if (t <= 77)                                                                          \
  ------------------
  |  Branch (1205:13): [True: 4.97k, Folded]
  ------------------
 1206|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 77);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1207|  4.97k|        if (t <= 78)                                                                          \
  ------------------
  |  Branch (1207:13): [True: 4.97k, Folded]
  ------------------
 1208|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 78);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1209|  4.97k|        if (t <= 79)                                                                          \
  ------------------
  |  Branch (1209:13): [True: 4.97k, Folded]
  ------------------
 1210|  4.97k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 79);                       \
  ------------------
  |  |  181|  4.97k|    {                                                                  \
  |  |  182|  4.97k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  4.97k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  4.97k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  4.97k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  4.97k|    }
  ------------------
 1211|  4.97k|        ihvout[0] = ihvin[0] + a;                                                             \
 1212|  4.97k|        ihvout[1] = ihvin[1] + b;                                                             \
 1213|  4.97k|        ihvout[2] = ihvin[2] + c;                                                             \
 1214|  4.97k|        ihvout[3] = ihvin[3] + d;                                                             \
 1215|  4.97k|        ihvout[4] = ihvin[4] + e;                                                             \
 1216|  4.97k|    }

ubc_check:
  571|   206k|{
  572|   206k|    uint32_t mask = ~((uint32_t)(0));
  573|   206k|    mask &= (((((W[44] ^ W[45]) >> 29) & 1) - 1) |
  574|   206k|             ~(DV_I_48_0_bit | DV_I_51_0_bit | DV_I_52_0_bit | DV_II_45_0_bit |
  575|   206k|               DV_II_46_0_bit | DV_II_50_0_bit | DV_II_51_0_bit));
  576|   206k|    mask &= (((((W[49] ^ W[50]) >> 29) & 1) - 1) |
  577|   206k|             ~(DV_I_46_0_bit | DV_II_45_0_bit | DV_II_50_0_bit | DV_II_51_0_bit |
  578|   206k|               DV_II_55_0_bit | DV_II_56_0_bit));
  579|   206k|    mask &= (((((W[48] ^ W[49]) >> 29) & 1) - 1) |
  580|   206k|             ~(DV_I_45_0_bit | DV_I_52_0_bit | DV_II_49_0_bit | DV_II_50_0_bit |
  581|   206k|               DV_II_54_0_bit | DV_II_55_0_bit));
  582|   206k|    mask &= ((((W[47] ^ (W[50] >> 25)) & (1 << 4)) - (1 << 4)) |
  583|   206k|             ~(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit |
  584|   206k|               DV_II_51_0_bit | DV_II_56_0_bit));
  585|   206k|    mask &= (((((W[47] ^ W[48]) >> 29) & 1) - 1) |
  586|   206k|             ~(DV_I_44_0_bit | DV_I_51_0_bit | DV_II_48_0_bit | DV_II_49_0_bit |
  587|   206k|               DV_II_53_0_bit | DV_II_54_0_bit));
  588|   206k|    mask &= (((((W[46] >> 4) ^ (W[49] >> 29)) & 1) - 1) |
  589|   206k|             ~(DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit | DV_II_50_0_bit |
  590|   206k|               DV_II_55_0_bit));
  591|   206k|    mask &= (((((W[46] ^ W[47]) >> 29) & 1) - 1) |
  592|   206k|             ~(DV_I_43_0_bit | DV_I_50_0_bit | DV_II_47_0_bit | DV_II_48_0_bit |
  593|   206k|               DV_II_52_0_bit | DV_II_53_0_bit));
  594|   206k|    mask &= (((((W[45] >> 4) ^ (W[48] >> 29)) & 1) - 1) |
  595|   206k|             ~(DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit | DV_II_49_0_bit |
  596|   206k|               DV_II_54_0_bit));
  597|   206k|    mask &= (((((W[45] ^ W[46]) >> 29) & 1) - 1) |
  598|   206k|             ~(DV_I_49_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_47_0_bit |
  599|   206k|               DV_II_51_0_bit | DV_II_52_0_bit));
  600|   206k|    mask &= (((((W[44] >> 4) ^ (W[47] >> 29)) & 1) - 1) |
  601|   206k|             ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit | DV_II_48_0_bit |
  602|   206k|               DV_II_53_0_bit));
  603|   206k|    mask &= (((((W[43] >> 4) ^ (W[46] >> 29)) & 1) - 1) |
  604|   206k|             ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit | DV_II_47_0_bit |
  605|   206k|               DV_II_52_0_bit));
  606|   206k|    mask &= (((((W[43] ^ W[44]) >> 29) & 1) - 1) |
  607|   206k|             ~(DV_I_47_0_bit | DV_I_50_0_bit | DV_I_51_0_bit | DV_II_45_0_bit |
  608|   206k|               DV_II_49_0_bit | DV_II_50_0_bit));
  609|   206k|    mask &= (((((W[42] >> 4) ^ (W[45] >> 29)) & 1) - 1) |
  610|   206k|             ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit | DV_I_52_0_bit | DV_II_46_0_bit |
  611|   206k|               DV_II_51_0_bit));
  612|   206k|    mask &= (((((W[41] >> 4) ^ (W[44] >> 29)) & 1) - 1) |
  613|   206k|             ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit | DV_I_51_0_bit | DV_II_45_0_bit |
  614|   206k|               DV_II_50_0_bit));
  615|   206k|    mask &= (((((W[40] ^ W[41]) >> 29) & 1) - 1) |
  616|   206k|             ~(DV_I_44_0_bit | DV_I_47_0_bit | DV_I_48_0_bit | DV_II_46_0_bit |
  617|   206k|               DV_II_47_0_bit | DV_II_56_0_bit));
  618|   206k|    mask &=
  619|   206k|      (((((W[54] ^ W[55]) >> 29) & 1) - 1) |
  620|   206k|       ~(DV_I_51_0_bit | DV_II_47_0_bit | DV_II_50_0_bit | DV_II_55_0_bit | DV_II_56_0_bit));
  621|   206k|    mask &=
  622|   206k|      (((((W[53] ^ W[54]) >> 29) & 1) - 1) |
  623|   206k|       ~(DV_I_50_0_bit | DV_II_46_0_bit | DV_II_49_0_bit | DV_II_54_0_bit | DV_II_55_0_bit));
  624|   206k|    mask &=
  625|   206k|      (((((W[52] ^ W[53]) >> 29) & 1) - 1) |
  626|   206k|       ~(DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit | DV_II_53_0_bit | DV_II_54_0_bit));
  627|   206k|    mask &=
  628|   206k|      ((((W[50] ^ (W[53] >> 25)) & (1 << 4)) - (1 << 4)) |
  629|   206k|       ~(DV_I_50_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_48_0_bit | DV_II_54_0_bit));
  630|   206k|    mask &=
  631|   206k|      (((((W[50] ^ W[51]) >> 29) & 1) - 1) |
  632|   206k|       ~(DV_I_47_0_bit | DV_II_46_0_bit | DV_II_51_0_bit | DV_II_52_0_bit | DV_II_56_0_bit));
  633|   206k|    mask &=
  634|   206k|      ((((W[49] ^ (W[52] >> 25)) & (1 << 4)) - (1 << 4)) |
  635|   206k|       ~(DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit | DV_II_47_0_bit | DV_II_53_0_bit));
  636|   206k|    mask &=
  637|   206k|      ((((W[48] ^ (W[51] >> 25)) & (1 << 4)) - (1 << 4)) |
  638|   206k|       ~(DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_52_0_bit));
  639|   206k|    mask &=
  640|   206k|      (((((W[42] ^ W[43]) >> 29) & 1) - 1) |
  641|   206k|       ~(DV_I_46_0_bit | DV_I_49_0_bit | DV_I_50_0_bit | DV_II_48_0_bit | DV_II_49_0_bit));
  642|   206k|    mask &=
  643|   206k|      (((((W[41] ^ W[42]) >> 29) & 1) - 1) |
  644|   206k|       ~(DV_I_45_0_bit | DV_I_48_0_bit | DV_I_49_0_bit | DV_II_47_0_bit | DV_II_48_0_bit));
  645|   206k|    mask &=
  646|   206k|      (((((W[40] >> 4) ^ (W[43] >> 29)) & 1) - 1) |
  647|   206k|       ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_50_0_bit | DV_II_49_0_bit | DV_II_56_0_bit));
  648|   206k|    mask &=
  649|   206k|      (((((W[39] >> 4) ^ (W[42] >> 29)) & 1) - 1) |
  650|   206k|       ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_49_0_bit | DV_II_48_0_bit | DV_II_55_0_bit));
  651|   206k|    if (mask &
  ------------------
  |  Branch (651:9): [True: 17.5k, False: 188k]
  ------------------
  652|   206k|        (DV_I_44_0_bit | DV_I_48_0_bit | DV_II_47_0_bit | DV_II_54_0_bit | DV_II_56_0_bit))
  653|  17.5k|        mask &= (((((W[38] >> 4) ^ (W[41] >> 29)) & 1) - 1) |
  654|  17.5k|                 ~(DV_I_44_0_bit | DV_I_48_0_bit | DV_II_47_0_bit | DV_II_54_0_bit |
  655|  17.5k|                   DV_II_56_0_bit));
  656|   206k|    mask &=
  657|   206k|      (((((W[37] >> 4) ^ (W[40] >> 29)) & 1) - 1) |
  658|   206k|       ~(DV_I_43_0_bit | DV_I_47_0_bit | DV_II_46_0_bit | DV_II_53_0_bit | DV_II_55_0_bit));
  659|   206k|    if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_51_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (659:9): [True: 10.9k, False: 195k]
  ------------------
  660|  10.9k|        mask &= (((((W[55] ^ W[56]) >> 29) & 1) - 1) |
  661|  10.9k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_51_0_bit | DV_II_56_0_bit));
  662|   206k|    if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_50_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (662:9): [True: 8.82k, False: 197k]
  ------------------
  663|  8.82k|        mask &= ((((W[52] ^ (W[55] >> 25)) & (1 << 4)) - (1 << 4)) |
  664|  8.82k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_50_0_bit | DV_II_56_0_bit));
  665|   206k|    if (mask & (DV_I_51_0_bit | DV_II_47_0_bit | DV_II_49_0_bit | DV_II_55_0_bit))
  ------------------
  |  Branch (665:9): [True: 8.34k, False: 197k]
  ------------------
  666|  8.34k|        mask &= ((((W[51] ^ (W[54] >> 25)) & (1 << 4)) - (1 << 4)) |
  667|  8.34k|                 ~(DV_I_51_0_bit | DV_II_47_0_bit | DV_II_49_0_bit | DV_II_55_0_bit));
  668|   206k|    if (mask & (DV_I_48_0_bit | DV_II_47_0_bit | DV_II_52_0_bit | DV_II_53_0_bit))
  ------------------
  |  Branch (668:9): [True: 11.2k, False: 195k]
  ------------------
  669|  11.2k|        mask &= (((((W[51] ^ W[52]) >> 29) & 1) - 1) |
  670|  11.2k|                 ~(DV_I_48_0_bit | DV_II_47_0_bit | DV_II_52_0_bit | DV_II_53_0_bit));
  671|   206k|    if (mask & (DV_I_46_0_bit | DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit))
  ------------------
  |  Branch (671:9): [True: 7.18k, False: 199k]
  ------------------
  672|  7.18k|        mask &= (((((W[36] >> 4) ^ (W[40] >> 29)) & 1) - 1) |
  673|  7.18k|                 ~(DV_I_46_0_bit | DV_I_49_0_bit | DV_II_45_0_bit | DV_II_48_0_bit));
  674|   206k|    if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit))
  ------------------
  |  Branch (674:9): [True: 4.72k, False: 201k]
  ------------------
  675|  4.72k|        mask &= ((0 - (((W[53] ^ W[56]) >> 29) & 1)) |
  676|  4.72k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit));
  677|   206k|    if (mask & (DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (677:9): [True: 5.26k, False: 201k]
  ------------------
  678|  5.26k|        mask &= ((0 - (((W[51] ^ W[54]) >> 29) & 1)) |
  679|  5.26k|                 ~(DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit));
  680|   206k|    if (mask & (DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (680:9): [True: 3.53k, False: 202k]
  ------------------
  681|  3.53k|        mask &= ((0 - (((W[50] ^ W[52]) >> 29) & 1)) |
  682|  3.53k|                 ~(DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit));
  683|   206k|    if (mask & (DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit))
  ------------------
  |  Branch (683:9): [True: 4.92k, False: 201k]
  ------------------
  684|  4.92k|        mask &= ((0 - (((W[49] ^ W[51]) >> 29) & 1)) |
  685|  4.92k|                 ~(DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit));
  686|   206k|    if (mask & (DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit))
  ------------------
  |  Branch (686:9): [True: 2.54k, False: 203k]
  ------------------
  687|  2.54k|        mask &= ((0 - (((W[48] ^ W[50]) >> 29) & 1)) |
  688|  2.54k|                 ~(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit));
  689|   206k|    if (mask & (DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit))
  ------------------
  |  Branch (689:9): [True: 2.75k, False: 203k]
  ------------------
  690|  2.75k|        mask &= ((0 - (((W[47] ^ W[49]) >> 29) & 1)) |
  691|  2.75k|                 ~(DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit));
  692|   206k|    if (mask & (DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit))
  ------------------
  |  Branch (692:9): [True: 11.7k, False: 194k]
  ------------------
  693|  11.7k|        mask &= ((0 - (((W[46] ^ W[48]) >> 29) & 1)) |
  694|  11.7k|                 ~(DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit));
  695|   206k|    mask &= ((((W[45] ^ W[47]) & (1 << 6)) - (1 << 6)) |
  696|   206k|             ~(DV_I_47_2_bit | DV_I_49_2_bit | DV_I_51_2_bit));
  697|   206k|    if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit))
  ------------------
  |  Branch (697:9): [True: 5.98k, False: 200k]
  ------------------
  698|  5.98k|        mask &= ((0 - (((W[45] ^ W[47]) >> 29) & 1)) |
  699|  5.98k|                 ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit));
  700|   206k|    mask &=
  701|   206k|      (((((W[44] ^ W[46]) >> 6) & 1) - 1) | ~(DV_I_46_2_bit | DV_I_48_2_bit | DV_I_50_2_bit));
  702|   206k|    if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit))
  ------------------
  |  Branch (702:9): [True: 9.98k, False: 196k]
  ------------------
  703|  9.98k|        mask &= ((0 - (((W[44] ^ W[46]) >> 29) & 1)) |
  704|  9.98k|                 ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit));
  705|   206k|    mask &= ((0 - ((W[41] ^ (W[42] >> 5)) & (1 << 1))) |
  706|   206k|             ~(DV_I_48_2_bit | DV_II_46_2_bit | DV_II_51_2_bit));
  707|   206k|    mask &= ((0 - ((W[40] ^ (W[41] >> 5)) & (1 << 1))) |
  708|   206k|             ~(DV_I_47_2_bit | DV_I_51_2_bit | DV_II_50_2_bit));
  709|   206k|    if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (709:9): [True: 4.27k, False: 202k]
  ------------------
  710|  4.27k|        mask &= ((0 - (((W[40] ^ W[42]) >> 4) & 1)) |
  711|  4.27k|                 ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit));
  712|   206k|    mask &= ((0 - ((W[39] ^ (W[40] >> 5)) & (1 << 1))) |
  713|   206k|             ~(DV_I_46_2_bit | DV_I_50_2_bit | DV_II_49_2_bit));
  714|   206k|    if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit))
  ------------------
  |  Branch (714:9): [True: 7.88k, False: 198k]
  ------------------
  715|  7.88k|        mask &= ((0 - (((W[39] ^ W[41]) >> 4) & 1)) |
  716|  7.88k|                 ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit));
  717|   206k|    if (mask & (DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (717:9): [True: 5.47k, False: 200k]
  ------------------
  718|  5.47k|        mask &= ((0 - (((W[38] ^ W[40]) >> 4) & 1)) |
  719|  5.47k|                 ~(DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit));
  720|   206k|    if (mask & (DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit))
  ------------------
  |  Branch (720:9): [True: 6.09k, False: 200k]
  ------------------
  721|  6.09k|        mask &= ((0 - (((W[37] ^ W[39]) >> 4) & 1)) |
  722|  6.09k|                 ~(DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit));
  723|   206k|    mask &= ((0 - ((W[36] ^ (W[37] >> 5)) & (1 << 1))) |
  724|   206k|             ~(DV_I_47_2_bit | DV_I_50_2_bit | DV_II_46_2_bit));
  725|   206k|    if (mask & (DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (725:9): [True: 1.50k, False: 204k]
  ------------------
  726|  1.50k|        mask &= (((((W[35] >> 4) ^ (W[39] >> 29)) & 1) - 1) |
  727|  1.50k|                 ~(DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit));
  728|   206k|    if (mask & (DV_I_48_0_bit | DV_II_48_0_bit))
  ------------------
  |  Branch (728:9): [True: 997, False: 205k]
  ------------------
  729|    997|        mask &=
  730|    997|          ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 0))) | ~(DV_I_48_0_bit | DV_II_48_0_bit));
  731|   206k|    if (mask & (DV_I_45_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (731:9): [True: 1.87k, False: 204k]
  ------------------
  732|  1.87k|        mask &=
  733|  1.87k|          ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 1))) | ~(DV_I_45_0_bit | DV_II_45_0_bit));
  734|   206k|    if (mask & (DV_I_47_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (734:9): [True: 759, False: 205k]
  ------------------
  735|    759|        mask &=
  736|    759|          ((0 - ((W[62] ^ (W[63] >> 5)) & (1 << 0))) | ~(DV_I_47_0_bit | DV_II_47_0_bit));
  737|   206k|    if (mask & (DV_I_46_0_bit | DV_II_46_0_bit))
  ------------------
  |  Branch (737:9): [True: 747, False: 205k]
  ------------------
  738|    747|        mask &=
  739|    747|          ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 0))) | ~(DV_I_46_0_bit | DV_II_46_0_bit));
  740|   206k|    mask &= ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 2))) | ~(DV_I_46_2_bit | DV_II_46_2_bit));
  741|   206k|    if (mask & (DV_I_45_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (741:9): [True: 646, False: 205k]
  ------------------
  742|    646|        mask &=
  743|    646|          ((0 - ((W[60] ^ (W[61] >> 5)) & (1 << 0))) | ~(DV_I_45_0_bit | DV_II_45_0_bit));
  744|   206k|    if (mask & (DV_II_51_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (744:9): [True: 4.65k, False: 201k]
  ------------------
  745|  4.65k|        mask &= (((((W[58] ^ W[59]) >> 29) & 1) - 1) | ~(DV_II_51_0_bit | DV_II_54_0_bit));
  746|   206k|    if (mask & (DV_II_50_0_bit | DV_II_53_0_bit))
  ------------------
  |  Branch (746:9): [True: 4.20k, False: 202k]
  ------------------
  747|  4.20k|        mask &= (((((W[57] ^ W[58]) >> 29) & 1) - 1) | ~(DV_II_50_0_bit | DV_II_53_0_bit));
  748|   206k|    if (mask & (DV_II_52_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (748:9): [True: 6.67k, False: 199k]
  ------------------
  749|  6.67k|        mask &= ((((W[56] ^ (W[59] >> 25)) & (1 << 4)) - (1 << 4)) |
  750|  6.67k|                 ~(DV_II_52_0_bit | DV_II_54_0_bit));
  751|   206k|    if (mask & (DV_II_51_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (751:9): [True: 4.53k, False: 201k]
  ------------------
  752|  4.53k|        mask &= ((0 - (((W[56] ^ W[59]) >> 29) & 1)) | ~(DV_II_51_0_bit | DV_II_52_0_bit));
  753|   206k|    if (mask & (DV_II_49_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (753:9): [True: 3.26k, False: 203k]
  ------------------
  754|  3.26k|        mask &= (((((W[56] ^ W[57]) >> 29) & 1) - 1) | ~(DV_II_49_0_bit | DV_II_52_0_bit));
  755|   206k|    if (mask & (DV_II_51_0_bit | DV_II_53_0_bit))
  ------------------
  |  Branch (755:9): [True: 2.24k, False: 204k]
  ------------------
  756|  2.24k|        mask &= ((((W[55] ^ (W[58] >> 25)) & (1 << 4)) - (1 << 4)) |
  757|  2.24k|                 ~(DV_II_51_0_bit | DV_II_53_0_bit));
  758|   206k|    if (mask & (DV_II_50_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (758:9): [True: 4.29k, False: 202k]
  ------------------
  759|  4.29k|        mask &= ((((W[54] ^ (W[57] >> 25)) & (1 << 4)) - (1 << 4)) |
  760|  4.29k|                 ~(DV_II_50_0_bit | DV_II_52_0_bit));
  761|   206k|    if (mask & (DV_II_49_0_bit | DV_II_51_0_bit))
  ------------------
  |  Branch (761:9): [True: 1.71k, False: 204k]
  ------------------
  762|  1.71k|        mask &= ((((W[53] ^ (W[56] >> 25)) & (1 << 4)) - (1 << 4)) |
  763|  1.71k|                 ~(DV_II_49_0_bit | DV_II_51_0_bit));
  764|   206k|    mask &=
  765|   206k|      ((((W[51] ^ (W[50] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_50_2_bit | DV_II_46_2_bit));
  766|   206k|    mask &= ((((W[48] ^ W[50]) & (1 << 6)) - (1 << 6)) | ~(DV_I_50_2_bit | DV_II_46_2_bit));
  767|   206k|    if (mask & (DV_I_51_0_bit | DV_I_52_0_bit))
  ------------------
  |  Branch (767:9): [True: 938, False: 205k]
  ------------------
  768|    938|        mask &= ((0 - (((W[48] ^ W[55]) >> 29) & 1)) | ~(DV_I_51_0_bit | DV_I_52_0_bit));
  769|   206k|    mask &= ((((W[47] ^ W[49]) & (1 << 6)) - (1 << 6)) | ~(DV_I_49_2_bit | DV_I_51_2_bit));
  770|   206k|    mask &=
  771|   206k|      ((((W[48] ^ (W[47] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_47_2_bit | DV_II_51_2_bit));
  772|   206k|    mask &= ((((W[46] ^ W[48]) & (1 << 6)) - (1 << 6)) | ~(DV_I_48_2_bit | DV_I_50_2_bit));
  773|   206k|    mask &=
  774|   206k|      ((((W[47] ^ (W[46] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_46_2_bit | DV_II_50_2_bit));
  775|   206k|    mask &= ((0 - ((W[44] ^ (W[45] >> 5)) & (1 << 1))) | ~(DV_I_51_2_bit | DV_II_49_2_bit));
  776|   206k|    mask &= ((((W[43] ^ W[45]) & (1 << 6)) - (1 << 6)) | ~(DV_I_47_2_bit | DV_I_49_2_bit));
  777|   206k|    mask &= (((((W[42] ^ W[44]) >> 6) & 1) - 1) | ~(DV_I_46_2_bit | DV_I_48_2_bit));
  778|   206k|    mask &=
  779|   206k|      ((((W[43] ^ (W[42] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_II_46_2_bit | DV_II_51_2_bit));
  780|   206k|    mask &=
  781|   206k|      ((((W[42] ^ (W[41] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_51_2_bit | DV_II_50_2_bit));
  782|   206k|    mask &=
  783|   206k|      ((((W[41] ^ (W[40] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_50_2_bit | DV_II_49_2_bit));
  784|   206k|    if (mask & (DV_I_52_0_bit | DV_II_51_0_bit))
  ------------------
  |  Branch (784:9): [True: 1.21k, False: 205k]
  ------------------
  785|  1.21k|        mask &= ((((W[39] ^ (W[43] >> 25)) & (1 << 4)) - (1 << 4)) |
  786|  1.21k|                 ~(DV_I_52_0_bit | DV_II_51_0_bit));
  787|   206k|    if (mask & (DV_I_51_0_bit | DV_II_50_0_bit))
  ------------------
  |  Branch (787:9): [True: 2.62k, False: 203k]
  ------------------
  788|  2.62k|        mask &= ((((W[38] ^ (W[42] >> 25)) & (1 << 4)) - (1 << 4)) |
  789|  2.62k|                 ~(DV_I_51_0_bit | DV_II_50_0_bit));
  790|   206k|    if (mask & (DV_I_48_2_bit | DV_I_51_2_bit))
  ------------------
  |  Branch (790:9): [True: 18.4k, False: 187k]
  ------------------
  791|  18.4k|        mask &= ((0 - ((W[37] ^ (W[38] >> 5)) & (1 << 1))) | ~(DV_I_48_2_bit | DV_I_51_2_bit));
  792|   206k|    if (mask & (DV_I_50_0_bit | DV_II_49_0_bit))
  ------------------
  |  Branch (792:9): [True: 1.04k, False: 205k]
  ------------------
  793|  1.04k|        mask &= ((((W[37] ^ (W[41] >> 25)) & (1 << 4)) - (1 << 4)) |
  794|  1.04k|                 ~(DV_I_50_0_bit | DV_II_49_0_bit));
  795|   206k|    if (mask & (DV_II_52_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (795:9): [True: 2.79k, False: 203k]
  ------------------
  796|  2.79k|        mask &= ((0 - ((W[36] ^ W[38]) & (1 << 4))) | ~(DV_II_52_0_bit | DV_II_54_0_bit));
  797|   206k|    mask &= ((0 - ((W[35] ^ (W[36] >> 5)) & (1 << 1))) | ~(DV_I_46_2_bit | DV_I_49_2_bit));
  798|   206k|    if (mask & (DV_I_51_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (798:9): [True: 405, False: 205k]
  ------------------
  799|    405|        mask &= ((((W[35] ^ (W[39] >> 25)) & (1 << 3)) - (1 << 3)) |
  800|    405|                 ~(DV_I_51_0_bit | DV_II_47_0_bit));
  801|   206k|    if (mask) {
  ------------------
  |  Branch (801:9): [True: 93.3k, False: 112k]
  ------------------
  802|  93.3k|        if (mask & DV_I_43_0_bit)
  ------------------
  |  Branch (802:13): [True: 1.95k, False: 91.4k]
  ------------------
  803|  1.95k|            if (!((W[61] ^ (W[62] >> 5)) & (1 << 1)) ||
  ------------------
  |  Branch (803:17): [True: 1.00k, False: 946]
  ------------------
  804|    946|                !(!((W[59] ^ (W[63] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (804:17): [True: 279, False: 667]
  ------------------
  805|    667|                !((W[58] ^ (W[63] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (805:17): [True: 271, False: 396]
  ------------------
  806|  1.55k|                mask &= ~DV_I_43_0_bit;
  807|  93.3k|        if (mask & DV_I_44_0_bit)
  ------------------
  |  Branch (807:13): [True: 1.58k, False: 91.8k]
  ------------------
  808|  1.58k|            if (!((W[62] ^ (W[63] >> 5)) & (1 << 1)) ||
  ------------------
  |  Branch (808:17): [True: 613, False: 974]
  ------------------
  809|    974|                !(!((W[60] ^ (W[64] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (809:17): [True: 334, False: 640]
  ------------------
  810|    640|                !((W[59] ^ (W[64] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (810:17): [True: 265, False: 375]
  ------------------
  811|  1.21k|                mask &= ~DV_I_44_0_bit;
  812|  93.3k|        if (mask & DV_I_46_2_bit)
  ------------------
  |  Branch (812:13): [True: 6.37k, False: 87.0k]
  ------------------
  813|  6.37k|            mask &= ((~((W[40] ^ W[42]) >> 2)) | ~DV_I_46_2_bit);
  814|  93.3k|        if (mask & DV_I_47_2_bit)
  ------------------
  |  Branch (814:13): [True: 8.10k, False: 85.2k]
  ------------------
  815|  8.10k|            if (!((W[62] ^ (W[63] >> 5)) & (1 << 2)) || !(!((W[41] ^ W[43]) & (1 << 6))))
  ------------------
  |  Branch (815:17): [True: 1.79k, False: 6.31k]
  |  Branch (815:57): [True: 4.68k, False: 1.62k]
  ------------------
  816|  6.48k|                mask &= ~DV_I_47_2_bit;
  817|  93.3k|        if (mask & DV_I_48_2_bit)
  ------------------
  |  Branch (817:13): [True: 7.48k, False: 85.9k]
  ------------------
  818|  7.48k|            if (!((W[63] ^ (W[64] >> 5)) & (1 << 2)) ||
  ------------------
  |  Branch (818:17): [True: 5.08k, False: 2.39k]
  ------------------
  819|  2.39k|                !(!((W[48] ^ (W[49] << 5)) & (1 << 6))))
  ------------------
  |  Branch (819:17): [True: 1.16k, False: 1.23k]
  ------------------
  820|  6.24k|                mask &= ~DV_I_48_2_bit;
  821|  93.3k|        if (mask & DV_I_49_2_bit)
  ------------------
  |  Branch (821:13): [True: 14.6k, False: 78.7k]
  ------------------
  822|  14.6k|            if (!(!((W[49] ^ (W[50] << 5)) & (1 << 6))) || !((W[42] ^ W[50]) & (1 << 1)) ||
  ------------------
  |  Branch (822:17): [True: 4.32k, False: 10.3k]
  |  Branch (822:60): [True: 3.63k, False: 6.69k]
  ------------------
  823|  6.69k|                !(!((W[39] ^ (W[40] << 5)) & (1 << 6))) || !((W[38] ^ W[40]) & (1 << 1)))
  ------------------
  |  Branch (823:17): [True: 5.57k, False: 1.12k]
  |  Branch (823:60): [True: 786, False: 338]
  ------------------
  824|  14.3k|                mask &= ~DV_I_49_2_bit;
  825|  93.3k|        if (mask & DV_I_50_0_bit)
  ------------------
  |  Branch (825:13): [True: 270, False: 93.1k]
  ------------------
  826|    270|            mask &= ((((W[36] ^ W[37]) << 7)) | ~DV_I_50_0_bit);
  827|  93.3k|        if (mask & DV_I_50_2_bit)
  ------------------
  |  Branch (827:13): [True: 1.94k, False: 91.4k]
  ------------------
  828|  1.94k|            mask &= ((((W[43] ^ W[51]) << 11)) | ~DV_I_50_2_bit);
  829|  93.3k|        if (mask & DV_I_51_0_bit)
  ------------------
  |  Branch (829:13): [True: 216, False: 93.1k]
  ------------------
  830|    216|            mask &= ((((W[37] ^ W[38]) << 9)) | ~DV_I_51_0_bit);
  831|  93.3k|        if (mask & DV_I_51_2_bit)
  ------------------
  |  Branch (831:13): [True: 3.37k, False: 90.0k]
  ------------------
  832|  3.37k|            if (!(!((W[51] ^ (W[52] << 5)) & (1 << 6))) || !(!((W[49] ^ W[51]) & (1 << 6))) ||
  ------------------
  |  Branch (832:17): [True: 1.16k, False: 2.21k]
  |  Branch (832:60): [True: 504, False: 1.70k]
  ------------------
  833|  1.70k|                !(!((W[37] ^ (W[37] >> 5)) & (1 << 1))) ||
  ------------------
  |  Branch (833:17): [True: 558, False: 1.15k]
  ------------------
  834|  1.15k|                !(!((W[35] ^ (W[39] >> 25)) & (1 << 5))))
  ------------------
  |  Branch (834:17): [True: 776, False: 374]
  ------------------
  835|  2.99k|                mask &= ~DV_I_51_2_bit;
  836|  93.3k|        if (mask & DV_I_52_0_bit)
  ------------------
  |  Branch (836:13): [True: 325, False: 93.0k]
  ------------------
  837|    325|            mask &= ((((W[38] ^ W[39]) << 11)) | ~DV_I_52_0_bit);
  838|  93.3k|        if (mask & DV_II_46_2_bit)
  ------------------
  |  Branch (838:13): [True: 3.32k, False: 90.0k]
  ------------------
  839|  3.32k|            mask &= ((((W[47] ^ W[51]) << 17)) | ~DV_II_46_2_bit);
  840|  93.3k|        if (mask & DV_II_48_0_bit)
  ------------------
  |  Branch (840:13): [True: 680, False: 92.7k]
  ------------------
  841|    680|            if (!(!((W[36] ^ (W[40] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (841:17): [True: 224, False: 456]
  ------------------
  842|    456|                !((W[35] ^ (W[40] << 2)) & (1 << 30)))
  ------------------
  |  Branch (842:17): [True: 236, False: 220]
  ------------------
  843|    460|                mask &= ~DV_II_48_0_bit;
  844|  93.3k|        if (mask & DV_II_49_0_bit)
  ------------------
  |  Branch (844:13): [True: 687, False: 92.7k]
  ------------------
  845|    687|            if (!(!((W[37] ^ (W[41] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (845:17): [True: 226, False: 461]
  ------------------
  846|    461|                !((W[36] ^ (W[41] << 2)) & (1 << 30)))
  ------------------
  |  Branch (846:17): [True: 219, False: 242]
  ------------------
  847|    445|                mask &= ~DV_II_49_0_bit;
  848|  93.3k|        if (mask & DV_II_49_2_bit)
  ------------------
  |  Branch (848:13): [True: 29.7k, False: 63.6k]
  ------------------
  849|  29.7k|            if (!(!((W[53] ^ (W[54] << 5)) & (1 << 6))) || !(!((W[51] ^ W[53]) & (1 << 6))) ||
  ------------------
  |  Branch (849:17): [True: 8.43k, False: 21.3k]
  |  Branch (849:60): [True: 7.70k, False: 13.6k]
  ------------------
  850|  13.6k|                !((W[50] ^ W[54]) & (1 << 1)) || !(!((W[45] ^ (W[46] << 5)) & (1 << 6))) ||
  ------------------
  |  Branch (850:17): [True: 7.80k, False: 5.80k]
  |  Branch (850:50): [True: 2.37k, False: 3.43k]
  ------------------
  851|  3.43k|                !(!((W[37] ^ (W[41] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (851:17): [True: 1.84k, False: 1.58k]
  ------------------
  852|  1.58k|                !((W[36] ^ (W[41] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (852:17): [True: 403, False: 1.18k]
  ------------------
  853|  28.5k|                mask &= ~DV_II_49_2_bit;
  854|  93.3k|        if (mask & DV_II_50_0_bit)
  ------------------
  |  Branch (854:13): [True: 2.34k, False: 91.0k]
  ------------------
  855|  2.34k|            if (!((W[55] ^ W[58]) & (1 << 29)) || !(!((W[38] ^ (W[42] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (855:17): [True: 1.17k, False: 1.17k]
  |  Branch (855:51): [True: 475, False: 697]
  ------------------
  856|    697|                !((W[37] ^ (W[42] << 2)) & (1 << 30)))
  ------------------
  |  Branch (856:17): [True: 214, False: 483]
  ------------------
  857|  1.86k|                mask &= ~DV_II_50_0_bit;
  858|  93.3k|        if (mask & DV_II_50_2_bit)
  ------------------
  |  Branch (858:13): [True: 26.8k, False: 66.5k]
  ------------------
  859|  26.8k|            if (!(!((W[54] ^ (W[55] << 5)) & (1 << 6))) || !(!((W[52] ^ W[54]) & (1 << 6))) ||
  ------------------
  |  Branch (859:17): [True: 9.72k, False: 17.1k]
  |  Branch (859:60): [True: 5.22k, False: 11.8k]
  ------------------
  860|  11.8k|                !((W[51] ^ W[55]) & (1 << 1)) || !((W[45] ^ W[47]) & (1 << 1)) ||
  ------------------
  |  Branch (860:17): [True: 5.61k, False: 6.28k]
  |  Branch (860:50): [True: 1.39k, False: 4.89k]
  ------------------
  861|  4.89k|                !(!((W[38] ^ (W[42] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (861:17): [True: 3.09k, False: 1.79k]
  ------------------
  862|  1.79k|                !((W[37] ^ (W[42] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (862:17): [True: 1.18k, False: 612]
  ------------------
  863|  26.2k|                mask &= ~DV_II_50_2_bit;
  864|  93.3k|        if (mask & DV_II_51_0_bit)
  ------------------
  |  Branch (864:13): [True: 741, False: 92.6k]
  ------------------
  865|    741|            if (!(!((W[39] ^ (W[43] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (865:17): [True: 264, False: 477]
  ------------------
  866|    477|                !((W[38] ^ (W[43] << 2)) & (1 << 30)))
  ------------------
  |  Branch (866:17): [True: 240, False: 237]
  ------------------
  867|    504|                mask &= ~DV_II_51_0_bit;
  868|  93.3k|        if (mask & DV_II_51_2_bit)
  ------------------
  |  Branch (868:13): [True: 27.7k, False: 65.6k]
  ------------------
  869|  27.7k|            if (!(!((W[55] ^ (W[56] << 5)) & (1 << 6))) || !(!((W[53] ^ W[55]) & (1 << 6))) ||
  ------------------
  |  Branch (869:17): [True: 13.9k, False: 13.7k]
  |  Branch (869:60): [True: 8.50k, False: 5.21k]
  ------------------
  870|  5.21k|                !((W[52] ^ W[56]) & (1 << 1)) || !((W[46] ^ W[48]) & (1 << 1)) ||
  ------------------
  |  Branch (870:17): [True: 2.56k, False: 2.65k]
  |  Branch (870:50): [True: 994, False: 1.65k]
  ------------------
  871|  1.65k|                !(!((W[39] ^ (W[43] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (871:17): [True: 557, False: 1.10k]
  ------------------
  872|  1.10k|                !((W[38] ^ (W[43] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (872:17): [True: 576, False: 524]
  ------------------
  873|  27.1k|                mask &= ~DV_II_51_2_bit;
  874|  93.3k|        if (mask & DV_II_52_0_bit)
  ------------------
  |  Branch (874:13): [True: 1.26k, False: 92.1k]
  ------------------
  875|  1.26k|            if (!(!((W[59] ^ W[60]) & (1 << 29))) ||
  ------------------
  |  Branch (875:17): [True: 364, False: 901]
  ------------------
  876|    901|                !(!((W[40] ^ (W[44] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (876:17): [True: 221, False: 680]
  ------------------
  877|    680|                !(!((W[40] ^ (W[44] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (877:17): [True: 220, False: 460]
  ------------------
  878|    460|                !((W[39] ^ (W[44] << 2)) & (1 << 30)))
  ------------------
  |  Branch (878:17): [True: 244, False: 216]
  ------------------
  879|  1.04k|                mask &= ~DV_II_52_0_bit;
  880|  93.3k|        if (mask & DV_II_53_0_bit)
  ------------------
  |  Branch (880:13): [True: 1.26k, False: 92.1k]
  ------------------
  881|  1.26k|            if (!((W[58] ^ W[61]) & (1 << 29)) || !(!((W[57] ^ (W[61] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (881:17): [True: 228, False: 1.04k]
  |  Branch (881:51): [True: 220, False: 820]
  ------------------
  882|    820|                !(!((W[41] ^ (W[45] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (882:17): [True: 226, False: 594]
  ------------------
  883|    594|                !(!((W[41] ^ (W[45] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (883:17): [True: 310, False: 284]
  ------------------
  884|    984|                mask &= ~DV_II_53_0_bit;
  885|  93.3k|        if (mask & DV_II_54_0_bit)
  ------------------
  |  Branch (885:13): [True: 903, False: 92.4k]
  ------------------
  886|    903|            if (!(!((W[58] ^ (W[62] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (886:17): [True: 234, False: 669]
  ------------------
  887|    669|                !(!((W[42] ^ (W[46] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (887:17): [True: 230, False: 439]
  ------------------
  888|    439|                !(!((W[42] ^ (W[46] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (888:17): [True: 223, False: 216]
  ------------------
  889|    687|                mask &= ~DV_II_54_0_bit;
  890|  93.3k|        if (mask & DV_II_55_0_bit)
  ------------------
  |  Branch (890:13): [True: 1.37k, False: 92.0k]
  ------------------
  891|  1.37k|            if (!(!((W[59] ^ (W[63] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (891:17): [True: 355, False: 1.02k]
  ------------------
  892|  1.02k|                !(!((W[57] ^ (W[59] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (892:17): [True: 238, False: 783]
  ------------------
  893|    783|                !(!((W[43] ^ (W[47] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (893:17): [True: 212, False: 571]
  ------------------
  894|    571|                !(!((W[43] ^ (W[47] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (894:17): [True: 222, False: 349]
  ------------------
  895|  1.02k|                mask &= ~DV_II_55_0_bit;
  896|  93.3k|        if (mask & DV_II_56_0_bit)
  ------------------
  |  Branch (896:13): [True: 1.13k, False: 92.2k]
  ------------------
  897|  1.13k|            if (!(!((W[60] ^ (W[64] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (897:17): [True: 226, False: 912]
  ------------------
  898|    912|                !(!((W[44] ^ (W[48] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (898:17): [True: 332, False: 580]
  ------------------
  899|    580|                !(!((W[44] ^ (W[48] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (899:17): [True: 218, False: 362]
  ------------------
  900|    776|                mask &= ~DV_II_56_0_bit;
  901|  93.3k|    }
  902|       |
  903|   206k|    dvmask[0] = mask;
  904|   206k|}

_ZN28pgp_sphincsplus_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE23sphincsplus_parameter_t16pgp_pubkey_alg_t:
  118|  1.91k|    : key_encoded_(key_encoded), pk_alg_(alg), sphincsplus_param_(param),
  119|  1.91k|      sphincsplus_hash_func_(rnp_sphincsplus_alg_to_hashfunc(alg)), is_initialized_(true)
  120|  1.91k|{
  121|  1.91k|}
_Z23sphincsplus_pubkey_size23sphincsplus_parameter_t:
  289|  2.36k|{
  290|  2.36k|    switch (param) {
  291|    270|    case sphincsplus_simple_128s:
  ------------------
  |  Branch (291:5): [True: 270, False: 2.09k]
  ------------------
  292|    270|        return 32;
  293|    513|    case sphincsplus_simple_128f:
  ------------------
  |  Branch (293:5): [True: 513, False: 1.84k]
  ------------------
  294|    513|        return 32;
  295|     29|    case sphincsplus_simple_192s:
  ------------------
  |  Branch (295:5): [True: 29, False: 2.33k]
  ------------------
  296|     29|        return 48;
  297|    127|    case sphincsplus_simple_192f:
  ------------------
  |  Branch (297:5): [True: 127, False: 2.23k]
  ------------------
  298|    127|        return 48;
  299|    157|    case sphincsplus_simple_256s:
  ------------------
  |  Branch (299:5): [True: 157, False: 2.20k]
  ------------------
  300|    157|        return 64;
  301|  1.02k|    case sphincsplus_simple_256f:
  ------------------
  |  Branch (301:5): [True: 1.02k, False: 1.33k]
  ------------------
  302|  1.02k|        return 64;
  303|    240|    default:
  ------------------
  |  Branch (303:5): [True: 240, False: 2.12k]
  ------------------
  304|    240|        RNP_LOG("invalid SLH-DSA parameter identifier");
  ------------------
  |  |   76|    240|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    240|    do {                                                                                 \
  |  |  |  |   69|    240|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 240, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    240|            break;                                                                       \
  |  |  |  |   71|    240|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  305|    240|        return 0;
  306|  2.36k|    }
  307|  2.36k|}
_Z26sphincsplus_signature_size23sphincsplus_parameter_t:
  311|    654|{
  312|    654|    switch (param) {
  313|      4|    case sphincsplus_simple_128s:
  ------------------
  |  Branch (313:5): [True: 4, False: 650]
  ------------------
  314|      4|        return 7856;
  315|      6|    case sphincsplus_simple_128f:
  ------------------
  |  Branch (315:5): [True: 6, False: 648]
  ------------------
  316|      6|        return 17088;
  317|     42|    case sphincsplus_simple_192s:
  ------------------
  |  Branch (317:5): [True: 42, False: 612]
  ------------------
  318|     42|        return 16224;
  319|      0|    case sphincsplus_simple_192f:
  ------------------
  |  Branch (319:5): [True: 0, False: 654]
  ------------------
  320|      0|        return 35664;
  321|    366|    case sphincsplus_simple_256s:
  ------------------
  |  Branch (321:5): [True: 366, False: 288]
  ------------------
  322|    366|        return 29792;
  323|      9|    case sphincsplus_simple_256f:
  ------------------
  |  Branch (323:5): [True: 9, False: 645]
  ------------------
  324|      9|        return 49856;
  325|    227|    default:
  ------------------
  |  Branch (325:5): [True: 227, False: 427]
  ------------------
  326|    227|        RNP_LOG("invalid SLH-DSA parameter identifier");
  ------------------
  |  |   76|    227|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    227|    do {                                                                                 \
  |  |  |  |   69|    227|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 227, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    227|            break;                                                                       \
  |  |  |  |   71|    227|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  327|    227|        return 0;
  328|    654|    }
  329|    654|}
sphincsplus.cpp:_ZN12_GLOBAL__N_131rnp_sphincsplus_alg_to_hashfuncE16pgp_pubkey_alg_t:
   70|  1.91k|{
   71|  1.91k|    switch (alg) {
   72|    577|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (72:5): [True: 577, False: 1.33k]
  ------------------
   73|    577|        return sphincsplus_sha256;
   74|  1.33k|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (74:5): [True: 1.33k, False: 577]
  ------------------
   75|  1.33k|        return sphinscplus_shake256;
   76|      0|    default:
  ------------------
  |  Branch (76:5): [True: 0, False: 1.91k]
  ------------------
   77|      0|        RNP_LOG("invalid SLH-DSA alg id");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   78|      0|        throw rnp::rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   79|  1.91k|    }
   80|  1.91k|}

_ZNK28pgp_sphincsplus_public_key_t11get_encodedEv:
  161|    932|    {
  162|    932|        return key_encoded_;
  163|    932|    };
_ZN28pgp_sphincsplus_public_key_tC2Ev:
  129|  2.91k|    pgp_sphincsplus_public_key_t() = default;
_ZN29pgp_sphincsplus_private_key_tC2Ev:
   68|  2.91k|    pgp_sphincsplus_private_key_t() = default;

_Z14pgp_block_size14pgp_symm_alg_t:
  210|  29.3k|{
  211|  29.3k|    switch (alg) {
  212|  4.15k|    case PGP_SA_IDEA:
  ------------------
  |  Branch (212:5): [True: 4.15k, False: 25.2k]
  ------------------
  213|  7.62k|    case PGP_SA_TRIPLEDES:
  ------------------
  |  Branch (213:5): [True: 3.47k, False: 25.9k]
  ------------------
  214|  13.0k|    case PGP_SA_CAST5:
  ------------------
  |  Branch (214:5): [True: 5.45k, False: 23.9k]
  ------------------
  215|  15.6k|    case PGP_SA_BLOWFISH:
  ------------------
  |  Branch (215:5): [True: 2.52k, False: 26.8k]
  ------------------
  216|  15.6k|        return 8;
  217|    734|    case PGP_SA_AES_128:
  ------------------
  |  Branch (217:5): [True: 734, False: 28.6k]
  ------------------
  218|  1.09k|    case PGP_SA_AES_192:
  ------------------
  |  Branch (218:5): [True: 363, False: 29.0k]
  ------------------
  219|  1.35k|    case PGP_SA_AES_256:
  ------------------
  |  Branch (219:5): [True: 261, False: 29.1k]
  ------------------
  220|  2.27k|    case PGP_SA_TWOFISH:
  ------------------
  |  Branch (220:5): [True: 912, False: 28.4k]
  ------------------
  221|  5.21k|    case PGP_SA_CAMELLIA_128:
  ------------------
  |  Branch (221:5): [True: 2.94k, False: 26.4k]
  ------------------
  222|  11.3k|    case PGP_SA_CAMELLIA_192:
  ------------------
  |  Branch (222:5): [True: 6.15k, False: 23.2k]
  ------------------
  223|  11.6k|    case PGP_SA_CAMELLIA_256:
  ------------------
  |  Branch (223:5): [True: 264, False: 29.1k]
  ------------------
  224|  12.8k|    case PGP_SA_SM4:
  ------------------
  |  Branch (224:5): [True: 1.19k, False: 28.2k]
  ------------------
  225|  12.8k|        return 16;
  226|    966|    default:
  ------------------
  |  Branch (226:5): [True: 966, False: 28.4k]
  ------------------
  227|    966|        return 0;
  228|  29.3k|    }
  229|  29.3k|}
_Z25pgp_cipher_aead_nonce_len14pgp_aead_alg_t:
  317|  2.11k|{
  318|  2.11k|    switch (aalg) {
  319|    785|    case PGP_AEAD_EAX:
  ------------------
  |  Branch (319:5): [True: 785, False: 1.33k]
  ------------------
  320|    785|        return PGP_AEAD_EAX_NONCE_LEN;
  ------------------
  |  |   64|    785|#define PGP_AEAD_EAX_NONCE_LEN 16
  ------------------
  321|    896|    case PGP_AEAD_OCB:
  ------------------
  |  Branch (321:5): [True: 896, False: 1.22k]
  ------------------
  322|    896|        return PGP_AEAD_OCB_NONCE_LEN;
  ------------------
  |  |   67|    896|#define PGP_AEAD_OCB_NONCE_LEN 15
  ------------------
  323|    436|    default:
  ------------------
  |  Branch (323:5): [True: 436, False: 1.68k]
  ------------------
  324|    436|        return 0;
  325|  2.11k|    }
  326|  2.11k|}
_Z23pgp_cipher_aead_tag_len14pgp_aead_alg_t:
  330|  1.52k|{
  331|  1.52k|    switch (aalg) {
  332|    703|    case PGP_AEAD_EAX:
  ------------------
  |  Branch (332:5): [True: 703, False: 824]
  ------------------
  333|  1.52k|    case PGP_AEAD_OCB:
  ------------------
  |  Branch (333:5): [True: 824, False: 703]
  ------------------
  334|  1.52k|        return PGP_AEAD_EAX_OCB_TAG_LEN;
  ------------------
  |  |   79|  1.52k|#define PGP_AEAD_EAX_OCB_TAG_LEN 16
  ------------------
  335|      0|    default:
  ------------------
  |  Branch (335:5): [True: 0, False: 1.52k]
  ------------------
  336|      0|        return 0;
  337|  1.52k|    }
  338|  1.52k|}

_ZN3pgp11EncMaterial6createE16pgp_pubkey_alg_t:
   35|  18.3k|{
   36|  18.3k|    switch (alg) {
   37|  5.73k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (37:5): [True: 5.73k, False: 12.6k]
  ------------------
   38|  6.94k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (38:5): [True: 1.20k, False: 17.1k]
  ------------------
   39|  6.94k|        return std::unique_ptr<EncMaterial>(new RSAEncMaterial());
   40|    998|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (40:5): [True: 998, False: 17.3k]
  ------------------
   41|  2.31k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (41:5): [True: 1.31k, False: 17.0k]
  ------------------
   42|  2.31k|        return std::unique_ptr<EncMaterial>(new EGEncMaterial());
   43|  1.04k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (43:5): [True: 1.04k, False: 17.3k]
  ------------------
   44|  1.04k|        return std::unique_ptr<EncMaterial>(new SM2EncMaterial());
   45|  2.50k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (45:5): [True: 2.50k, False: 15.8k]
  ------------------
   46|  2.50k|        return std::unique_ptr<EncMaterial>(new ECDHEncMaterial());
   47|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   48|  2.67k|    case PGP_PKA_X25519:
  ------------------
  |  Branch (48:5): [True: 2.67k, False: 15.6k]
  ------------------
   49|  2.67k|        return std::unique_ptr<EncMaterial>(new X25519EncMaterial());
   50|      0|#endif
   51|      0|#if defined(ENABLE_PQC)
   52|    284|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (52:5): [True: 284, False: 18.0k]
  ------------------
   53|    284|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    284|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   54|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
   55|    977|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (55:5): [True: 693, False: 17.6k]
  ------------------
   56|    977|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    977|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   57|  1.71k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (57:5): [True: 736, False: 17.6k]
  ------------------
   58|  1.71k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.71k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   59|  2.10k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (59:5): [True: 391, False: 17.9k]
  ------------------
   60|  2.10k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.10k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   61|  2.39k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (61:5): [True: 293, False: 18.0k]
  ------------------
   62|  2.39k|        return std::unique_ptr<EncMaterial>(new MlkemEcdhEncMaterial(alg));
   63|      0|#endif
   64|    490|    default:
  ------------------
  |  Branch (64:5): [True: 490, False: 17.8k]
  ------------------
   65|    490|        RNP_LOG("unknown pk alg %d", alg);
  ------------------
  |  |   76|    490|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    490|    do {                                                                                 \
  |  |  |  |   69|    490|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 490, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    490|            break;                                                                       \
  |  |  |  |   71|    490|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   66|    490|        return nullptr;
   67|  18.3k|    }
   68|  18.3k|}
_ZN3pgp14RSAEncMaterial5parseER17pgp_packet_body_t:
   72|  6.94k|{
   73|  6.94k|    return pkt.get(enc.m);
   74|  6.94k|}
_ZN3pgp13EGEncMaterial5parseER17pgp_packet_body_t:
   84|  2.31k|{
   85|  2.31k|    return pkt.get(enc.g) && pkt.get(enc.m);
  ------------------
  |  Branch (85:12): [True: 2.01k, False: 298]
  |  Branch (85:30): [True: 1.88k, False: 133]
  ------------------
   86|  2.31k|}
_ZN3pgp14SM2EncMaterial5parseER17pgp_packet_body_t:
   97|  1.04k|{
   98|  1.04k|    return pkt.get(enc.m);
   99|  1.04k|}
_ZN3pgp15ECDHEncMaterial5parseER17pgp_packet_body_t:
  109|  2.50k|{
  110|  2.50k|    uint8_t sz = 0;
  111|       |    /* ECDH ephemeral point and m size */
  112|  2.50k|    if (!pkt.get(enc.p) || !pkt.get(sz)) {
  ------------------
  |  Branch (112:9): [True: 360, False: 2.14k]
  |  Branch (112:28): [True: 210, False: 1.93k]
  ------------------
  113|    570|        return false;
  114|    570|    }
  115|       |    /* ECDH m */
  116|  1.93k|    if (sz > ECDH_WRAPPED_KEY_SIZE) {
  ------------------
  |  |   38|  1.93k|#define ECDH_WRAPPED_KEY_SIZE 48
  ------------------
  |  Branch (116:9): [True: 211, False: 1.72k]
  ------------------
  117|    211|        RNP_LOG("wrong ecdh m len");
  ------------------
  |  |   76|    211|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    211|    do {                                                                                 \
  |  |  |  |   69|    211|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 211, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    211|            break;                                                                       \
  |  |  |  |   71|    211|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|    211|        return false;
  119|    211|    }
  120|  1.72k|    enc.m.resize(sz);
  121|  1.72k|    if (!pkt.get(enc.m.data(), sz)) {
  ------------------
  |  Branch (121:9): [True: 214, False: 1.51k]
  ------------------
  122|    214|        return false;
  123|    214|    }
  124|  1.51k|    return true;
  125|  1.72k|}
_ZN3pgp17X25519EncMaterial5parseER17pgp_packet_body_t:
  138|  2.67k|{
  139|  2.67k|    enc.eph_key.resize(32);
  140|  2.67k|    if (!pkt.get(enc.eph_key.data(), enc.eph_key.size())) {
  ------------------
  |  Branch (140:9): [True: 332, False: 2.34k]
  ------------------
  141|    332|        RNP_LOG("failed to parse X25519 PKESK (eph. pubkey)");
  ------------------
  |  |   76|    332|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    332|    do {                                                                                 \
  |  |  |  |   69|    332|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 332, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    332|            break;                                                                       \
  |  |  |  |   71|    332|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  142|    332|        return false;
  143|    332|    }
  144|  2.34k|    uint8_t sess_len = 0;
  145|  2.34k|    if (!pkt.get(sess_len) || !sess_len) {
  ------------------
  |  Branch (145:9): [True: 201, False: 2.14k]
  |  Branch (145:31): [True: 196, False: 1.95k]
  ------------------
  146|    397|        RNP_LOG("failed to parse X25519 PKESK (enc sesskey length)");
  ------------------
  |  |   76|    397|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    397|    do {                                                                                 \
  |  |  |  |   69|    397|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 397, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    397|            break;                                                                       \
  |  |  |  |   71|    397|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  147|    397|        return false;
  148|    397|    }
  149|       |    /* get plaintext salg if PKESKv3 */
  150|  1.95k|    if (version == PGP_PKSK_V3) {
  ------------------
  |  Branch (150:9): [True: 1.69k, False: 257]
  ------------------
  151|  1.69k|        uint8_t bt = 0;
  152|  1.69k|        if (!pkt.get(bt)) {
  ------------------
  |  Branch (152:13): [True: 214, False: 1.47k]
  ------------------
  153|    214|            RNP_LOG("failed to get salg");
  ------------------
  |  |   76|    214|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    214|    do {                                                                                 \
  |  |  |  |   69|    214|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 214, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    214|            break;                                                                       \
  |  |  |  |   71|    214|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  154|    214|            return RNP_ERROR_BAD_FORMAT;
  155|    214|        }
  156|  1.47k|        sess_len--;
  157|  1.47k|        salg = (pgp_symm_alg_t) bt;
  158|  1.47k|    }
  159|  1.73k|    enc.enc_sess_key.resize(sess_len);
  160|  1.73k|    if (!pkt.get(enc.enc_sess_key.data(), sess_len)) {
  ------------------
  |  Branch (160:9): [True: 190, False: 1.54k]
  ------------------
  161|    190|        RNP_LOG("failed to parse X25519 PKESK (enc sesskey)");
  ------------------
  |  |   76|    190|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    190|    do {                                                                                 \
  |  |  |  |   69|    190|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 190, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    190|            break;                                                                       \
  |  |  |  |   71|    190|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  162|    190|        return false;
  163|    190|    }
  164|  1.54k|    return true;
  165|  1.73k|}
_ZN3pgp20MlkemEcdhEncMaterial5parseER17pgp_packet_body_t:
  183|  2.39k|{
  184|       |    /* Calculate ciphertext size */
  185|  2.39k|    auto csize =
  186|  2.39k|      kyber_ciphertext_size(pgp_kyber_ecdh_composite_key_t::pk_alg_to_kyber_id(alg_)) +
  187|  2.39k|      pgp_kyber_ecdh_composite_key_t::ecdh_curve_ephemeral_size(
  188|  2.39k|        pgp_kyber_ecdh_composite_key_t::pk_alg_to_curve_id(alg_));
  189|  2.39k|    enc.composite_ciphertext.resize(csize);
  190|       |    /* Read composite ciphertext */
  191|  2.39k|    if (!pkt.get(enc.composite_ciphertext.data(), enc.composite_ciphertext.size())) {
  ------------------
  |  Branch (191:9): [True: 1.03k, False: 1.36k]
  ------------------
  192|  1.03k|        RNP_LOG("failed to get kyber-ecdh ciphertext");
  ------------------
  |  |   76|  1.03k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.03k|    do {                                                                                 \
  |  |  |  |   69|  1.03k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.03k|            break;                                                                       \
  |  |  |  |   71|  1.03k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  193|  1.03k|        return false;
  194|  1.03k|    }
  195|  1.36k|    uint8_t wrapped_key_len = 0;
  196|  1.36k|    if (!pkt.get(wrapped_key_len) || !wrapped_key_len) {
  ------------------
  |  Branch (196:9): [True: 0, False: 1.36k]
  |  Branch (196:38): [True: 192, False: 1.17k]
  ------------------
  197|    192|        RNP_LOG("failed to get kyber-ecdh wrapped session key length");
  ------------------
  |  |   76|    192|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    192|    do {                                                                                 \
  |  |  |  |   69|    192|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 192, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    192|            break;                                                                       \
  |  |  |  |   71|    192|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  198|    192|        return false;
  199|    192|    }
  200|       |    /* get plaintext salg if PKESKv3 */
  201|  1.17k|    if (version == PGP_PKSK_V3) {
  ------------------
  |  Branch (201:9): [True: 658, False: 514]
  ------------------
  202|    658|        uint8_t balg = 0;
  203|    658|        if (!pkt.get(balg)) {
  ------------------
  |  Branch (203:13): [True: 4, False: 654]
  ------------------
  204|      4|            RNP_LOG("failed to get salg");
  ------------------
  |  |   76|      4|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      4|    do {                                                                                 \
  |  |  |  |   69|      4|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 4, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      4|            break;                                                                       \
  |  |  |  |   71|      4|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  205|      4|            return RNP_ERROR_BAD_FORMAT;
  206|      4|        }
  207|    654|        salg = (pgp_symm_alg_t) balg;
  208|    654|        wrapped_key_len--;
  209|    654|    }
  210|  1.16k|    enc.wrapped_sesskey.resize(wrapped_key_len);
  211|  1.16k|    if (!pkt.get(enc.wrapped_sesskey.data(), enc.wrapped_sesskey.size())) {
  ------------------
  |  Branch (211:9): [True: 123, False: 1.04k]
  ------------------
  212|    123|        RNP_LOG("failed to get kyber-ecdh session key");
  ------------------
  |  |   76|    123|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    123|    do {                                                                                 \
  |  |  |  |   69|    123|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 123, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    123|            break;                                                                       \
  |  |  |  |   71|    123|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|    123|        return false;
  214|    123|    }
  215|  1.04k|    return true;
  216|  1.16k|}

_ZN3pgp11EncMaterialD2Ev:
   43|  17.8k|    virtual ~EncMaterial(){};
_ZN3pgp20MlkemEcdhEncMaterialC2E16pgp_pubkey_alg_t:
  100|  2.39k|    MlkemEcdhEncMaterial(pgp_pubkey_alg_t alg) : alg_(alg)
  101|  2.39k|    {
  102|  2.39k|    }

_ZN3pgp11FingerprintC2Ev:
   38|   224k|Fingerprint::Fingerprint() : keyid_({})
   39|   224k|{
   40|   224k|}
_ZN3pgp11FingerprintC2EPKhm:
   42|  9.12k|Fingerprint::Fingerprint(const uint8_t *data, size_t size) : Fingerprint()
   43|  9.12k|{
   44|  9.12k|    fp_.assign(data, data + size);
   45|  9.12k|}
_ZN3pgp11FingerprintC2ERK13pgp_key_pkt_t:
   48|  40.5k|{
   49|  40.5k|    switch (key.version) {
   50|  1.24k|    case PGP_V2:
  ------------------
  |  Branch (50:5): [True: 1.24k, False: 39.3k]
  ------------------
   51|  3.12k|    case PGP_V3: {
  ------------------
  |  Branch (51:5): [True: 1.88k, False: 38.6k]
  ------------------
   52|       |        /* v2/3 fingerprint is calculated from RSA public numbers */
   53|  3.12k|        if (!is_rsa_key_alg(key.alg)) {
  ------------------
  |  Branch (53:13): [True: 0, False: 3.12k]
  ------------------
   54|      0|            RNP_LOG("bad algorithm");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   55|      0|            throw rnp::rnp_exception(RNP_ERROR_NOT_SUPPORTED);
   56|      0|        }
   57|  3.12k|        auto &rsa = dynamic_cast<const pgp::RSAKeyMaterial &>(*key.material);
   58|  3.12k|        auto  hash = rnp::Hash::create(PGP_HASH_MD5);
   59|  3.12k|        hash->add(rsa.n());
   60|  3.12k|        hash->add(rsa.e());
   61|  3.12k|        fp_ = hash->finish();
   62|       |        /* keyid just low bytes of RSA n */
   63|  3.12k|        size_t n = rsa.n().size();
   64|  3.12k|        size_t sz = std::min(rsa.n().size(), keyid_.size());
   65|  3.12k|        std::memcpy(keyid_.data(), rsa.n().data() + n - sz, sz);
   66|  3.12k|        return;
   67|  3.12k|    }
   68|  29.8k|    case PGP_V4:
  ------------------
  |  Branch (68:5): [True: 29.8k, False: 10.7k]
  ------------------
   69|  30.4k|    case PGP_V5:
  ------------------
  |  Branch (69:5): [True: 660, False: 39.8k]
  ------------------
   70|  30.4k|#if defined(ENABLE_CRYPTO_REFRESH)
   71|  37.4k|    case PGP_V6:
  ------------------
  |  Branch (71:5): [True: 6.93k, False: 33.6k]
  ------------------
   72|  37.4k|#endif
   73|  37.4k|    {
   74|  37.4k|        auto halg = key.version == PGP_V4 ? PGP_HASH_SHA1 : PGP_HASH_SHA256;
  ------------------
  |  Branch (74:21): [True: 29.8k, False: 7.59k]
  ------------------
   75|  37.4k|        auto hash = rnp::Hash::create(halg);
   76|  37.4k|        signature_hash_key(key, *hash, key.version);
   77|  37.4k|        fp_ = hash->finish();
   78|       |        /* keyid */
   79|  37.4k|        if (key.version == PGP_V4) {
  ------------------
  |  Branch (79:13): [True: 29.8k, False: 7.59k]
  ------------------
   80|  29.8k|            assert(fp_.size() == PGP_FINGERPRINT_V4_SIZE);
   81|  29.8k|            const size_t inc = PGP_FINGERPRINT_V4_SIZE - PGP_KEY_ID_SIZE;
  ------------------
  |  |   43|  29.8k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
                          const size_t inc = PGP_FINGERPRINT_V4_SIZE - PGP_KEY_ID_SIZE;
  ------------------
  |  |   39|  29.8k|#define PGP_KEY_ID_SIZE 8
  ------------------
   82|  29.8k|            memcpy(keyid_.data(), fp_.data() + inc, keyid_.size());
   83|  29.8k|        } else {
   84|  7.59k|            memcpy(keyid_.data(), fp_.data(), keyid_.size());
   85|  7.59k|        }
   86|  37.4k|        return;
   87|  30.4k|    }
   88|      0|    default:
  ------------------
  |  Branch (88:5): [True: 0, False: 40.5k]
  ------------------
   89|      0|        RNP_LOG("unsupported key version");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   90|      0|        throw rnp::rnp_exception(RNP_ERROR_NOT_SUPPORTED);
   91|  40.5k|    }
   92|  40.5k|}
_ZNK3pgp11Fingerprint5keyidEv:
  115|  40.5k|{
  116|  40.5k|    return keyid_;
  117|  40.5k|}
_ZNK3pgp11Fingerprint4dataEv:
  127|  5.65k|{
  128|  5.65k|    return fp_.data();
  129|  5.65k|}
_ZNK3pgp11Fingerprint4sizeEv:
  133|  5.65k|{
  134|  5.65k|    return fp_.size();
  135|  5.65k|}

_Z8json_addP11json_objectPKcS0_:
   35|  2.12M|{
   36|  2.12M|    if (!val) {
  ------------------
  |  Branch (36:9): [True: 0, False: 2.12M]
  ------------------
   37|      0|        return false;
   38|      0|    }
   39|       |    // TODO: in JSON-C 0.13 json_object_object_add returns bool instead of void
   40|  2.12M|    json_object_object_add(obj, name, val);
   41|  2.12M|    if (!json_object_object_get_ex(obj, name, NULL)) {
  ------------------
  |  Branch (41:9): [True: 0, False: 2.12M]
  ------------------
   42|      0|        json_object_put(val);
   43|      0|        return false;
   44|      0|    }
   45|       |
   46|  2.12M|    return true;
   47|  2.12M|}
_Z8json_addP11json_objectPKcS2_:
   51|   289k|{
   52|   289k|    return json_add(obj, name, json_object_new_string(value));
   53|   289k|}
_Z8json_addP11json_objectPKcb:
   57|   394k|{
   58|   394k|    return json_add(obj, name, json_object_new_boolean(value));
   59|   394k|}
_Z8json_addP11json_objectPKci:
   63|   427k|{
   64|   427k|    return json_add(obj, name, json_object_new_int(value));
   65|   427k|}
_Z8json_addP11json_objectPKcm:
   69|   343k|{
   70|   343k|#if (JSON_C_MAJOR_VERSION == 0) && (JSON_C_MINOR_VERSION < 14)
   71|   343k|    return json_add(obj, name, json_object_new_int64(value));
   72|       |#else
   73|       |    return json_add(obj, name, json_object_new_uint64(value));
   74|       |#endif
   75|   343k|}
_Z8json_addP11json_objectPKcS2_m:
   79|  11.5k|{
   80|  11.5k|    return json_add(obj, name, json_object_new_string_len(value, len));
   81|  11.5k|}
_Z8json_addP11json_objectPKcRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   85|   416k|{
   86|   416k|    return json_add(obj, name, json_object_new_string_len(value.data(), value.size()));
   87|   416k|}
_Z12json_add_hexP11json_objectPKcPKhm:
   91|   410k|{
   92|   410k|    if (val_len > 1024 * 1024) {
  ------------------
  |  Branch (92:9): [True: 0, False: 410k]
  ------------------
   93|      0|        RNP_LOG("too large json hex field: %zu", val_len);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   94|      0|        val_len = 1024 * 1024;
   95|      0|    }
   96|       |
   97|   410k|    return json_add(obj, name, bin_to_hex(val, val_len, rnp::HexFormat::Lowercase));
   98|   410k|}
_Z12json_add_hexP11json_objectPKcRKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  102|  28.8k|{
  103|  28.8k|    return json_add_hex(obj, name, vec.data(), vec.size());
  104|  28.8k|}
_Z8json_addP11json_objectPKcRKNSt3__15arrayIhLm8EEE:
  108|  24.6k|{
  109|  24.6k|    return json_add_hex(obj, name, keyid.data(), keyid.size());
  110|  24.6k|}
_Z8json_addP11json_objectPKcRKN3pgp11FingerprintE:
  114|  2.16k|{
  115|  2.16k|    return json_add_hex(obj, name, fp.data(), fp.size());
  116|  2.16k|}
_Z14json_array_addP11json_objectPKc:
  120|  22.0k|{
  121|  22.0k|    return json_array_add(obj, json_object_new_string(val));
  122|  22.0k|}
_Z14json_array_addP11json_objectS0_:
  126|  40.7k|{
  127|  40.7k|    if (!val) {
  ------------------
  |  Branch (127:9): [True: 0, False: 40.7k]
  ------------------
  128|      0|        return false;
  129|      0|    }
  130|  40.7k|    if (json_object_array_add(obj, val)) {
  ------------------
  |  Branch (130:9): [True: 0, False: 40.7k]
  ------------------
  131|      0|        json_object_put(val);
  132|      0|        return false;
  133|      0|    }
  134|  40.7k|    return true;
  135|  40.7k|}

_ZN3rnp10JSONObjectC2EP11json_object:
  138|   372k|    JSONObject(json_object *obj) : obj_(obj)
  139|   372k|    {
  140|   372k|    }
_ZN3rnp10JSONObject7releaseEv:
  151|   353k|    {
  152|   353k|        json_object *res = obj_;
  153|       |        obj_ = NULL;
  154|   353k|        return res;
  155|   353k|    }
_ZN3rnp10JSONObjectD2Ev:
  143|   372k|    {
  144|   372k|        if (obj_) {
  ------------------
  |  Branch (144:13): [True: 18.6k, False: 353k]
  ------------------
  145|  18.6k|            json_object_put(obj_);
  146|  18.6k|        }
  147|   372k|    }

_ZN3pgp11KeyMaterialD2Ev:
  238|  59.1k|{
  239|  59.1k|}
_ZNK3pgp11KeyMaterial3algEv:
  243|  68.0k|{
  244|  68.0k|    return alg_;
  245|  68.0k|}
_ZN3pgp11KeyMaterial6createE16pgp_pubkey_alg_t:
  376|  59.7k|{
  377|  59.7k|    switch (alg) {
  378|  7.05k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (378:5): [True: 7.05k, False: 52.6k]
  ------------------
  379|  15.0k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (379:5): [True: 7.97k, False: 51.7k]
  ------------------
  380|  24.1k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (380:5): [True: 9.15k, False: 50.5k]
  ------------------
  381|  24.1k|        return std::unique_ptr<KeyMaterial>(new RSAKeyMaterial(alg));
  382|  2.06k|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (382:5): [True: 2.06k, False: 57.6k]
  ------------------
  383|  3.20k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (383:5): [True: 1.13k, False: 58.5k]
  ------------------
  384|  3.20k|        return std::unique_ptr<KeyMaterial>(new EGKeyMaterial(alg));
  385|  1.51k|    case PGP_PKA_DSA:
  ------------------
  |  Branch (385:5): [True: 1.51k, False: 58.2k]
  ------------------
  386|  1.51k|        return std::unique_ptr<KeyMaterial>(new DSAKeyMaterial());
  387|  3.69k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (387:5): [True: 3.69k, False: 56.0k]
  ------------------
  388|  3.69k|        return std::unique_ptr<KeyMaterial>(new ECDHKeyMaterial());
  389|  2.32k|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (389:5): [True: 2.32k, False: 57.3k]
  ------------------
  390|  2.32k|        return std::unique_ptr<KeyMaterial>(new ECDSAKeyMaterial());
  391|  2.27k|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (391:5): [True: 2.27k, False: 57.4k]
  ------------------
  392|  2.27k|        return std::unique_ptr<KeyMaterial>(new EDDSAKeyMaterial());
  393|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  394|  1.72k|    case PGP_PKA_ED25519:
  ------------------
  |  Branch (394:5): [True: 1.72k, False: 57.9k]
  ------------------
  395|  1.72k|        return std::unique_ptr<KeyMaterial>(new Ed25519KeyMaterial());
  396|  1.89k|    case PGP_PKA_X25519:
  ------------------
  |  Branch (396:5): [True: 1.89k, False: 57.8k]
  ------------------
  397|  1.89k|        return std::unique_ptr<KeyMaterial>(new X25519KeyMaterial());
  398|      0|#endif
  399|  1.71k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (399:5): [True: 1.71k, False: 58.0k]
  ------------------
  400|  1.71k|        return std::unique_ptr<KeyMaterial>(new SM2KeyMaterial());
  401|      0|#if defined(ENABLE_PQC)
  402|    650|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (402:5): [True: 650, False: 59.0k]
  ------------------
  403|    650|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    650|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  404|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448
  405|  1.54k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (405:5): [True: 897, False: 58.8k]
  ------------------
  406|  1.54k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.54k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  407|  3.14k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (407:5): [True: 1.60k, False: 58.1k]
  ------------------
  408|  3.14k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.14k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  409|  3.98k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (409:5): [True: 837, False: 58.8k]
  ------------------
  410|  3.98k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.98k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  411|  5.05k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (411:5): [True: 1.06k, False: 58.6k]
  ------------------
  412|  5.05k|        return std::unique_ptr<KeyMaterial>(new MlkemEcdhKeyMaterial(alg));
  413|  4.59k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (413:5): [True: 4.59k, False: 55.1k]
  ------------------
  414|  4.59k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.59k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  415|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448
  416|  5.97k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (416:5): [True: 1.37k, False: 58.3k]
  ------------------
  417|  5.97k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  5.97k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  418|  6.69k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (418:5): [True: 720, False: 58.9k]
  ------------------
  419|  6.69k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  6.69k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  420|  7.86k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (420:5): [True: 1.17k, False: 58.5k]
  ------------------
  421|  7.86k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  7.86k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  422|  8.69k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (422:5): [True: 828, False: 58.8k]
  ------------------
  423|  8.69k|        return std::unique_ptr<KeyMaterial>(new DilithiumEccKeyMaterial(alg));
  424|  1.05k|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (424:5): [True: 1.05k, False: 58.6k]
  ------------------
  425|  1.05k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.05k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  426|  2.91k|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (426:5): [True: 1.86k, False: 57.8k]
  ------------------
  427|  2.91k|        return std::unique_ptr<KeyMaterial>(new SlhdsaKeyMaterial(alg));
  428|      0|#endif
  429|    528|    default:
  ------------------
  |  Branch (429:5): [True: 528, False: 59.1k]
  ------------------
  430|    528|        return nullptr;
  431|  59.7k|    }
  432|  59.7k|}
_ZN3pgp14RSAKeyMaterial5parseER17pgp_packet_body_t:
  497|  23.9k|{
  498|  23.9k|    secret_ = false;
  499|  23.9k|    return pkt.get(key_.n) && pkt.get(key_.e);
  ------------------
  |  Branch (499:12): [True: 23.0k, False: 829]
  |  Branch (499:31): [True: 22.9k, False: 118]
  ------------------
  500|  23.9k|}
_ZNK3pgp14RSAKeyMaterial1nEv:
  614|  33.1k|{
  615|  33.1k|    return key_.n;
  616|  33.1k|}
_ZNK3pgp14RSAKeyMaterial1eEv:
  620|  23.7k|{
  621|  23.7k|    return key_.e;
  622|  23.7k|}
_ZN3pgp14DSAKeyMaterial5parseER17pgp_packet_body_t:
  678|  1.50k|{
  679|  1.50k|    secret_ = false;
  680|  1.50k|    return pkt.get(key_.p) && pkt.get(key_.q) && pkt.get(key_.g) && pkt.get(key_.y);
  ------------------
  |  Branch (680:12): [True: 1.17k, False: 330]
  |  Branch (680:31): [True: 919, False: 260]
  |  Branch (680:50): [True: 711, False: 208]
  |  Branch (680:69): [True: 711, False: 0]
  ------------------
  681|  1.50k|}
_ZNK3pgp14DSAKeyMaterial1pEv:
  775|    709|{
  776|    709|    return key_.p;
  777|    709|}
_ZNK3pgp14DSAKeyMaterial1qEv:
  781|    709|{
  782|    709|    return key_.q;
  783|    709|}
_ZNK3pgp14DSAKeyMaterial1gEv:
  787|    709|{
  788|    709|    return key_.g;
  789|    709|}
_ZNK3pgp14DSAKeyMaterial1yEv:
  793|    709|{
  794|    709|    return key_.y;
  795|    709|}
_ZN3pgp13EGKeyMaterial5parseER17pgp_packet_body_t:
  832|  2.83k|{
  833|  2.83k|    secret_ = false;
  834|  2.83k|    return pkt.get(key_.p) && pkt.get(key_.g) && pkt.get(key_.y);
  ------------------
  |  Branch (834:12): [True: 2.07k, False: 762]
  |  Branch (834:31): [True: 1.86k, False: 210]
  |  Branch (834:50): [True: 1.73k, False: 132]
  ------------------
  835|  2.83k|}
_ZNK3pgp13EGKeyMaterial1pEv:
  925|  1.71k|{
  926|  1.71k|    return key_.p;
  927|  1.71k|}
_ZNK3pgp13EGKeyMaterial1gEv:
  931|  1.71k|{
  932|  1.71k|    return key_.g;
  933|  1.71k|}
_ZNK3pgp13EGKeyMaterial1yEv:
  937|  1.71k|{
  938|  1.71k|    return key_.y;
  939|  1.71k|}
_ZN3pgp13ECKeyMaterial5parseER17pgp_packet_body_t:
  982|  9.35k|{
  983|  9.35k|    secret_ = false;
  984|  9.35k|    if (!pkt.get(key_.curve) || !pkt.get(key_.p)) {
  ------------------
  |  Branch (984:9): [True: 3.36k, False: 5.99k]
  |  Branch (984:33): [True: 1.46k, False: 4.53k]
  ------------------
  985|  4.82k|        return false;
  986|  4.82k|    }
  987|  4.53k|    return true;
  988|  9.35k|}
_ZNK3pgp13ECKeyMaterial5curveEv:
 1046|  3.27k|{
 1047|  3.27k|    return key_.curve;
 1048|  3.27k|}
_ZNK3pgp13ECKeyMaterial1pEv:
 1052|  3.27k|{
 1053|  3.27k|    return key_.p;
 1054|  3.27k|}
_ZN3pgp15ECDHKeyMaterial5parseER17pgp_packet_body_t:
 1140|  3.65k|{
 1141|  3.65k|    if (!ECKeyMaterial::parse(pkt)) {
  ------------------
  |  Branch (1141:9): [True: 1.56k, False: 2.09k]
  ------------------
 1142|  1.56k|        return false;
 1143|  1.56k|    }
 1144|       |    /* Additional ECDH fields */
 1145|       |    /* Read KDF parameters. At the moment should be 0x03 0x01 halg ealg */
 1146|  2.09k|    uint8_t len = 0, halg = 0, walg = 0;
 1147|  2.09k|    if (!pkt.get(len) || (len != 3)) {
  ------------------
  |  Branch (1147:9): [True: 208, False: 1.88k]
  |  Branch (1147:26): [True: 236, False: 1.64k]
  ------------------
 1148|    444|        return false;
 1149|    444|    }
 1150|  1.64k|    if (!pkt.get(len) || (len != 1)) {
  ------------------
  |  Branch (1150:9): [True: 195, False: 1.45k]
  |  Branch (1150:26): [True: 192, False: 1.26k]
  ------------------
 1151|    387|        return false;
 1152|    387|    }
 1153|  1.26k|    if (!pkt.get(halg) || !pkt.get(walg)) {
  ------------------
  |  Branch (1153:9): [True: 198, False: 1.06k]
  |  Branch (1153:27): [True: 194, False: 868]
  ------------------
 1154|    392|        return false;
 1155|    392|    }
 1156|    868|    key_.kdf_hash_alg = (pgp_hash_alg_t) halg;
 1157|    868|    key_.key_wrap_alg = (pgp_symm_alg_t) walg;
 1158|    868|    return true;
 1159|  1.26k|}
_ZNK3pgp15ECDHKeyMaterial12kdf_hash_algEv:
 1229|    848|{
 1230|    848|    return key_.kdf_hash_alg;
 1231|    848|}
_ZNK3pgp15ECDHKeyMaterial12key_wrap_algEv:
 1235|    848|{
 1236|    848|    return key_.key_wrap_alg;
 1237|    848|}
_ZN3pgp18Ed25519KeyMaterial5parseER17pgp_packet_body_t:
 1430|  1.70k|{
 1431|  1.70k|    secret_ = false;
 1432|  1.70k|    auto                 ec_desc = ec::Curve::get(PGP_CURVE_ED25519);
 1433|  1.70k|    std::vector<uint8_t> buf(ec_desc->bytes());
 1434|  1.70k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1434:9): [True: 334, False: 1.37k]
  ------------------
 1435|    334|        RNP_LOG("failed to parse Ed25519 public key data");
  ------------------
  |  |   76|    334|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    334|    do {                                                                                 \
  |  |  |  |   69|    334|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 334, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    334|            break;                                                                       \
  |  |  |  |   71|    334|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1436|    334|        return false;
 1437|    334|    }
 1438|  1.37k|    key_.pub = buf;
 1439|  1.37k|    return true;
 1440|  1.70k|}
_ZNK3pgp18Ed25519KeyMaterial3pubEv:
 1517|    380|{
 1518|    380|    return key_.pub;
 1519|    380|}
_ZN3pgp17X25519KeyMaterial5parseER17pgp_packet_body_t:
 1555|  1.85k|{
 1556|  1.85k|    secret_ = false;
 1557|  1.85k|    auto                 ec_desc = ec::Curve::get(PGP_CURVE_25519);
 1558|  1.85k|    std::vector<uint8_t> buf(ec_desc->bytes());
 1559|  1.85k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1559:9): [True: 212, False: 1.64k]
  ------------------
 1560|    212|        RNP_LOG("failed to parse X25519 public key data");
  ------------------
  |  |   76|    212|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    212|    do {                                                                                 \
  |  |  |  |   69|    212|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 212, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    212|            break;                                                                       \
  |  |  |  |   71|    212|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1561|    212|        return false;
 1562|    212|    }
 1563|  1.64k|    key_.pub = buf;
 1564|  1.64k|    return true;
 1565|  1.85k|}
_ZNK3pgp17X25519KeyMaterial3pubEv:
 1647|    511|{
 1648|    511|    return key_.pub;
 1649|    511|}
_ZN3pgp20MlkemEcdhKeyMaterial5parseER17pgp_packet_body_t:
 1686|  4.66k|{
 1687|  4.66k|    secret_ = false;
 1688|  4.66k|    std::vector<uint8_t> buf(pgp_kyber_ecdh_composite_public_key_t::encoded_size(alg()));
 1689|  4.66k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1689:9): [True: 946, False: 3.72k]
  ------------------
 1690|    946|        RNP_LOG("failed to parse mlkem-ecdh public key data");
  ------------------
  |  |   76|    946|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    946|    do {                                                                                 \
  |  |  |  |   69|    946|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 946, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    946|            break;                                                                       \
  |  |  |  |   71|    946|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1691|    946|        return false;
 1692|    946|    }
 1693|  3.72k|    key_.pub = pgp_kyber_ecdh_composite_public_key_t(buf, alg());
 1694|  3.72k|    return true;
 1695|  4.66k|}
_ZNK3pgp20MlkemEcdhKeyMaterial3pubEv:
 1770|  1.66k|{
 1771|  1.66k|    return key_.pub;
 1772|  1.66k|}
_ZN3pgp23DilithiumEccKeyMaterial5parseER17pgp_packet_body_t:
 1807|  8.32k|{
 1808|  8.32k|    secret_ = false;
 1809|  8.32k|    std::vector<uint8_t> buf(pgp_dilithium_exdsa_composite_public_key_t::encoded_size(alg()));
 1810|  8.32k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1810:9): [True: 1.02k, False: 7.29k]
  ------------------
 1811|  1.02k|        RNP_LOG("failed to parse mldsa-ecdsa/eddsa public key data");
  ------------------
  |  |   76|  1.02k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.02k|    do {                                                                                 \
  |  |  |  |   69|  1.02k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.02k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.02k|            break;                                                                       \
  |  |  |  |   71|  1.02k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1812|  1.02k|        return false;
 1813|  1.02k|    }
 1814|  7.29k|    key_.pub = pgp_dilithium_exdsa_composite_public_key_t(buf, alg());
 1815|  7.29k|    return true;
 1816|  8.32k|}
_ZNK3pgp23DilithiumEccKeyMaterial3pubEv:
 1892|  3.61k|{
 1893|  3.61k|    return key_.pub;
 1894|  3.61k|}
_ZN3pgp17SlhdsaKeyMaterial5parseER17pgp_packet_body_t:
 1929|  2.64k|{
 1930|  2.64k|    secret_ = false;
 1931|  2.64k|    uint8_t bt = 0;
 1932|  2.64k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (1932:9): [True: 288, False: 2.36k]
  ------------------
 1933|    288|        RNP_LOG("failed to parse SLH-DSA public key data");
  ------------------
  |  |   76|    288|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    288|    do {                                                                                 \
  |  |  |  |   69|    288|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 288, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    288|            break;                                                                       \
  |  |  |  |   71|    288|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1934|    288|        return false;
 1935|    288|    }
 1936|  2.36k|    sphincsplus_parameter_t param = (sphincsplus_parameter_t) bt;
 1937|  2.36k|    auto                    size = sphincsplus_pubkey_size(param);
 1938|  2.36k|    if (!size) {
  ------------------
  |  Branch (1938:9): [True: 240, False: 2.12k]
  ------------------
 1939|    240|        RNP_LOG("invalid SLH-DSA param");
  ------------------
  |  |   76|    240|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    240|    do {                                                                                 \
  |  |  |  |   69|    240|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 240, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    240|            break;                                                                       \
  |  |  |  |   71|    240|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1940|    240|        return false;
 1941|    240|    }
 1942|  2.12k|    std::vector<uint8_t> buf(size);
 1943|  2.12k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1943:9): [True: 211, False: 1.91k]
  ------------------
 1944|    211|        RNP_LOG("failed to parse SLH-DSA public key data");
  ------------------
  |  |   76|    211|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    211|    do {                                                                                 \
  |  |  |  |   69|    211|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 211, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    211|            break;                                                                       \
  |  |  |  |   71|    211|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1945|    211|        return false;
 1946|    211|    }
 1947|  1.91k|    key_.pub = pgp_sphincsplus_public_key_t(buf, param, alg());
 1948|  1.91k|    return true;
 1949|  2.12k|}
_ZNK3pgp17SlhdsaKeyMaterial3pubEv:
 2039|    932|{
 2040|    932|    return key_.pub;
 2041|    932|}

_ZN3pgp11KeyMaterialC2E16pgp_pubkey_alg_tb:
  193|  59.1k|        : validity_({}), alg_(kalg), secret_(secret){};
_ZN3pgp14RSAKeyMaterialC2E16pgp_pubkey_alg_t:
  245|  24.1k|    RSAKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp14DSAKeyMaterialC2Ev:
  288|  1.51k|    DSAKeyMaterial() : KeyMaterial(PGP_PKA_DSA), key_{} {};
_ZN3pgp13EGKeyMaterialC2E16pgp_pubkey_alg_t:
  325|  3.20k|    EGKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp13ECKeyMaterialC2E16pgp_pubkey_alg_t:
  363|  10.0k|    ECKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp16ECDSAKeyMaterialC2Ev:
  386|  2.32k|    ECDSAKeyMaterial() : ECKeyMaterial(PGP_PKA_ECDSA){};
_ZN3pgp15ECDHKeyMaterialC2Ev:
  405|  3.69k|    ECDHKeyMaterial() : ECKeyMaterial(PGP_PKA_ECDH){};
_ZN3pgp16EDDSAKeyMaterialC2Ev:
  431|  2.27k|    EDDSAKeyMaterial() : ECKeyMaterial(PGP_PKA_EDDSA){};
_ZN3pgp14SM2KeyMaterialC2Ev:
  450|  1.71k|    SM2KeyMaterial() : ECKeyMaterial(PGP_PKA_SM2){};
_ZN3pgp18Ed25519KeyMaterialC2Ev:
  479|  1.72k|    Ed25519KeyMaterial() : KeyMaterial(PGP_PKA_ED25519), key_{} {};
_ZN3pgp17X25519KeyMaterialC2Ev:
  509|  1.89k|    X25519KeyMaterial() : KeyMaterial(PGP_PKA_X25519), key_{} {};
_ZN3pgp20MlkemEcdhKeyMaterialC2E16pgp_pubkey_alg_t:
  541|  5.05k|    MlkemEcdhKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp23DilithiumEccKeyMaterialC2E16pgp_pubkey_alg_t:
  570|  8.69k|    DilithiumEccKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp17SlhdsaKeyMaterialC2E16pgp_pubkey_alg_t:
  602|  2.91k|    SlhdsaKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};

_Z14rnp_log_switchv:
   53|   522k|{
   54|   522k|    if (_rnp_log_switch < 0) {
  ------------------
  |  Branch (54:9): [True: 1, False: 522k]
  ------------------
   55|      1|        const char *var = getenv(RNP_LOG_CONSOLE);
   56|      1|        _rnp_log_switch = (var && strcmp(var, "0")) ? 1 : 0;
  ------------------
  |  Branch (56:28): [True: 0, False: 1]
  |  Branch (56:35): [True: 0, False: 0]
  ------------------
   57|      1|    }
   58|   522k|    return !_rnp_log_disable && !!_rnp_log_switch;
  ------------------
  |  Branch (58:12): [True: 522k, False: 0]
  |  Branch (58:33): [True: 0, False: 522k]
  ------------------
   59|   522k|}

_ZN12rnp_input_stC2Ev:
 1994|  15.6k|rnp_input_st::rnp_input_st() : reader(NULL), closer(NULL), app_ctx(NULL)
 1995|  15.6k|{
 1996|  15.6k|    memset(&src, 0, sizeof(src));
 1997|  15.6k|}
_ZN12rnp_input_stD2Ev:
 2016|  15.6k|{
 2017|  15.6k|    bool armored = src.type == PGP_STREAM_ARMORED;
 2018|  15.6k|    src.close();
 2019|  15.6k|    if (armored) {
  ------------------
  |  Branch (2019:9): [True: 0, False: 15.6k]
  ------------------
 2020|      0|        rnp_input_t armored = (rnp_input_t) app_ctx;
 2021|      0|        delete armored;
 2022|       |        app_ctx = NULL;
 2023|      0|    }
 2024|  15.6k|}
rnp_input_from_memory:
 2073|  15.6k|try {
 2074|  15.6k|    if (!input) {
  ------------------
  |  Branch (2074:9): [True: 0, False: 15.6k]
  ------------------
 2075|      0|        return RNP_ERROR_NULL_POINTER;
 2076|      0|    }
 2077|  15.6k|    if (!buf && buf_len) {
  ------------------
  |  Branch (2077:9): [True: 0, False: 15.6k]
  |  Branch (2077:17): [True: 0, False: 0]
  ------------------
 2078|      0|        return RNP_ERROR_NULL_POINTER;
 2079|      0|    }
 2080|  15.6k|    if (!buf_len) {
  ------------------
  |  Branch (2080:9): [True: 0, False: 15.6k]
  ------------------
 2081|       |        // prevent malloc(0)
 2082|      0|        do_copy = false;
 2083|      0|    }
 2084|  15.6k|    *input = new rnp_input_st();
 2085|  15.6k|    uint8_t *data = (uint8_t *) buf;
 2086|  15.6k|    if (do_copy) {
  ------------------
  |  Branch (2086:9): [True: 0, False: 15.6k]
  ------------------
 2087|      0|        data = (uint8_t *) malloc(buf_len);
 2088|      0|        if (!data) {
  ------------------
  |  Branch (2088:13): [True: 0, False: 0]
  ------------------
 2089|       |            /* LCOV_EXCL_START */
 2090|      0|            delete *input;
 2091|      0|            *input = NULL;
 2092|      0|            return RNP_ERROR_OUT_OF_MEMORY;
 2093|       |            /* LCOV_EXCL_END */
 2094|      0|        }
 2095|      0|        memcpy(data, buf, buf_len);
 2096|      0|    }
 2097|  15.6k|    rnp_result_t ret = init_mem_src(&(*input)->src, data, buf_len, do_copy);
 2098|  15.6k|    if (ret) {
  ------------------
  |  Branch (2098:9): [True: 0, False: 15.6k]
  ------------------
 2099|       |        /* LCOV_EXCL_START */
 2100|      0|        if (do_copy) {
  ------------------
  |  Branch (2100:13): [True: 0, False: 0]
  ------------------
 2101|      0|            free(data);
 2102|      0|        }
 2103|      0|        delete *input;
 2104|      0|        *input = NULL;
 2105|       |        /* LCOV_EXCL_END */
 2106|      0|    }
 2107|  15.6k|    return ret;
 2108|  15.6k|}
 2109|  15.6k|FFI_GUARD
  ------------------
  |  |  606|  15.6k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  15.6k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  15.6k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  15.6k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  15.6k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  15.6k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  15.6k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  15.6k|    catch (...)                                                                     \
  |  |  |  |  602|  15.6k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp_input_destroy:
 2162|  15.6k|try {
 2163|  15.6k|    delete input;
 2164|  15.6k|    return RNP_SUCCESS;
 2165|  15.6k|}
 2166|  15.6k|FFI_GUARD
  ------------------
  |  |  606|  15.6k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  15.6k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  15.6k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  15.6k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  15.6k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  15.6k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  15.6k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  15.6k|    catch (...)                                                                     \
  |  |  |  |  602|  15.6k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp_output_to_null:
 2356|  7.83k|try {
 2357|       |    // checks
 2358|  7.83k|    if (!output) {
  ------------------
  |  Branch (2358:9): [True: 0, False: 7.83k]
  ------------------
 2359|      0|        return RNP_ERROR_NULL_POINTER;
 2360|      0|    }
 2361|       |
 2362|  7.83k|    *output = (rnp_output_t) calloc(1, sizeof(**output));
 2363|  7.83k|    if (!*output) {
  ------------------
  |  Branch (2363:9): [True: 0, False: 7.83k]
  ------------------
 2364|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2365|      0|    }
 2366|  7.83k|    rnp_result_t ret = init_null_dest(&(*output)->dst);
 2367|  7.83k|    if (ret) {
  ------------------
  |  Branch (2367:9): [True: 0, False: 7.83k]
  ------------------
 2368|       |        /* LCOV_EXCL_START */
 2369|      0|        free(*output);
 2370|      0|        *output = NULL;
 2371|       |        /* LCOV_EXCL_END */
 2372|      0|    }
 2373|  7.83k|    return ret;
 2374|  7.83k|}
 2375|  7.83k|FFI_GUARD
  ------------------
  |  |  606|  7.83k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  7.83k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  7.83k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  7.83k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  7.83k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  7.83k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  7.83k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  7.83k|    catch (...)                                                                     \
  |  |  |  |  602|  7.83k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp_output_destroy:
 2441|  7.83k|try {
 2442|  7.83k|    if (output) {
  ------------------
  |  Branch (2442:9): [True: 7.83k, False: 0]
  ------------------
 2443|  7.83k|        if (output->dst.type == PGP_STREAM_ARMORED) {
  ------------------
  |  Branch (2443:13): [True: 0, False: 7.83k]
  ------------------
 2444|      0|            ((rnp_output_t) output->app_ctx)->keep = output->keep;
 2445|      0|        }
 2446|  7.83k|        dst_close(&output->dst, !output->keep);
 2447|  7.83k|        free(output->dst_directory);
 2448|  7.83k|        free(output);
 2449|  7.83k|    }
 2450|  7.83k|    return RNP_SUCCESS;
 2451|  7.83k|}
 2452|  7.83k|FFI_GUARD
  ------------------
  |  |  606|  7.83k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  7.83k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  7.83k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  7.83k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  7.83k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  7.83k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  7.83k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  7.83k|    catch (...)                                                                     \
  |  |  |  |  602|  7.83k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp_buffer_destroy:
 5605|  7.83k|{
 5606|  7.83k|    free(ptr);
 5607|  7.83k|}
rnp_dump_packets_to_json:
 8692|  7.83k|try {
 8693|  7.83k|    if (!input || !result) {
  ------------------
  |  Branch (8693:9): [True: 0, False: 7.83k]
  |  Branch (8693:19): [True: 0, False: 7.83k]
  ------------------
 8694|      0|        return RNP_ERROR_NULL_POINTER;
 8695|      0|    }
 8696|  7.83k|    return rnp_dump_src_to_json(input->src, flags, result);
 8697|  7.83k|}
 8698|  7.83k|FFI_GUARD
  ------------------
  |  |  606|  7.83k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  7.83k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  7.83k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  7.83k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  7.83k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  7.83k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  7.83k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  7.83k|    catch (...)                                                                     \
  |  |  |  |  602|  7.83k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp_dump_packets_to_output:
 8702|  7.83k|try {
 8703|  7.83k|    if (!input || !output) {
  ------------------
  |  Branch (8703:9): [True: 0, False: 7.83k]
  |  Branch (8703:19): [True: 0, False: 7.83k]
  ------------------
 8704|      0|        return RNP_ERROR_NULL_POINTER;
 8705|      0|    }
 8706|       |
 8707|  7.83k|    rnp::DumpContextDst dumpctx(input->src, output->dst);
 8708|  7.83k|    dumpctx.set_dump_mpi(extract_flag(flags, RNP_JSON_DUMP_MPI));
  ------------------
  |  |   69|  7.83k|#define RNP_JSON_DUMP_MPI (1U << 0)
  ------------------
 8709|  7.83k|    dumpctx.set_dump_packets(extract_flag(flags, RNP_JSON_DUMP_RAW));
  ------------------
  |  |   70|  7.83k|#define RNP_JSON_DUMP_RAW (1U << 1)
  ------------------
 8710|  7.83k|    dumpctx.set_dump_grips(extract_flag(flags, RNP_JSON_DUMP_GRIP));
  ------------------
  |  |   71|  7.83k|#define RNP_JSON_DUMP_GRIP (1U << 2)
  ------------------
 8711|  7.83k|    if (flags) {
  ------------------
  |  Branch (8711:9): [True: 0, False: 7.83k]
  ------------------
 8712|      0|        return RNP_ERROR_BAD_PARAMETERS;
 8713|      0|    }
 8714|       |
 8715|  7.83k|    rnp_result_t ret = dumpctx.dump();
 8716|  7.83k|    output->keep = true;
 8717|  7.83k|    return ret;
 8718|  7.83k|}
 8719|  7.83k|FFI_GUARD
  ------------------
  |  |  606|  7.83k|#define FFI_GUARD FFI_GUARD_FP((stderr))
  |  |  ------------------
  |  |  |  |  589|  7.83k|    catch (rnp::rnp_exception & e)                                                  \
  |  |  |  |  590|  7.83k|    {                                                                               \
  |  |  |  |  591|      0|        return ffi_exception((fp), __func__, e.what(), e.code());                   \
  |  |  |  |  592|      0|    }                                                                               \
  |  |  |  |  593|  7.83k|    catch (std::bad_alloc &)                                                        \
  |  |  |  |  594|  7.83k|    {                                                                               \
  |  |  |  |  595|      0|        return ffi_exception((fp), __func__, "bad_alloc", RNP_ERROR_OUT_OF_MEMORY); \
  |  |  |  |  596|      0|    }                                                                               \
  |  |  |  |  597|  7.83k|    catch (std::exception & e)                                                      \
  |  |  |  |  598|  7.83k|    {                                                                               \
  |  |  |  |  599|      0|        return ffi_exception((fp), __func__, e.what());                             \
  |  |  |  |  600|      0|    }                                                                               \
  |  |  |  |  601|  7.83k|    catch (...)                                                                     \
  |  |  |  |  602|  7.83k|    {                                                                               \
  |  |  |  |  603|      0|        return ffi_exception((fp), __func__, "unknown exception");                  \
  |  |  |  |  604|      0|    }
  |  |  ------------------
  ------------------
rnp.cpp:_ZL13ret_str_valuePKcPPc:
  529|  5.44k|{
  530|  5.44k|    if (!str) {
  ------------------
  |  Branch (530:9): [True: 0, False: 5.44k]
  ------------------
  531|      0|        return RNP_ERROR_BAD_PARAMETERS;
  532|      0|    }
  533|  5.44k|    char *strcp = strdup(str);
  534|  5.44k|    if (!strcp) {
  ------------------
  |  Branch (534:9): [True: 0, False: 5.44k]
  ------------------
  535|      0|        *res = NULL;                    // LCOV_EXCL_LINE
  536|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
  537|      0|    }
  538|  5.44k|    *res = strcp;
  539|  5.44k|    return RNP_SUCCESS;
  540|  5.44k|}
rnp.cpp:_ZL12extract_flagRjj:
 1209|  47.0k|{
 1210|  47.0k|    bool res = flags & flag;
 1211|  47.0k|    flags &= ~flag;
 1212|  47.0k|    return res;
 1213|  47.0k|}
rnp.cpp:_ZL20rnp_dump_src_to_jsonR12pgp_source_tjPPc:
 8651|  7.83k|{
 8652|  7.83k|    json_object *        jso = NULL;
 8653|  7.83k|    rnp::DumpContextJson dumpctx(src, &jso);
 8654|       |
 8655|  7.83k|    dumpctx.set_dump_mpi(extract_flag(flags, RNP_JSON_DUMP_MPI));
  ------------------
  |  |   69|  7.83k|#define RNP_JSON_DUMP_MPI (1U << 0)
  ------------------
 8656|  7.83k|    dumpctx.set_dump_packets(extract_flag(flags, RNP_JSON_DUMP_RAW));
  ------------------
  |  |   70|  7.83k|#define RNP_JSON_DUMP_RAW (1U << 1)
  ------------------
 8657|  7.83k|    dumpctx.set_dump_grips(extract_flag(flags, RNP_JSON_DUMP_GRIP));
  ------------------
  |  |   71|  7.83k|#define RNP_JSON_DUMP_GRIP (1U << 2)
  ------------------
 8658|  7.83k|    if (flags) {
  ------------------
  |  Branch (8658:9): [True: 0, False: 7.83k]
  ------------------
 8659|      0|        return RNP_ERROR_BAD_PARAMETERS;
 8660|      0|    }
 8661|       |
 8662|  7.83k|    rnp_result_t ret = dumpctx.dump();
 8663|  7.83k|    if (ret) {
  ------------------
  |  Branch (8663:9): [True: 2.38k, False: 5.44k]
  ------------------
 8664|  2.38k|        json_object_put(jso);
 8665|  2.38k|        return ret;
 8666|  2.38k|    }
 8667|       |
 8668|  5.44k|    rnp::JSONObject jsowrap(jso);
 8669|       |    return ret_str_value(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY), result);
 8670|  7.83k|}

_ZN3pgp11SigMaterial6createE16pgp_pubkey_alg_t14pgp_hash_alg_t:
   35|  46.7k|{
   36|  46.7k|    switch (palg) {
   37|  15.4k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (37:5): [True: 15.4k, False: 31.2k]
  ------------------
   38|  27.8k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (38:5): [True: 12.4k, False: 34.2k]
  ------------------
   39|  27.8k|        return std::unique_ptr<SigMaterial>(new RSASigMaterial(halg));
   40|  1.79k|    case PGP_PKA_DSA:
  ------------------
  |  Branch (40:5): [True: 1.79k, False: 44.9k]
  ------------------
   41|  1.79k|        return std::unique_ptr<SigMaterial>(new DSASigMaterial(halg));
   42|  3.02k|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (42:5): [True: 3.02k, False: 43.6k]
  ------------------
   43|  7.32k|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (43:5): [True: 4.29k, False: 42.4k]
  ------------------
   44|  8.44k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (44:5): [True: 1.11k, False: 45.6k]
  ------------------
   45|  10.7k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (45:5): [True: 2.25k, False: 44.4k]
  ------------------
   46|  10.7k|        return std::unique_ptr<SigMaterial>(new ECSigMaterial(halg));
   47|  1.42k|    case PGP_PKA_ELGAMAL: /* we support reading it but will not validate */
  ------------------
  |  Branch (47:5): [True: 1.42k, False: 45.2k]
  ------------------
   48|  3.23k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (48:5): [True: 1.81k, False: 44.9k]
  ------------------
   49|  3.23k|        return std::unique_ptr<SigMaterial>(new EGSigMaterial(halg));
   50|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   51|    514|    case PGP_PKA_ED25519: {
  ------------------
  |  Branch (51:5): [True: 514, False: 46.2k]
  ------------------
   52|    514|        return std::unique_ptr<SigMaterial>(new Ed25519SigMaterial(halg));
   53|  1.42k|    }
   54|      0|#endif
   55|      0|#if defined(ENABLE_PQC)
   56|    278|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (56:5): [True: 278, False: 46.4k]
  ------------------
   57|    278|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    278|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   58|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
   59|    495|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (59:5): [True: 217, False: 46.4k]
  ------------------
   60|    495|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    495|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   61|    716|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (61:5): [True: 221, False: 46.4k]
  ------------------
   62|    716|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    716|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   63|    924|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (63:5): [True: 208, False: 46.5k]
  ------------------
   64|    924|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    924|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   65|  1.16k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (65:5): [True: 237, False: 46.4k]
  ------------------
   66|  1.16k|        return std::unique_ptr<SigMaterial>(new DilithiumSigMaterial(palg, halg));
   67|    615|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (67:5): [True: 615, False: 46.1k]
  ------------------
   68|    615|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    615|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   69|    910|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (69:5): [True: 295, False: 46.4k]
  ------------------
   70|    910|        return std::unique_ptr<SigMaterial>(new SlhdsaSigMaterial(halg));
   71|      0|#endif
   72|    513|    default:
  ------------------
  |  Branch (72:5): [True: 513, False: 46.2k]
  ------------------
   73|    513|        RNP_LOG("Unknown pk algorithm : %d", (int) palg);
  ------------------
  |  |   76|    513|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    513|    do {                                                                                 \
  |  |  |  |   69|    513|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 513, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    513|            break;                                                                       \
  |  |  |  |   71|    513|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   74|    513|        return nullptr;
   75|  46.7k|    }
   76|  46.7k|}
_ZN3pgp14RSASigMaterial5parseER17pgp_packet_body_t:
   80|  27.8k|{
   81|  27.8k|    return pkt.get(sig.s);
   82|  27.8k|}
_ZN3pgp14DSASigMaterial5parseER17pgp_packet_body_t:
   92|  1.79k|{
   93|  1.79k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (93:12): [True: 1.57k, False: 219]
  |  Branch (93:30): [True: 1.54k, False: 36]
  ------------------
   94|  1.79k|}
_ZN3pgp13EGSigMaterial5parseER17pgp_packet_body_t:
  105|  3.23k|{
  106|  3.23k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (106:12): [True: 2.76k, False: 472]
  |  Branch (106:30): [True: 2.68k, False: 80]
  ------------------
  107|  3.23k|}
_ZN3pgp13ECSigMaterial5parseER17pgp_packet_body_t:
  119|  10.7k|{
  120|  10.7k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (120:12): [True: 9.16k, False: 1.53k]
  |  Branch (120:30): [True: 8.93k, False: 230]
  ------------------
  121|  10.7k|}
_ZN3pgp18Ed25519SigMaterial5parseER17pgp_packet_body_t:
  133|    514|{
  134|    514|    auto ec_desc = pgp::ec::Curve::get(PGP_CURVE_25519);
  135|    514|    if (!pkt.get(sig.sig, 2 * ec_desc->bytes())) {
  ------------------
  |  Branch (135:9): [True: 224, False: 290]
  ------------------
  136|    224|        RNP_LOG("failed to parse ED25519 signature data");
  ------------------
  |  |   76|    224|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    224|    do {                                                                                 \
  |  |  |  |   69|    224|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 224, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    224|            break;                                                                       \
  |  |  |  |   71|    224|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  137|    224|        return false;
  138|    224|    }
  139|    290|    return true;
  140|    514|}
_ZN3pgp20DilithiumSigMaterial5parseER17pgp_packet_body_t:
  152|  1.16k|{
  153|  1.16k|    if (!pkt.get(sig.sig, pgp_dilithium_exdsa_signature_t::composite_signature_size(palg))) {
  ------------------
  |  Branch (153:9): [True: 1.11k, False: 42]
  ------------------
  154|  1.11k|        RNP_LOG("failed to get mldsa-ecdsa/eddsa signature");
  ------------------
  |  |   76|  1.11k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.11k|    do {                                                                                 \
  |  |  |  |   69|  1.11k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.11k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.11k|            break;                                                                       \
  |  |  |  |   71|  1.11k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  155|  1.11k|        return false;
  156|  1.11k|    }
  157|     42|    return true;
  158|  1.16k|}
_ZN3pgp17SlhdsaSigMaterial5parseER17pgp_packet_body_t:
  168|    910|{
  169|    910|    uint8_t param = 0;
  170|    910|    if (!pkt.get(param)) {
  ------------------
  |  Branch (170:9): [True: 256, False: 654]
  ------------------
  171|    256|        RNP_LOG("failed to parse SLH-DSA signature data");
  ------------------
  |  |   76|    256|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    256|    do {                                                                                 \
  |  |  |  |   69|    256|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 256, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    256|            break;                                                                       \
  |  |  |  |   71|    256|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  172|    256|        return false;
  173|    256|    }
  174|    654|    auto sig_size = sphincsplus_signature_size((sphincsplus_parameter_t) param);
  175|    654|    if (!sig_size) {
  ------------------
  |  Branch (175:9): [True: 227, False: 427]
  ------------------
  176|    227|        RNP_LOG("invalid SLH-DSA param value");
  ------------------
  |  |   76|    227|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    227|    do {                                                                                 \
  |  |  |  |   69|    227|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 227, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    227|            break;                                                                       \
  |  |  |  |   71|    227|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|    227|        return false;
  178|    227|    }
  179|    427|    sig.param = (sphincsplus_parameter_t) param;
  180|    427|    if (!pkt.get(sig.sig, sig_size)) {
  ------------------
  |  Branch (180:9): [True: 387, False: 40]
  ------------------
  181|    387|        RNP_LOG("failed to parse SLH-DSA signature data");
  ------------------
  |  |   76|    387|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    387|    do {                                                                                 \
  |  |  |  |   69|    387|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 387, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    387|            break;                                                                       \
  |  |  |  |   71|    387|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  182|    387|        return false;
  183|    387|    }
  184|     40|    return true;
  185|    427|}

_ZN3pgp11SigMaterialC2E14pgp_hash_alg_t:
   40|  46.2k|    SigMaterial(pgp_hash_alg_t ahalg) : halg(ahalg){};
_ZN3pgp11SigMaterialD2Ev:
   41|  46.2k|    virtual ~SigMaterial(){};
_ZN3pgp14RSASigMaterialC2E14pgp_hash_alg_t:
   52|  27.8k|    RSASigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp14DSASigMaterialC2E14pgp_hash_alg_t:
   61|  1.79k|    DSASigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp13EGSigMaterialC2E14pgp_hash_alg_t:
   70|  3.23k|    EGSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp13ECSigMaterialC2E14pgp_hash_alg_t:
   79|  10.7k|    ECSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp18Ed25519SigMaterialC2E14pgp_hash_alg_t:
   89|    514|    Ed25519SigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp20DilithiumSigMaterialC2E16pgp_pubkey_alg_t14pgp_hash_alg_t:
  103|  1.16k|        : SigMaterial(ahalg), palg(apalg){};
_ZN3pgp17SlhdsaSigMaterialC2E14pgp_hash_alg_t:
  112|    910|    SlhdsaSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};

_ZN3pgp3pkt6sigsub3RawC2Ehbb:
   43|  31.7k|    : hashed_(hashed), raw_type_(rawtype), critical_(critical), type_(Type::Unknown)
   44|  31.7k|{
   45|  31.7k|}
_ZN3pgp3pkt6sigsub3RawC2ENS1_4TypeEbb:
   48|   270k|    : hashed_(hashed), raw_type_(static_cast<uint8_t>(type)), critical_(critical), type_(type)
   49|   270k|{
   50|   270k|}
_ZN3pgp3pkt6sigsub3RawD2Ev:
   53|   311k|{
   54|   311k|}
_ZNK3pgp3pkt6sigsub3Raw10check_sizeEm:
   58|  38.0k|{
   59|  38.0k|    return true;
   60|  38.0k|};
_ZN3pgp3pkt6sigsub3Raw10parse_dataEPKhm:
   64|  23.1k|{
   65|  23.1k|    return true;
   66|  23.1k|};
_ZN3pgp3pkt6sigsub3Raw5parseEPKhm:
   70|   293k|{
   71|   293k|    if (!check_size(size)) {
  ------------------
  |  Branch (71:9): [True: 203k, False: 90.9k]
  ------------------
   72|   203k|        RNP_LOG("wrong len %zu of subpacket type %" PRIu8, size, raw_type_);
  ------------------
  |  |   76|   203k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|   203k|    do {                                                                                 \
  |  |  |  |   69|   203k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 203k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|   203k|            break;                                                                       \
  |  |  |  |   71|   203k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   73|   203k|        return false;
   74|   203k|    }
   75|  90.9k|    if (!parse_data(data, size)) {
  ------------------
  |  Branch (75:9): [True: 3.15k, False: 87.8k]
  ------------------
   76|  3.15k|        return false;
   77|  3.15k|    }
   78|  87.8k|    data_.assign(data, data + size);
   79|  87.8k|    return true;
   80|  90.9k|}
_ZN3pgp3pkt6sigsub3Raw6createEhbb:
  128|   302k|{
  129|   302k|    switch (type) {
  130|  2.46k|    case (uint8_t) Type::CreationTime:
  ------------------
  |  Branch (130:5): [True: 2.46k, False: 300k]
  ------------------
  131|  2.46k|        return RawPtr(new CreationTime(hashed, critical));
  132|  1.77k|    case (uint8_t) Type::ExpirationTime:
  ------------------
  |  Branch (132:5): [True: 1.77k, False: 300k]
  ------------------
  133|  1.77k|        return RawPtr(new ExpirationTime(hashed, critical));
  134|  3.58k|    case (uint8_t) Type::ExportableCert:
  ------------------
  |  Branch (134:5): [True: 3.58k, False: 298k]
  ------------------
  135|  3.58k|        return RawPtr(new ExportableCert(hashed, critical));
  136|  1.64k|    case (uint8_t) Type::Trust:
  ------------------
  |  Branch (136:5): [True: 1.64k, False: 300k]
  ------------------
  137|  1.64k|        return RawPtr(new Trust(hashed, critical));
  138|  3.24k|    case (uint8_t) Type::RegExp:
  ------------------
  |  Branch (138:5): [True: 3.24k, False: 299k]
  ------------------
  139|  3.24k|        return RawPtr(new RegExp(hashed, critical));
  140|    830|    case (uint8_t) Type::Revocable:
  ------------------
  |  Branch (140:5): [True: 830, False: 301k]
  ------------------
  141|    830|        return RawPtr(new Revocable(hashed, critical));
  142|  7.63k|    case (uint8_t) Type::KeyExpirationTime:
  ------------------
  |  Branch (142:5): [True: 7.63k, False: 294k]
  ------------------
  143|  7.63k|        return RawPtr(new KeyExpirationTime(hashed, critical));
  144|  3.40k|    case (uint8_t) Type::PreferredSymmetric:
  ------------------
  |  Branch (144:5): [True: 3.40k, False: 299k]
  ------------------
  145|  3.40k|        return RawPtr(new PreferredSymmetric(hashed, critical));
  146|   194k|    case (uint8_t) Type::RevocationKey:
  ------------------
  |  Branch (146:5): [True: 194k, False: 107k]
  ------------------
  147|   194k|        return RawPtr(new RevocationKey(hashed, critical));
  148|  2.81k|    case (uint8_t) Type::IssuerKeyID:
  ------------------
  |  Branch (148:5): [True: 2.81k, False: 299k]
  ------------------
  149|  2.81k|        return RawPtr(new IssuerKeyID(hashed, critical));
  150|  4.94k|    case (uint8_t) Type::NotationData:
  ------------------
  |  Branch (150:5): [True: 4.94k, False: 297k]
  ------------------
  151|  4.94k|        return RawPtr(new NotationData(hashed, critical));
  152|  7.50k|    case (uint8_t) Type::PreferredHash:
  ------------------
  |  Branch (152:5): [True: 7.50k, False: 295k]
  ------------------
  153|  7.50k|        return RawPtr(new PreferredHash(hashed, critical));
  154|  1.96k|    case (uint8_t) Type::PreferredCompress:
  ------------------
  |  Branch (154:5): [True: 1.96k, False: 300k]
  ------------------
  155|  1.96k|        return RawPtr(new PreferredCompress(hashed, critical));
  156|  1.23k|    case (uint8_t) Type::KeyserverPrefs:
  ------------------
  |  Branch (156:5): [True: 1.23k, False: 301k]
  ------------------
  157|  1.23k|        return RawPtr(new KeyserverPrefs(hashed, critical));
  158|  3.72k|    case (uint8_t) Type::PreferredKeyserver:
  ------------------
  |  Branch (158:5): [True: 3.72k, False: 298k]
  ------------------
  159|  3.72k|        return RawPtr(new PreferredKeyserver(hashed, critical));
  160|  1.22k|    case (uint8_t) Type::PrimaryUserID:
  ------------------
  |  Branch (160:5): [True: 1.22k, False: 301k]
  ------------------
  161|  1.22k|        return RawPtr(new PrimaryUserID(hashed, critical));
  162|  2.04k|    case (uint8_t) Type::PolicyURI:
  ------------------
  |  Branch (162:5): [True: 2.04k, False: 300k]
  ------------------
  163|  2.04k|        return RawPtr(new PolicyURI(hashed, critical));
  164|  4.08k|    case (uint8_t) Type::KeyFlags:
  ------------------
  |  Branch (164:5): [True: 4.08k, False: 298k]
  ------------------
  165|  4.08k|        return RawPtr(new KeyFlags(hashed, critical));
  166|  5.85k|    case (uint8_t) Type::SignersUserID:
  ------------------
  |  Branch (166:5): [True: 5.85k, False: 296k]
  ------------------
  167|  5.85k|        return RawPtr(new SignersUserID(hashed, critical));
  168|  3.18k|    case (uint8_t) Type::RevocationReason:
  ------------------
  |  Branch (168:5): [True: 3.18k, False: 299k]
  ------------------
  169|  3.18k|        return RawPtr(new RevocationReason(hashed, critical));
  170|  2.60k|    case (uint8_t) Type::Features:
  ------------------
  |  Branch (170:5): [True: 2.60k, False: 299k]
  ------------------
  171|  2.60k|        return RawPtr(new Features(hashed, critical));
  172|  4.39k|    case (uint8_t) Type::EmbeddedSignature:
  ------------------
  |  Branch (172:5): [True: 4.39k, False: 298k]
  ------------------
  173|  4.39k|        return RawPtr(new EmbeddedSignature(hashed, critical));
  174|  3.57k|    case (uint8_t) Type::IssuerFingerprint:
  ------------------
  |  Branch (174:5): [True: 3.57k, False: 298k]
  ------------------
  175|  3.57k|        return RawPtr(new IssuerFingerprint(hashed, critical));
  176|  1.13k|    case (uint8_t) Type::PreferredAEAD:
  ------------------
  |  Branch (176:5): [True: 1.13k, False: 301k]
  ------------------
  177|  1.13k|        return RawPtr(new PreferredAEAD(hashed, critical));
  178|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  179|  1.05k|    case (uint8_t) Type::PreferredAEADv6:
  ------------------
  |  Branch (179:5): [True: 1.05k, False: 301k]
  ------------------
  180|  1.05k|        return RawPtr(new PreferredAEADv6(hashed, critical));
  181|      0|#endif
  182|  31.7k|    default:
  ------------------
  |  Branch (182:5): [True: 31.7k, False: 270k]
  ------------------
  183|  31.7k|        report_unknown(type, critical);
  184|  31.7k|        return RawPtr(new Raw(type, hashed, critical));
  185|   302k|    }
  186|   302k|}
_ZN3pgp3pkt6sigsub3Raw6createEPKhmb:
  196|   302k|{
  197|   302k|    if (!size) {
  ------------------
  |  Branch (197:9): [True: 0, False: 302k]
  ------------------
  198|      0|        RNP_LOG("got subpacket with 0 length");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  199|      0|        return nullptr;
  200|      0|    }
  201|   302k|    bool    critical = data[0] & 0x80;
  202|   302k|    uint8_t type = data[0] & 0x7f;
  203|   302k|    auto    sub = create(type, hashed, critical);
  204|   302k|    if (!sub || ((sub->type() == Type::Unknown) && critical) ||
  ------------------
  |  Branch (204:9): [True: 0, False: 302k]
  |  Branch (204:18): [True: 31.7k, False: 270k]
  |  Branch (204:52): [True: 8.57k, False: 23.1k]
  ------------------
  205|   293k|        !sub->parse(data + 1, size - 1)) {
  ------------------
  |  Branch (205:9): [True: 206k, False: 87.8k]
  ------------------
  206|   214k|        return nullptr;
  207|   214k|    }
  208|  87.8k|    return sub;
  209|   302k|}
_ZNK3pgp3pkt6sigsub3Raw5cloneEv:
  213|  1.43k|{
  214|  1.43k|    return RawPtr(new Raw(*this));
  215|  1.43k|}
_ZNK3pgp3pkt6sigsub4Time10check_sizeEm:
  227|  11.8k|{
  228|  11.8k|    return size == 4;
  229|  11.8k|}
_ZN3pgp3pkt6sigsub4Time10parse_dataEPKhm:
  233|  7.95k|{
  234|  7.95k|    time_ = read_uint32(data);
  235|  7.95k|    return true;
  236|  7.95k|}
_ZNK3pgp3pkt6sigsub12CreationTime5cloneEv:
  241|    153|{
  242|    153|    return RawPtr(new CreationTime(*this));
  243|    153|}
_ZNK3pgp3pkt6sigsub14ExpirationTime5cloneEv:
  248|     66|{
  249|     66|    return RawPtr(new ExpirationTime(*this));
  250|     66|}
_ZNK3pgp3pkt6sigsub17KeyExpirationTime5cloneEv:
  255|     66|{
  256|     66|    return RawPtr(new KeyExpirationTime(*this));
  257|     66|}
_ZNK3pgp3pkt6sigsub4Bool10check_sizeEm:
  269|  5.64k|{
  270|  5.64k|    return size == 1;
  271|  5.64k|}
_ZN3pgp3pkt6sigsub4Bool10parse_dataEPKhm:
  275|  1.69k|{
  276|  1.69k|    value_ = data[0];
  277|  1.69k|    return true;
  278|  1.69k|}
_ZNK3pgp3pkt6sigsub14ExportableCert5cloneEv:
  283|     68|{
  284|     68|    return RawPtr(new ExportableCert(*this));
  285|     68|}
_ZNK3pgp3pkt6sigsub5Trust10check_sizeEm:
  298|  1.64k|{
  299|  1.64k|    return size == 2;
  300|  1.64k|}
_ZN3pgp3pkt6sigsub5Trust10parse_dataEPKhm:
  304|  1.23k|{
  305|  1.23k|    level_ = data[0];
  306|  1.23k|    amount_ = data[1];
  307|  1.23k|    return true;
  308|  1.23k|}
_ZNK3pgp3pkt6sigsub5Trust5cloneEv:
  312|    142|{
  313|    142|    return RawPtr(new Trust(*this));
  314|    142|}
_ZN3pgp3pkt6sigsub6String10parse_dataEPKhm:
  325|  14.8k|{
  326|  14.8k|    value_.assign(data, data + size);
  327|  14.8k|    return true;
  328|  14.8k|}
_ZNK3pgp3pkt6sigsub6RegExp5cloneEv:
  333|    641|{
  334|    641|    return RawPtr(new RegExp(*this));
  335|    641|}
_ZNK3pgp3pkt6sigsub9Revocable5cloneEv:
  340|    118|{
  341|    118|    return RawPtr(new Revocable(*this));
  342|    118|}
_ZNK3pgp3pkt6sigsub9Preferred10check_sizeEm:
  353|  14.8k|{
  354|       |    /* No reason to have more then 256 bytes */
  355|  14.8k|    return size < 256;
  356|  14.8k|}
_ZN3pgp3pkt6sigsub9Preferred10parse_dataEPKhm:
  360|  14.6k|{
  361|  14.6k|    algs_.assign(data, data + size);
  362|  14.6k|    return true;
  363|  14.6k|}
_ZNK3pgp3pkt6sigsub18PreferredSymmetric5cloneEv:
  368|     72|{
  369|     72|    return RawPtr(new PreferredSymmetric(*this));
  370|     72|}
_ZNK3pgp3pkt6sigsub13PreferredHash5cloneEv:
  375|    390|{
  376|    390|    return RawPtr(new PreferredHash(*this));
  377|    390|}
_ZNK3pgp3pkt6sigsub17PreferredCompress5cloneEv:
  382|    237|{
  383|    237|    return RawPtr(new PreferredCompress(*this));
  384|    237|}
_ZNK3pgp3pkt6sigsub13PreferredAEAD5cloneEv:
  389|    268|{
  390|    268|    return RawPtr(new PreferredAEAD(*this));
  391|    268|}
_ZNK3pgp3pkt6sigsub15PreferredAEADv610check_sizeEm:
  397|  1.05k|{
  398|  1.05k|    if (size % 2) {
  ------------------
  |  Branch (398:9): [True: 252, False: 806]
  ------------------
  399|    252|        RNP_LOG("v6 AEAD Ciphersuite Preferences must contain an even number of bytes");
  ------------------
  |  |   76|    252|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    252|    do {                                                                                 \
  |  |  |  |   69|    252|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 252, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    252|            break;                                                                       \
  |  |  |  |   71|    252|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  400|    252|        return false;
  401|    252|    }
  402|    806|    return Preferred::check_size(size);
  403|  1.05k|}
_ZNK3pgp3pkt6sigsub15PreferredAEADv65cloneEv:
  407|    520|{
  408|    520|    return RawPtr(new PreferredAEADv6(*this));
  409|    520|}
_ZNK3pgp3pkt6sigsub13RevocationKey10check_sizeEm:
  424|   194k|{
  425|   194k|    return (size == 2 + PGP_FINGERPRINT_V4_SIZE) || (size == 2 + PGP_FINGERPRINT_V5_SIZE);
  ------------------
  |  |   43|   194k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
                  return (size == 2 + PGP_FINGERPRINT_V4_SIZE) || (size == 2 + PGP_FINGERPRINT_V5_SIZE);
  ------------------
  |  |   44|   194k|#define PGP_FINGERPRINT_V5_SIZE 32
  ------------------
  |  Branch (425:12): [True: 509, False: 194k]
  |  Branch (425:53): [True: 2.03k, False: 192k]
  ------------------
  426|   194k|}
_ZN3pgp3pkt6sigsub13RevocationKey10parse_dataEPKhm:
  430|  2.54k|{
  431|  2.54k|    rev_class_ = data[0];
  432|  2.54k|    alg_ = static_cast<pgp_pubkey_alg_t>(data[1]);
  433|  2.54k|    fp_ = pgp::Fingerprint(data + 2, size - 2);
  434|  2.54k|    return true;
  435|  2.54k|}
_ZNK3pgp3pkt6sigsub13RevocationKey5cloneEv:
  439|    178|{
  440|    178|    return RawPtr(new RevocationKey(*this));
  441|    178|}
_ZNK3pgp3pkt6sigsub11IssuerKeyID10check_sizeEm:
  452|  2.81k|{
  453|  2.81k|    return size == PGP_KEY_ID_SIZE;
  ------------------
  |  |   39|  2.81k|#define PGP_KEY_ID_SIZE 8
  ------------------
  454|  2.81k|}
_ZN3pgp3pkt6sigsub11IssuerKeyID10parse_dataEPKhm:
  458|  2.48k|{
  459|  2.48k|    memcpy(keyid_.data(), data, keyid_.size());
  460|  2.48k|    return true;
  461|  2.48k|}
_ZNK3pgp3pkt6sigsub11IssuerKeyID5cloneEv:
  465|    320|{
  466|    320|    return RawPtr(new IssuerKeyID(*this));
  467|    320|}
_ZNK3pgp3pkt6sigsub12NotationData10check_sizeEm:
  487|  4.94k|{
  488|  4.94k|    return size >= 8;
  489|  4.94k|}
_ZN3pgp3pkt6sigsub12NotationData10parse_dataEPKhm:
  493|  4.71k|{
  494|  4.71k|    size_t nlen = read_uint16(data + 4);
  495|  4.71k|    size_t vlen = read_uint16(data + 6);
  496|  4.71k|    if (size != nlen + vlen + 8) {
  ------------------
  |  Branch (496:9): [True: 2.49k, False: 2.21k]
  ------------------
  497|  2.49k|        return false;
  498|  2.49k|    }
  499|  2.21k|    memcpy(flags_.data(), data, 4);
  500|  2.21k|    name_.assign(data + 8, data + 8 + nlen);
  501|  2.21k|    value_.assign(data + 8 + nlen, data + 8 + nlen + vlen);
  502|  2.21k|    return true;
  503|  4.71k|}
_ZNK3pgp3pkt6sigsub12NotationData5cloneEv:
  537|    132|{
  538|    132|    return RawPtr(new NotationData(*this));
  539|    132|}
_ZNK3pgp3pkt6sigsub5Flags10check_sizeEm:
  551|  7.92k|{
  552|  7.92k|    return size >= 1;
  553|  7.92k|}
_ZN3pgp3pkt6sigsub5Flags10parse_dataEPKhm:
  557|  7.30k|{
  558|  7.30k|    flags_ = data[0];
  559|  7.30k|    return true;
  560|  7.30k|}
_ZNK3pgp3pkt6sigsub14KeyserverPrefs5cloneEv:
  565|    275|{
  566|    275|    return RawPtr(new KeyserverPrefs(*this));
  567|    275|}
_ZNK3pgp3pkt6sigsub18PreferredKeyserver5cloneEv:
  572|    489|{
  573|    489|    return RawPtr(new PreferredKeyserver(*this));
  574|    489|}
_ZNK3pgp3pkt6sigsub13PrimaryUserID5cloneEv:
  579|    215|{
  580|    215|    return RawPtr(new PrimaryUserID(*this));
  581|    215|}
_ZNK3pgp3pkt6sigsub9PolicyURI5cloneEv:
  586|    465|{
  587|    465|    return RawPtr(new PolicyURI(*this));
  588|    465|}
_ZNK3pgp3pkt6sigsub8KeyFlags5cloneEv:
  593|    100|{
  594|    100|    return RawPtr(new KeyFlags(*this));
  595|    100|}
_ZNK3pgp3pkt6sigsub13SignersUserID5cloneEv:
  600|    495|{
  601|    495|    return RawPtr(new SignersUserID(*this));
  602|    495|}
_ZNK3pgp3pkt6sigsub16RevocationReason10check_sizeEm:
  615|  3.18k|{
  616|  3.18k|    return size >= 1;
  617|  3.18k|}
_ZN3pgp3pkt6sigsub16RevocationReason10parse_dataEPKhm:
  621|  3.16k|{
  622|  3.16k|    code_ = static_cast<pgp_revocation_type_t>(data[0]);
  623|  3.16k|    reason_.assign(data + 1, data + size);
  624|  3.16k|    return true;
  625|  3.16k|}
_ZNK3pgp3pkt6sigsub16RevocationReason5cloneEv:
  629|    765|{
  630|    765|    return RawPtr(new RevocationReason(*this));
  631|    765|}
_ZNK3pgp3pkt6sigsub8Features5cloneEv:
  636|    467|{
  637|    467|    return RawPtr(new Features(*this));
  638|    467|}
_ZN3pgp3pkt6sigsub17EmbeddedSignatureC2ERKS2_:
  641|    250|EmbeddedSignature::EmbeddedSignature(const EmbeddedSignature &src) : Raw(src)
  642|    250|{
  643|    250|    signature_ = std::unique_ptr<Signature>(new Signature(*src.signature_));
  644|    250|}
_ZN3pgp3pkt6sigsub17EmbeddedSignatureC2Ebb:
  647|  4.39k|    : Raw(Type::EmbeddedSignature, hashed, critical)
  648|  4.39k|{
  649|  4.39k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature10check_sizeEm:
  666|  4.39k|{
  667|  4.39k|    return size > 6;
  668|  4.39k|}
_ZN3pgp3pkt6sigsub17EmbeddedSignature10parse_dataEPKhm:
  672|  3.96k|{
  673|  3.96k|    pgp_packet_body_t pkt(data, size);
  674|  3.96k|    Signature         sig;
  675|  3.96k|    if (sig.parse(pkt)) {
  ------------------
  |  Branch (675:9): [True: 652, False: 3.30k]
  ------------------
  676|    652|        return false;
  677|    652|    }
  678|  3.30k|    signature_ = std::unique_ptr<Signature>(new Signature(std::move(sig)));
  679|  3.30k|    return true;
  680|  3.96k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature9signatureEv:
  684|  1.69k|{
  685|  1.69k|    return signature_.get();
  686|  1.69k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature5cloneEv:
  703|    250|{
  704|    250|    return RawPtr(new EmbeddedSignature(*this));
  705|    250|}
_ZNK3pgp3pkt6sigsub17IssuerFingerprint10check_sizeEm:
  718|  3.57k|{
  719|  3.57k|    return (size >= 21) && (size <= PGP_MAX_FINGERPRINT_SIZE + 1);
  ------------------
  |  |   45|  3.19k|#define PGP_MAX_FINGERPRINT_SIZE 32
  ------------------
  |  Branch (719:12): [True: 3.19k, False: 383]
  |  Branch (719:28): [True: 3.15k, False: 40]
  ------------------
  720|  3.57k|}
_ZN3pgp3pkt6sigsub17IssuerFingerprint10parse_dataEPKhm:
  724|  3.15k|{
  725|  3.15k|    version_ = data[0];
  726|  3.15k|    fp_ = pgp::Fingerprint(data + 1, size - 1);
  727|  3.15k|    return true;
  728|  3.15k|}
_ZNK3pgp3pkt6sigsub17IssuerFingerprint5cloneEv:
  732|    150|{
  733|    150|    return RawPtr(new IssuerFingerprint(*this));
  734|    150|}
_ZN3pgp3pkt6sigsub4ListC2ERKS2_:
  737|  4.12k|{
  738|  4.12k|    items.reserve(src.items.size());
  739|  8.47k|    for (auto &item : src.items) {
  ------------------
  |  Branch (739:21): [True: 8.47k, False: 4.12k]
  ------------------
  740|  8.47k|        items.push_back(item->clone());
  741|  8.47k|    }
  742|  4.12k|}
sig_subpacket.cpp:_ZN3pgp3pkt6sigsubL14report_unknownEhb:
   93|  31.7k|{
   94|  31.7k|    switch (type) {
   95|    454|    case (uint8_t) Type::Private_100:
  ------------------
  |  Branch (95:5): [True: 454, False: 31.3k]
  ------------------
   96|    766|    case (uint8_t) Type::Private_101:
  ------------------
  |  Branch (96:5): [True: 312, False: 31.4k]
  ------------------
   97|  1.06k|    case (uint8_t) Type::Private_102:
  ------------------
  |  Branch (97:5): [True: 300, False: 31.4k]
  ------------------
   98|  1.37k|    case (uint8_t) Type::Private_103:
  ------------------
  |  Branch (98:5): [True: 308, False: 31.4k]
  ------------------
   99|  1.72k|    case (uint8_t) Type::Private_104:
  ------------------
  |  Branch (99:5): [True: 352, False: 31.4k]
  ------------------
  100|  2.24k|    case (uint8_t) Type::Private_105:
  ------------------
  |  Branch (100:5): [True: 515, False: 31.2k]
  ------------------
  101|  2.55k|    case (uint8_t) Type::Private_106:
  ------------------
  |  Branch (101:5): [True: 314, False: 31.4k]
  ------------------
  102|  4.35k|    case (uint8_t) Type::Private_107:
  ------------------
  |  Branch (102:5): [True: 1.79k, False: 29.9k]
  ------------------
  103|  4.59k|    case (uint8_t) Type::Private_108:
  ------------------
  |  Branch (103:5): [True: 246, False: 31.5k]
  ------------------
  104|  4.90k|    case (uint8_t) Type::Private_109:
  ------------------
  |  Branch (104:5): [True: 313, False: 31.4k]
  ------------------
  105|  5.42k|    case (uint8_t) Type::Private_110:
  ------------------
  |  Branch (105:5): [True: 514, False: 31.2k]
  ------------------
  106|  5.42k|        if (critical) {
  ------------------
  |  Branch (106:13): [True: 2.19k, False: 3.22k]
  ------------------
  107|  2.19k|            RNP_LOG("unknown critical private subpacket %" PRIu8, type);
  ------------------
  |  |   76|  2.19k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.19k|    do {                                                                                 \
  |  |  |  |   69|  2.19k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.19k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.19k|            break;                                                                       \
  |  |  |  |   71|  2.19k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  108|  2.19k|        }
  109|  5.42k|        return;
  110|  2.68k|    case (uint8_t) Type::Reserved_1:
  ------------------
  |  Branch (110:5): [True: 2.68k, False: 29.0k]
  ------------------
  111|  4.06k|    case (uint8_t) Type::Reserved_8:
  ------------------
  |  Branch (111:5): [True: 1.37k, False: 30.3k]
  ------------------
  112|  4.55k|    case (uint8_t) Type::Placeholder:
  ------------------
  |  Branch (112:5): [True: 490, False: 31.2k]
  ------------------
  113|  5.08k|    case (uint8_t) Type::Reserved_13:
  ------------------
  |  Branch (113:5): [True: 530, False: 31.2k]
  ------------------
  114|  5.42k|    case (uint8_t) Type::Reserved_14:
  ------------------
  |  Branch (114:5): [True: 340, False: 31.4k]
  ------------------
  115|  5.65k|    case (uint8_t) Type::Reserved_15:
  ------------------
  |  Branch (115:5): [True: 236, False: 31.5k]
  ------------------
  116|  6.33k|    case (uint8_t) Type::Reserved_17:
  ------------------
  |  Branch (116:5): [True: 673, False: 31.0k]
  ------------------
  117|  7.19k|    case (uint8_t) Type::Reserved_18:
  ------------------
  |  Branch (117:5): [True: 866, False: 30.9k]
  ------------------
  118|  7.57k|    case (uint8_t) Type::Reserved_19:
  ------------------
  |  Branch (118:5): [True: 378, False: 31.3k]
  ------------------
  119|       |        /* do not report reserved/placeholder subpacket */
  120|  7.57k|        return;
  121|  18.7k|    default:
  ------------------
  |  Branch (121:5): [True: 18.7k, False: 12.9k]
  ------------------
  122|  18.7k|        RNP_LOG("unknown subpacket : %" PRIu8, type);
  ------------------
  |  |   76|  18.7k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  18.7k|    do {                                                                                 \
  |  |  |  |   69|  18.7k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 18.7k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  18.7k|            break;                                                                       \
  |  |  |  |   71|  18.7k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  123|  31.7k|    }
  124|  31.7k|}

_ZNK3pgp3pkt6sigsub3Raw8raw_typeEv:
  125|  77.1k|    {
  126|  77.1k|        return raw_type_;
  127|  77.1k|    }
_ZNK3pgp3pkt6sigsub3Raw4dataEv:
  131|   102k|    {
  132|   102k|        return data_;
  133|   102k|    }
_ZNK3pgp3pkt6sigsub3Raw4typeEv:
  137|   353k|    {
  138|   353k|        return type_;
  139|   353k|    }
_ZNK3pgp3pkt6sigsub3Raw8criticalEv:
  143|  51.3k|    {
  144|  51.3k|        return critical_;
  145|  51.3k|    }
_ZNK3pgp3pkt6sigsub3Raw6hashedEv:
  155|  77.1k|    {
  156|  77.1k|        return hashed_;
  157|  77.1k|    }
_ZN3pgp3pkt6sigsub4TimeC2ENS1_4TypeEbb:
  183|  11.8k|    Time(Type type, bool hashed, bool critical) : Raw(type, hashed, critical), time_(0)
  184|  11.8k|    {
  185|  11.8k|    }
_ZNK3pgp3pkt6sigsub4Time4timeEv:
  189|  6.78k|    {
  190|  6.78k|        return time_;
  191|  6.78k|    }
_ZN3pgp3pkt6sigsub12CreationTimeC2Ebb:
  207|  2.46k|        : Time(Type::CreationTime, hashed, critical)
  208|  2.46k|    {
  209|  2.46k|    }
_ZN3pgp3pkt6sigsub14ExpirationTimeC2Ebb:
  218|  1.77k|        : Time(Type::ExpirationTime, hashed, critical)
  219|  1.77k|    {
  220|  1.77k|    }
_ZN3pgp3pkt6sigsub17KeyExpirationTimeC2Ebb:
  229|  7.63k|        : Time(Type::KeyExpirationTime, hashed, critical)
  230|  7.63k|    {
  231|  7.63k|    }
_ZN3pgp3pkt6sigsub4BoolC2ENS1_4TypeEbb:
  246|  5.64k|    Bool(Type type, bool hashed, bool critical) : Raw(type, hashed, critical), value_(false)
  247|  5.64k|    {
  248|  5.64k|    }
_ZN3pgp3pkt6sigsub14ExportableCertC2Ebb:
  257|  3.58k|        : Bool(Type::ExportableCert, hashed, critical)
  258|  3.58k|    {
  259|  3.58k|        value_ = true;
  260|  3.58k|    }
_ZNK3pgp3pkt6sigsub14ExportableCert10exportableEv:
  264|    172|    {
  265|    172|        return value_;
  266|    172|    }
_ZN3pgp3pkt6sigsub5TrustC2Ebb:
  291|  1.64k|        : Raw(Type::Trust, hashed, critical), level_(0), amount_(0)
  292|  1.64k|    {
  293|  1.64k|    }
_ZNK3pgp3pkt6sigsub5Trust5levelEv:
  297|    426|    {
  298|    426|        return level_;
  299|    426|    }
_ZNK3pgp3pkt6sigsub5Trust6amountEv:
  303|    426|    {
  304|    426|        return amount_;
  305|    426|    }
_ZN3pgp3pkt6sigsub6StringC2ENS1_4TypeEbb:
  334|  14.8k|    String(Type type, bool hashed, bool critical) : Raw(type, hashed, critical)
  335|  14.8k|    {
  336|  14.8k|    }
_ZN3pgp3pkt6sigsub6RegExpC2Ebb:
  344|  3.24k|    RegExp(bool hashed = true, bool critical = false) : String(Type::RegExp, hashed, critical)
  345|  3.24k|    {
  346|  3.24k|    }
_ZNK3pgp3pkt6sigsub6RegExp6regexpEv:
  350|  1.14k|    {
  351|  1.14k|        return value_;
  352|  1.14k|    }
_ZN3pgp3pkt6sigsub9RevocableC2Ebb:
  361|    830|        : Bool(Type::Revocable, hashed, critical)
  362|    830|    {
  363|    830|        value_ = true;
  364|    830|    }
_ZNK3pgp3pkt6sigsub9Revocable9revocableEv:
  368|    220|    {
  369|    220|        return value_;
  370|    220|    }
_ZN3pgp3pkt6sigsub9PreferredC2ENS1_4TypeEbb:
  393|  15.0k|    Preferred(Type type, bool hashed, bool critical) : Raw(type, hashed, critical){};
_ZNK3pgp3pkt6sigsub9Preferred4algsEv:
  397|  5.86k|    {
  398|  5.86k|        return algs_;
  399|  5.86k|    }
_ZN3pgp3pkt6sigsub18PreferredSymmetricC2Ebb:
  415|  3.40k|        : Preferred(Type::PreferredSymmetric, hashed, critical){};
_ZN3pgp3pkt6sigsub13PreferredHashC2Ebb:
  424|  7.50k|        : Preferred(Type::PreferredHash, hashed, critical){};
_ZN3pgp3pkt6sigsub17PreferredCompressC2Ebb:
  433|  1.96k|        : Preferred(Type::PreferredCompress, hashed, critical){};
_ZN3pgp3pkt6sigsub13PreferredAEADC2Ebb:
  442|  1.13k|        : Preferred(Type::PreferredAEAD, hashed, critical){};
_ZN3pgp3pkt6sigsub15PreferredAEADv6C2Ebb:
  455|  1.05k|        : Preferred(Type::PreferredAEADv6, hashed, critical){};
_ZN3pgp3pkt6sigsub13RevocationKeyC2Ebb:
  475|   194k|        : Raw(Type::RevocationKey, hashed, critical), rev_class_(0),
  476|   194k|          alg_(PGP_PKA_NOTHING), fp_{} {};
_ZNK3pgp3pkt6sigsub13RevocationKey9rev_classEv:
  480|  2.02k|    {
  481|  2.02k|        return rev_class_;
  482|  2.02k|    }
_ZNK3pgp3pkt6sigsub13RevocationKey3algEv:
  493|  2.02k|    {
  494|  2.02k|        return alg_;
  495|  2.02k|    }
_ZNK3pgp3pkt6sigsub13RevocationKey2fpEv:
  506|  2.02k|    {
  507|  2.02k|        return fp_;
  508|  2.02k|    }
_ZN3pgp3pkt6sigsub11IssuerKeyIDC2Ebb:
  532|  2.81k|        : Raw(Type::IssuerKeyID, hashed, critical)
  533|  2.81k|    {
  534|  2.81k|    }
_ZNK3pgp3pkt6sigsub11IssuerKeyID5keyidEv:
  538|  1.18k|    {
  539|  1.18k|        return keyid_;
  540|  1.18k|    }
_ZN3pgp3pkt6sigsub12NotationDataC2Ebb:
  566|  4.94k|        : Raw(Type::NotationData, hashed, critical)
  567|  4.94k|    {
  568|  4.94k|    }
_ZNK3pgp3pkt6sigsub12NotationData14human_readableEv:
  572|  2.87k|    {
  573|  2.87k|        return flags_[0] & 0x80;
  574|  2.87k|    }
_ZNK3pgp3pkt6sigsub12NotationData4nameEv:
  580|  1.91k|    {
  581|  1.91k|        return name_;
  582|  1.91k|    }
_ZNK3pgp3pkt6sigsub12NotationData5valueEv:
  588|  3.83k|    {
  589|  3.83k|        return value_;
  590|  3.83k|    }
_ZN3pgp3pkt6sigsub5FlagsC2ENS1_4TypeEbb:
  608|  7.92k|        : Raw(type, hashed, critical), flags_(0)
  609|  7.92k|    {
  610|  7.92k|    }
_ZN3pgp3pkt6sigsub14KeyserverPrefsC2Ebb:
  619|  1.23k|        : Flags(Type::KeyserverPrefs, hashed, critical)
  620|  1.23k|    {
  621|  1.23k|    }
_ZNK3pgp3pkt6sigsub14KeyserverPrefs9no_modifyEv:
  625|    430|    {
  626|    430|        return flags_ & 0x80;
  627|    430|    }
_ZN3pgp3pkt6sigsub18PreferredKeyserverC2Ebb:
  656|  3.72k|        : String(Type::PreferredKeyserver, hashed, critical)
  657|  3.72k|    {
  658|  3.72k|    }
_ZNK3pgp3pkt6sigsub18PreferredKeyserver9keyserverEv:
  662|  1.02k|    {
  663|  1.02k|        return value_;
  664|  1.02k|    }
_ZN3pgp3pkt6sigsub13PrimaryUserIDC2Ebb:
  680|  1.22k|        : Bool(Type::PrimaryUserID, hashed, critical)
  681|  1.22k|    {
  682|  1.22k|    }
_ZNK3pgp3pkt6sigsub13PrimaryUserID7primaryEv:
  686|    510|    {
  687|    510|        return value_;
  688|    510|    }
_ZN3pgp3pkt6sigsub9PolicyURIC2Ebb:
  704|  2.04k|        : String(Type::PolicyURI, hashed, critical)
  705|  2.04k|    {
  706|  2.04k|    }
_ZNK3pgp3pkt6sigsub9PolicyURI3URIEv:
  710|    942|    {
  711|    942|        return value_;
  712|    942|    }
_ZN3pgp3pkt6sigsub8KeyFlagsC2Ebb:
  721|  4.08k|        : Flags(Type::KeyFlags, hashed, critical)
  722|  4.08k|    {
  723|  4.08k|    }
_ZNK3pgp3pkt6sigsub8KeyFlags5flagsEv:
  727|  2.87k|    {
  728|  2.87k|        return flags_;
  729|  2.87k|    }
_ZN3pgp3pkt6sigsub13SignersUserIDC2Ebb:
  745|  5.85k|        : String(Type::SignersUserID, hashed, critical)
  746|  5.85k|    {
  747|  5.85k|    }
_ZNK3pgp3pkt6sigsub13SignersUserID6signerEv:
  751|  5.02k|    {
  752|  5.02k|        return value_;
  753|  5.02k|    }
_ZN3pgp3pkt6sigsub16RevocationReasonC2Ebb:
  778|  3.18k|        : Raw(Type::RevocationReason, hashed, critical), code_(PGP_REVOCATION_NO_REASON)
  779|  3.18k|    {
  780|  3.18k|    }
_ZNK3pgp3pkt6sigsub16RevocationReason4codeEv:
  784|  1.92k|    {
  785|  1.92k|        return code_;
  786|  1.92k|    }
_ZNK3pgp3pkt6sigsub16RevocationReason6reasonEv:
  797|  1.28k|    {
  798|  1.28k|        return reason_;
  799|  1.28k|    }
_ZN3pgp3pkt6sigsub8FeaturesC2Ebb:
  815|  2.60k|        : Flags(Type::Features, hashed, critical)
  816|  2.60k|    {
  817|  2.60k|    }
_ZNK3pgp3pkt6sigsub8Features8featuresEv:
  821|  7.86k|    {
  822|  7.86k|        return flags_;
  823|  7.86k|    }
_ZN3pgp3pkt6sigsub17IssuerFingerprintC2Ebb:
  871|  3.57k|        : Raw(Type::IssuerFingerprint, hashed, critical), version_(0), fp_{}
  872|  3.57k|    {
  873|  3.57k|    }
_ZNK3pgp3pkt6sigsub17IssuerFingerprint2fpEv:
  890|  2.31k|    {
  891|  2.31k|        return fp_;
  892|  2.31k|    }
_ZN3pgp3pkt6sigsub4ListC2Ev:
  909|  51.2k|    {
  910|  51.2k|    }
_ZNK3pgp3pkt6sigsub4List5beginEv:
  928|  26.6k|    {
  929|  26.6k|        return items.begin();
  930|  26.6k|    }
_ZNK3pgp3pkt6sigsub4List3endEv:
  934|  26.6k|    {
  935|  26.6k|        return items.end();
  936|  26.6k|    }
_ZNK3pgp3pkt6sigsub4List4sizeEv:
  940|   305k|    {
  941|   305k|        return items.size();
  942|   305k|    }

_ZN14pgp_aead_hdr_tC2Ev:
  175|  1.28k|    pgp_aead_hdr_t() : ealg(PGP_SA_UNKNOWN), aalg(PGP_AEAD_NONE)
  176|  1.28k|    {
  177|  1.28k|    }

_ZN11id_str_pair6lookupEPKS_iPKc:
   32|   470k|{
   33|  4.51M|    while (pair && pair->str) {
  ------------------
  |  Branch (33:12): [True: 4.51M, False: 0]
  |  Branch (33:20): [True: 4.37M, False: 132k]
  ------------------
   34|  4.37M|        if (pair->id == id) {
  ------------------
  |  Branch (34:13): [True: 337k, False: 4.04M]
  ------------------
   35|   337k|            return pair->str;
   36|   337k|        }
   37|  4.04M|        pair++;
   38|  4.04M|    }
   39|   132k|    return notfound;
   40|   470k|}

_Z11read_uint16PKh:
   61|   236k|{
   62|   236k|    return ((uint16_t) buf[0] << 8) | buf[1];
   63|   236k|}
_Z11read_uint32PKh:
   68|   101k|{
   69|   101k|    return ((uint32_t) buf[0] << 24) | ((uint32_t) buf[1] << 16) | ((uint32_t) buf[2] << 8) |
   70|   101k|           (uint32_t) buf[3];
   71|   101k|}
_Z12write_uint16Pht:
   76|  29.8k|{
   77|  29.8k|    buf[0] = val >> 8;
   78|  29.8k|    buf[1] = val & 0xff;
   79|  29.8k|}
_Z12write_uint32Phj:
   84|  13.8k|{
   85|  13.8k|    buf[0] = (uint8_t)(val >> 24) & 0xff;
   86|  13.8k|    buf[1] = (uint8_t)(val >> 16) & 0xff;
   87|  13.8k|    buf[2] = (uint8_t)(val >> 8) & 0xff;
   88|  13.8k|    buf[3] = (uint8_t)(val >> 0) & 0xff;
   89|  13.8k|}

_Z16init_armored_srcP12pgp_source_tS0_b:
  705|  1.82k|{
  706|  1.82k|    if (!init_src_common(src, 0)) {
  ------------------
  |  Branch (706:9): [True: 0, False: 1.82k]
  ------------------
  707|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  708|      0|    }
  709|  1.82k|    pgp_source_armored_param_t *param = new (std::nothrow) pgp_source_armored_param_t();
  710|  1.82k|    if (!param) {
  ------------------
  |  Branch (710:9): [True: 0, False: 1.82k]
  ------------------
  711|      0|        RNP_LOG("allocation failed");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  712|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  713|      0|    }
  714|       |
  715|  1.82k|    param->readsrc = readsrc;
  716|  1.82k|    param->noheaders = noheaders;
  717|  1.82k|    src->param = param;
  718|  1.82k|    src->raw_read = armored_src_read;
  719|  1.82k|    src->raw_close = armored_src_close;
  720|  1.82k|    src->type = PGP_STREAM_ARMORED;
  721|       |
  722|       |    /* base64 data only */
  723|  1.82k|    if (noheaders) {
  ------------------
  |  Branch (723:9): [True: 0, False: 1.82k]
  ------------------
  724|      0|        return RNP_SUCCESS;
  725|      0|    }
  726|       |
  727|       |    /* initialize crc context */
  728|  1.82k|    param->crc_ctx = rnp::CRC24::create();
  729|       |    /* parsing armored header */
  730|  1.82k|    rnp_result_t errcode = RNP_ERROR_GENERIC;
  731|  1.82k|    if (!armor_parse_header(param)) {
  ------------------
  |  Branch (731:9): [True: 462, False: 1.36k]
  ------------------
  732|    462|        errcode = RNP_ERROR_BAD_FORMAT;
  733|    462|        goto finish;
  734|    462|    }
  735|       |    /* eol */
  736|  1.36k|    if (!param->readsrc->skip_eol()) {
  ------------------
  |  Branch (736:9): [True: 68, False: 1.29k]
  ------------------
  737|     68|        RNP_LOG("no eol after the armor header");
  ------------------
  |  |   76|     68|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     68|    do {                                                                                 \
  |  |  |  |   69|     68|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 68, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     68|            break;                                                                       \
  |  |  |  |   71|     68|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  738|     68|        errcode = RNP_ERROR_BAD_FORMAT;
  739|     68|        goto finish;
  740|     68|    }
  741|       |    /* parsing headers */
  742|  1.29k|    if (!armor_parse_headers(param)) {
  ------------------
  |  Branch (742:9): [True: 482, False: 810]
  ------------------
  743|    482|        RNP_LOG("failed to parse headers");
  ------------------
  |  |   76|    482|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    482|    do {                                                                                 \
  |  |  |  |   69|    482|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 482, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    482|            break;                                                                       \
  |  |  |  |   71|    482|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  744|    482|        errcode = RNP_ERROR_BAD_FORMAT;
  745|    482|        goto finish;
  746|    482|    }
  747|       |
  748|       |    /* now we are good to go with base64-encoded data */
  749|    810|    errcode = RNP_SUCCESS;
  750|  1.82k|finish:
  751|  1.82k|    if (errcode) {
  ------------------
  |  Branch (751:9): [True: 1.01k, False: 810]
  ------------------
  752|  1.01k|        src->close();
  753|  1.01k|    }
  754|  1.82k|    return errcode;
  755|    810|}
_ZN12pgp_source_t10is_armoredEv:
 1050|  15.6k|{
 1051|  15.6k|    char   buf[ARMORED_PEEK_BUF_SIZE] = {0};
 1052|  15.6k|    size_t read = 0;
 1053|       |
 1054|  15.6k|    if (!peek(buf, sizeof(buf) - 1, &read) || (read < strlen(ST_ARMOR_BEGIN) + 1)) {
  ------------------
  |  |   46|  15.6k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  |  Branch (1054:9): [True: 0, False: 15.6k]
  |  Branch (1054:47): [True: 6.73k, False: 8.90k]
  ------------------
 1055|  6.73k|        return false;
 1056|  6.73k|    }
 1057|  8.90k|    buf[read] = 0;
 1058|  8.90k|    if (!!strstr(buf, ST_CLEAR_BEGIN)) {
  ------------------
  |  |   48|  8.90k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
  |  Branch (1058:9): [True: 6, False: 8.89k]
  ------------------
 1059|      6|        return false;
 1060|      6|    }
 1061|  8.89k|    return !!strstr(buf, ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  8.89k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
 1062|  8.90k|}
_ZN12pgp_source_t12is_cleartextEv:
 1066|  15.6k|{
 1067|  15.6k|    char   buf[ARMORED_PEEK_BUF_SIZE] = {0};
 1068|  15.6k|    size_t read = 0;
 1069|       |
 1070|  15.6k|    if (!peek(buf, sizeof(buf) - 1, &read) || (read < strlen(ST_CLEAR_BEGIN))) {
  ------------------
  |  |   48|  15.6k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
  |  Branch (1070:9): [True: 0, False: 15.6k]
  |  Branch (1070:47): [True: 11.0k, False: 4.60k]
  ------------------
 1071|  11.0k|        return false;
 1072|  11.0k|    }
 1073|  4.60k|    buf[read] = 0;
 1074|  4.60k|    return !!strstr(buf, ST_CLEAR_BEGIN);
  ------------------
  |  |   48|  4.60k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
 1075|  15.6k|}
stream-armor.cpp:_ZL22armor_str_to_data_typeRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  481|  1.67k|{
  482|  1.67k|    if ((str == "MESSAGE") || (str == "ARMORED FILE")) {
  ------------------
  |  Branch (482:9): [True: 1.20k, False: 476]
  |  Branch (482:31): [True: 4, False: 472]
  ------------------
  483|  1.20k|        return PGP_ARMORED_MESSAGE;
  484|  1.20k|    }
  485|    472|    if ((str == "PUBLIC KEY BLOCK") || (str == "PUBLIC KEY")) {
  ------------------
  |  Branch (485:9): [True: 88, False: 384]
  |  Branch (485:40): [True: 6, False: 378]
  ------------------
  486|     94|        return PGP_ARMORED_PUBLIC_KEY;
  487|     94|    }
  488|    378|    if ((str == "SECRET KEY BLOCK") || (str == "SECRET KEY") || (str == "PRIVATE KEY BLOCK") ||
  ------------------
  |  Branch (488:9): [True: 2, False: 376]
  |  Branch (488:40): [True: 2, False: 374]
  |  Branch (488:65): [True: 8, False: 366]
  ------------------
  489|    366|        (str == "PRIVATE KEY")) {
  ------------------
  |  Branch (489:9): [True: 2, False: 364]
  ------------------
  490|     14|        return PGP_ARMORED_SECRET_KEY;
  491|     14|    }
  492|    364|    if (str == "SIGNATURE") {
  ------------------
  |  Branch (492:9): [True: 48, False: 316]
  ------------------
  493|     48|        return PGP_ARMORED_SIGNATURE;
  494|     48|    }
  495|    316|    return PGP_ARMORED_UNKNOWN;
  496|    364|}
stream-armor.cpp:_ZL17peek_armor_headerR12pgp_source_tPmb:
  563|  1.82k|{
  564|  1.82k|    std::string hdr(ARMORED_PEEK_BUF_SIZE, '\0');
  ------------------
  |  |   46|  1.82k|#define ARMORED_PEEK_BUF_SIZE 1024
  ------------------
  565|  1.82k|    size_t      read = 0;
  566|  1.82k|    if (skip) {
  ------------------
  |  Branch (566:9): [True: 1.82k, False: 0]
  ------------------
  567|  1.82k|        *skip = 0;
  568|  1.82k|    }
  569|  1.82k|    if (!src.peek(&hdr.front(), hdr.size(), &read) || (read < 20)) {
  ------------------
  |  Branch (569:9): [True: 0, False: 1.82k]
  |  Branch (569:55): [True: 4, False: 1.81k]
  ------------------
  570|      4|        return "";
  571|      4|    }
  572|  1.81k|    hdr.resize(read);
  573|       |
  574|  1.81k|    std::string type;
  575|  1.81k|    size_t      armhdrlen = 0;
  576|  1.81k|    size_t      pos = find_armor_header(hdr, armhdrlen, type);
  577|  1.81k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (577:9): [True: 112, False: 1.70k]
  ------------------
  578|    112|        return "";
  579|    112|    }
  580|       |
  581|       |    /* if there are non-whitespaces before the armor header then issue warning */
  582|  2.10k|    for (size_t idx = 0; check && (idx < pos); idx++) {
  ------------------
  |  Branch (582:26): [True: 2.10k, False: 0]
  |  Branch (582:35): [True: 724, False: 1.38k]
  ------------------
  583|    724|        if (B64DEC[(uint8_t) hdr[idx]] != 0xfd) {
  ------------------
  |  Branch (583:13): [True: 322, False: 402]
  ------------------
  584|    322|            RNP_LOG("extra data before the header line");
  ------------------
  |  |   76|    322|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    322|    do {                                                                                 \
  |  |  |  |   69|    322|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 322, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    322|            break;                                                                       \
  |  |  |  |   71|    322|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|    322|            break;
  586|    322|        }
  587|    724|    }
  588|       |
  589|  1.70k|    if (skip) {
  ------------------
  |  Branch (589:9): [True: 1.70k, False: 0]
  ------------------
  590|  1.70k|        *skip = armhdrlen;
  591|  1.70k|    }
  592|  1.70k|    return type;
  593|  1.81k|}
stream-armor.cpp:_ZL17find_armor_headerRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERmRS5_:
  464|  1.81k|{
  465|  1.81k|    size_t bg_len = strlen(ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  1.81k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  466|  1.81k|    size_t pos = str.find(ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  1.81k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  467|  1.81k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (467:9): [True: 0, False: 1.81k]
  ------------------
  468|      0|        return pos;
  469|      0|    }
  470|  1.81k|    size_t end = str.find(ST_DASHES, pos + bg_len);
  ------------------
  |  |   45|  1.81k|#define ST_DASHES ("-----")
  ------------------
  471|  1.81k|    if (end == std::string::npos) {
  ------------------
  |  Branch (471:9): [True: 112, False: 1.70k]
  ------------------
  472|    112|        return end;
  473|    112|    }
  474|  1.70k|    hdrlen = end + 5;
  475|  1.70k|    type.assign(str.begin() + pos + bg_len, str.begin() + end);
  476|  1.70k|    return pos;
  477|  1.81k|}
stream-armor.cpp:_ZL16armored_src_readP12pgp_source_tPvmPm:
  242|  2.58k|{
  243|  2.58k|    pgp_source_armored_param_t *param = (pgp_source_armored_param_t *) src->param;
  244|  2.58k|    uint8_t  b64buf[ARMORED_BLOCK_SIZE];     /* input base64 data with spaces and so on */
  245|  2.58k|    uint8_t  decbuf[ARMORED_BLOCK_SIZE + 4]; /* decoded 6-bit values */
  246|  2.58k|    uint8_t *bufptr = (uint8_t *) buf;       /* for better readability below */
  247|  2.58k|    uint8_t *bptr, *bend;                    /* pointer to input data in b64buf */
  248|  2.58k|    uint8_t *dptr, *dend, *pend; /* pointers to decoded data in decbuf: working pointer, last
  249|       |                                    available byte, last byte to process */
  250|  2.58k|    uint8_t  bval;
  251|  2.58k|    uint32_t b24;
  252|  2.58k|    size_t   read = 0;
  253|  2.58k|    size_t   left = len;
  254|  2.58k|    size_t   eqcount = 0; /* number of '=' at the end of base64 stream */
  255|       |
  256|  2.58k|    if (!param) {
  ------------------
  |  Branch (256:9): [True: 0, False: 2.58k]
  ------------------
  257|      0|        return false;
  258|      0|    }
  259|       |
  260|       |    /* checking whether there are some decoded bytes */
  261|  2.58k|    if (param->restpos < param->restlen) {
  ------------------
  |  Branch (261:9): [True: 997, False: 1.58k]
  ------------------
  262|    997|        if (param->restlen - param->restpos >= len) {
  ------------------
  |  Branch (262:13): [True: 0, False: 997]
  ------------------
  263|      0|            memcpy(bufptr, &param->rest[param->restpos], len);
  264|      0|            param->restpos += len;
  265|      0|            try {
  266|      0|                param->crc_ctx->add(bufptr, len);
  267|      0|            } catch (const std::exception &e) {
  268|      0|                RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  269|      0|                return false;
  270|      0|            }
  271|      0|            *readres = len;
  272|      0|            return true;
  273|    997|        } else {
  274|    997|            left = len - (param->restlen - param->restpos);
  275|    997|            memcpy(bufptr, &param->rest[param->restpos], len - left);
  276|    997|            param->restpos = param->restlen = 0;
  277|    997|            bufptr += len - left;
  278|    997|        }
  279|    997|    }
  280|       |
  281|  2.58k|    if (param->eofb64) {
  ------------------
  |  Branch (281:9): [True: 703, False: 1.88k]
  ------------------
  282|    703|        *readres = len - left;
  283|    703|        return true;
  284|    703|    }
  285|       |
  286|  1.88k|    memcpy(decbuf, param->brest, param->brestlen);
  287|  1.88k|    dend = decbuf + param->brestlen;
  288|       |
  289|  15.0k|    do {
  290|  15.0k|        if (!param->readsrc->peek(b64buf, sizeof(b64buf), &read)) {
  ------------------
  |  Branch (290:13): [True: 0, False: 15.0k]
  ------------------
  291|      0|            return false;
  292|      0|        }
  293|  15.0k|        if (!read) {
  ------------------
  |  Branch (293:13): [True: 137, False: 14.8k]
  ------------------
  294|    137|            RNP_LOG("premature end of armored input");
  ------------------
  |  |   76|    137|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    137|    do {                                                                                 \
  |  |  |  |   69|    137|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 137, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    137|            break;                                                                       \
  |  |  |  |   71|    137|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  295|    137|            return false;
  296|    137|        }
  297|       |
  298|  14.8k|        dptr = dend;
  299|  14.8k|        bptr = b64buf;
  300|  14.8k|        bend = b64buf + read;
  301|       |        /* checking input data, stripping away whitespaces, checking for end of the b64 data */
  302|  58.3M|        while (bptr < bend) {
  ------------------
  |  Branch (302:16): [True: 58.2M, False: 14.2k]
  ------------------
  303|  58.2M|            if ((bval = B64DEC[*(bptr++)]) < 64) {
  ------------------
  |  Branch (303:17): [True: 56.7M, False: 1.58M]
  ------------------
  304|  56.7M|                *(dptr++) = bval;
  305|  56.7M|            } else if (bval == 0xfe) {
  ------------------
  |  Branch (305:24): [True: 436, False: 1.57M]
  ------------------
  306|       |                /* '=' means the base64 padding or the beginning of checksum */
  307|    436|                param->eofb64 = true;
  308|    436|                break;
  309|  1.57M|            } else if (bval == 0xff) {
  ------------------
  |  Branch (309:24): [True: 170, False: 1.57M]
  ------------------
  310|    170|                auto ch = *(bptr - 1);
  311|       |                /* OpenPGP message headers without the crc and without trailing = */
  312|    170|                if ((ch == CH_DASH) && !param->noheaders) {
  ------------------
  |  |   34|    170|#define CH_DASH ('-')
  ------------------
  |  Branch (312:21): [True: 110, False: 60]
  |  Branch (312:40): [True: 110, False: 0]
  ------------------
  313|    110|                    param->eofb64 = true;
  314|    110|                    break;
  315|    110|                }
  316|     60|                RNP_LOG("wrong base64 character 0x%02hhX", ch);
  ------------------
  |  |   76|     60|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     60|    do {                                                                                 \
  |  |  |  |   69|     60|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 60, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     60|            break;                                                                       \
  |  |  |  |   71|     60|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  317|     60|                return false;
  318|    170|            }
  319|  58.2M|        }
  320|       |
  321|  14.8k|        dend = dptr;
  322|  14.8k|        dptr = decbuf;
  323|       |        /* Processing full 4s which will go directly to the buf.
  324|       |           After this left < 3 or decbuf has < 4 bytes */
  325|  14.8k|        if ((size_t)(dend - dptr) / 4 * 3 < left) {
  ------------------
  |  Branch (325:13): [True: 13.6k, False: 1.13k]
  ------------------
  326|  13.6k|            pend = decbuf + (dend - dptr) / 4 * 4;
  327|  13.6k|            left -= (dend - dptr) / 4 * 3;
  328|  13.6k|        } else {
  329|  1.13k|            pend = decbuf + (left / 3) * 4;
  330|  1.13k|            left -= left / 3 * 3;
  331|  1.13k|        }
  332|       |
  333|       |        /* this one would the most performance-consuming part for large chunks */
  334|  13.6M|        while (dptr < pend) {
  ------------------
  |  Branch (334:16): [True: 13.6M, False: 14.8k]
  ------------------
  335|  13.6M|            b24 = *dptr++ << 18;
  336|  13.6M|            b24 |= *dptr++ << 12;
  337|  13.6M|            b24 |= *dptr++ << 6;
  338|  13.6M|            b24 |= *dptr++;
  339|  13.6M|            *bufptr++ = b24 >> 16;
  340|  13.6M|            *bufptr++ = b24 >> 8;
  341|  13.6M|            *bufptr++ = b24 & 0xff;
  342|  13.6M|        }
  343|       |
  344|       |        /* moving rest to the beginning of decbuf */
  345|  14.8k|        memmove(decbuf, dptr, dend - dptr);
  346|  14.8k|        dend = decbuf + (dend - dptr);
  347|       |
  348|       |        /* skip already processed data */
  349|  14.8k|        if (!param->eofb64) {
  ------------------
  |  Branch (349:13): [True: 14.2k, False: 546]
  ------------------
  350|       |            /* all input is base64 data or eol/spaces, so skipping it */
  351|  14.2k|            param->readsrc->skip(read);
  352|       |            /* check for eof for base64-encoded data without headers */
  353|  14.2k|            if (param->noheaders && param->readsrc->eof()) {
  ------------------
  |  Branch (353:17): [True: 0, False: 14.2k]
  |  Branch (353:37): [True: 0, False: 0]
  ------------------
  354|      0|                param->readsrc->skip(read);
  355|      0|                param->eofb64 = true;
  356|  14.2k|            } else {
  357|  14.2k|                continue;
  358|  14.2k|            }
  359|  14.2k|        } else {
  360|       |            /* '=' reached, bptr points on it */
  361|    546|            param->readsrc->skip(bptr - b64buf - 1);
  362|    546|        }
  363|       |
  364|       |        /* end of base64 data */
  365|    546|        if (param->noheaders) {
  ------------------
  |  Branch (365:13): [True: 0, False: 546]
  ------------------
  366|      0|            if (!base64_read_padding(*param->readsrc, &eqcount)) {
  ------------------
  |  Branch (366:17): [True: 0, False: 0]
  ------------------
  367|      0|                return false;
  368|      0|            }
  369|      0|            break;
  370|      0|        }
  371|       |        /* reading b64 padding if any */
  372|    546|        if (!armor_read_padding(*param->readsrc, &eqcount)) {
  ------------------
  |  Branch (372:13): [True: 70, False: 476]
  ------------------
  373|     70|            RNP_LOG("wrong padding");
  ------------------
  |  |   76|     70|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     70|    do {                                                                                 \
  |  |  |  |   69|     70|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 70, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     70|            break;                                                                       \
  |  |  |  |   71|     70|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  374|     70|            return false;
  375|     70|        }
  376|       |        /* reading crc */
  377|    476|        if (!armor_read_crc(param)) {
  ------------------
  |  Branch (377:13): [True: 330, False: 146]
  ------------------
  378|    330|            RNP_LOG("Warning: missing or malformed CRC line");
  ------------------
  |  |   76|    330|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    330|    do {                                                                                 \
  |  |  |  |   69|    330|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 330, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    330|            break;                                                                       \
  |  |  |  |   71|    330|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  379|    330|        }
  380|       |        /* reading armor trailing line */
  381|    476|        if (!armor_read_trailer(param)) {
  ------------------
  |  Branch (381:13): [True: 155, False: 321]
  ------------------
  382|    155|            RNP_LOG("wrong armor trailer");
  ------------------
  |  |   76|    155|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    155|    do {                                                                                 \
  |  |  |  |   69|    155|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 155, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    155|            break;                                                                       \
  |  |  |  |   71|    155|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  383|    155|            return false;
  384|    155|        }
  385|    321|        break;
  386|  14.2k|    } while (left >= 3);
  ------------------
  |  Branch (386:14): [True: 13.1k, False: 1.13k]
  ------------------
  387|       |
  388|       |    /* process bytes left in decbuf */
  389|       |
  390|  1.45k|    dptr = decbuf;
  391|  1.45k|    pend = decbuf + (dend - decbuf) / 4 * 4;
  392|  1.45k|    bptr = param->rest;
  393|   531k|    while (dptr < pend) {
  ------------------
  |  Branch (393:12): [True: 529k, False: 1.45k]
  ------------------
  394|   529k|        b24 = *dptr++ << 18;
  395|   529k|        b24 |= *dptr++ << 12;
  396|   529k|        b24 |= *dptr++ << 6;
  397|   529k|        b24 |= *dptr++;
  398|   529k|        *bptr++ = b24 >> 16;
  399|   529k|        *bptr++ = b24 >> 8;
  400|   529k|        *bptr++ = b24 & 0xff;
  401|   529k|    }
  402|       |
  403|  1.45k|    if (!armored_update_crc(param, buf, bufptr - (uint8_t *) buf)) {
  ------------------
  |  Branch (403:9): [True: 0, False: 1.45k]
  ------------------
  404|      0|        return false;
  405|      0|    }
  406|       |
  407|  1.45k|    if (param->eofb64) {
  ------------------
  |  Branch (407:9): [True: 321, False: 1.13k]
  ------------------
  408|    321|        if ((dend - dptr + eqcount) % 4 != 0) {
  ------------------
  |  Branch (408:13): [True: 72, False: 249]
  ------------------
  409|     72|            RNP_LOG("wrong b64 padding");
  ------------------
  |  |   76|     72|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     72|    do {                                                                                 \
  |  |  |  |   69|     72|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 72, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     72|            break;                                                                       \
  |  |  |  |   71|     72|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  410|     72|            return false;
  411|     72|        }
  412|       |
  413|    249|        if (eqcount == 1) {
  ------------------
  |  Branch (413:13): [True: 90, False: 159]
  ------------------
  414|     90|            b24 = (*dptr << 10) | (*(dptr + 1) << 4) | (*(dptr + 2) >> 2);
  415|     90|            *bptr++ = b24 >> 8;
  416|     90|            *bptr++ = b24 & 0xff;
  417|    159|        } else if (eqcount == 2) {
  ------------------
  |  Branch (417:20): [True: 39, False: 120]
  ------------------
  418|     39|            *bptr++ = (*dptr << 2) | (*(dptr + 1) >> 4);
  419|     39|        }
  420|       |
  421|       |        /* Calculate CRC after reading whole input stream */
  422|    249|        if (!armored_update_crc(param, param->rest, bptr - param->rest, true)) {
  ------------------
  |  Branch (422:13): [True: 0, False: 249]
  ------------------
  423|      0|            return false;
  424|      0|        }
  425|  1.13k|    } else {
  426|       |        /* few bytes which do not fit to 4 boundary */
  427|  2.81k|        for (int i = 0; i < dend - dptr; i++) {
  ------------------
  |  Branch (427:25): [True: 1.67k, False: 1.13k]
  ------------------
  428|  1.67k|            param->brest[i] = *(dptr + i);
  429|  1.67k|        }
  430|  1.13k|        param->brestlen = dend - dptr;
  431|  1.13k|    }
  432|       |
  433|  1.38k|    param->restlen = bptr - param->rest;
  434|       |
  435|       |    /* check whether we have some bytes to add */
  436|  1.38k|    if ((left > 0) && (param->restlen > 0)) {
  ------------------
  |  Branch (436:9): [True: 1.08k, False: 301]
  |  Branch (436:23): [True: 939, False: 146]
  ------------------
  437|    939|        read = left > param->restlen ? param->restlen : left;
  ------------------
  |  Branch (437:16): [True: 113, False: 826]
  ------------------
  438|    939|        memcpy(bufptr, param->rest, read);
  439|    939|        if (!param->eofb64 && !armored_update_crc(param, bufptr, read)) {
  ------------------
  |  Branch (439:13): [True: 812, False: 127]
  |  Branch (439:31): [True: 0, False: 812]
  ------------------
  440|      0|            return false;
  441|      0|        }
  442|    939|        left -= read;
  443|    939|        param->restpos += read;
  444|    939|    }
  445|       |
  446|  1.38k|    *readres = len - left;
  447|  1.38k|    return true;
  448|  1.38k|}
stream-armor.cpp:_ZL18armor_read_paddingR12pgp_source_tPm:
  106|    546|{
  107|    546|    char   st[64];
  108|    546|    size_t stlen = 0;
  109|       |
  110|    546|    if (!src.peek_line(st, 64, &stlen)) {
  ------------------
  |  Branch (110:9): [True: 13, False: 533]
  ------------------
  111|     13|        return false;
  112|     13|    }
  113|       |
  114|    533|    if ((stlen == 1) || (stlen == 2)) {
  ------------------
  |  Branch (114:9): [True: 200, False: 333]
  |  Branch (114:25): [True: 84, False: 249]
  ------------------
  115|    284|        if ((st[0] != CH_EQ) || ((stlen == 2) && (st[1] != CH_EQ))) {
  ------------------
  |  |   33|    284|#define CH_EQ ('=')
  ------------------
                      if ((st[0] != CH_EQ) || ((stlen == 2) && (st[1] != CH_EQ))) {
  ------------------
  |  |   33|     81|#define CH_EQ ('=')
  ------------------
  |  Branch (115:13): [True: 6, False: 278]
  |  Branch (115:34): [True: 81, False: 197]
  |  Branch (115:50): [True: 15, False: 66]
  ------------------
  116|     21|            return false;
  117|     21|        }
  118|       |
  119|    263|        *read = stlen;
  120|    263|        src.skip(stlen);
  121|    263|        return src.skip_eol();
  122|    284|    } else if (stlen == 5) {
  ------------------
  |  Branch (122:16): [True: 140, False: 109]
  ------------------
  123|    140|        *read = 0;
  124|    140|        return true;
  125|    140|    } else if ((stlen > 5) && !memcmp(st, ST_DASHES, 5)) {
  ------------------
  |  |   45|    102|#define ST_DASHES ("-----")
  ------------------
  |  Branch (125:16): [True: 102, False: 7]
  |  Branch (125:31): [True: 73, False: 29]
  ------------------
  126|       |        /* case with absent crc and 3-byte last chunk */
  127|     73|        *read = 0;
  128|     73|        return true;
  129|     73|    }
  130|     36|    return false;
  131|    533|}
stream-armor.cpp:_ZL14armor_read_crcP26pgp_source_armored_param_t:
  167|    476|{
  168|    476|    uint8_t dec[4] = {0};
  169|    476|    char    crc[8] = {0};
  170|    476|    size_t  clen = 0;
  171|       |
  172|    476|    if (!param->readsrc->peek_line(crc, sizeof(crc), &clen)) {
  ------------------
  |  Branch (172:9): [True: 287, False: 189]
  ------------------
  173|    287|        return false;
  174|    287|    }
  175|       |
  176|    189|    if ((clen != 5) || (crc[0] != CH_EQ)) {
  ------------------
  |  |   33|    174|#define CH_EQ ('=')
  ------------------
  |  Branch (176:9): [True: 15, False: 174]
  |  Branch (176:24): [True: 10, False: 164]
  ------------------
  177|     25|        return false;
  178|     25|    }
  179|       |
  180|    772|    for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (180:21): [True: 626, False: 146]
  ------------------
  181|    626|        if ((dec[i] = B64DEC[(uint8_t) crc[i + 1]]) >= 64) {
  ------------------
  |  Branch (181:13): [True: 18, False: 608]
  ------------------
  182|     18|            return false;
  183|     18|        }
  184|    626|    }
  185|       |
  186|    146|    param->readcrc[0] = (dec[0] << 2) | ((dec[1] >> 4) & 0x0F);
  187|    146|    param->readcrc[1] = (dec[1] << 4) | ((dec[2] >> 2) & 0x0F);
  188|    146|    param->readcrc[2] = (dec[2] << 6) | dec[3];
  189|       |
  190|    146|    param->has_crc = true;
  191|       |
  192|    146|    param->readsrc->skip(5);
  193|    146|    return param->readsrc->skip_eol();
  194|    164|}
stream-armor.cpp:_ZL18armor_read_trailerP26pgp_source_armored_param_t:
  198|    476|{
  199|       |    /* Space or tab could get between armor and trailer, see issue #2199 */
  200|    476|    if (!param->readsrc->skip_chars("\r\n \t")) {
  ------------------
  |  Branch (200:9): [True: 0, False: 476]
  ------------------
  201|      0|        return false;
  202|      0|    }
  203|       |
  204|    476|    std::string st = ST_ARMOR_END + param->armorhdr + ST_DASHES;
  ------------------
  |  |   47|  1.42k|#define ST_ARMOR_END ("-----END PGP ")
  ------------------
                  std::string st = ST_ARMOR_END + param->armorhdr + ST_DASHES;
  ------------------
  |  |   45|    476|#define ST_DASHES ("-----")
  ------------------
  205|    476|    std::string str(st.size(), 0);
  206|    476|    if (!param->readsrc->peek_eq(&str.front(), str.size()) || (st != str)) {
  ------------------
  |  Branch (206:9): [True: 100, False: 376]
  |  Branch (206:63): [True: 55, False: 321]
  ------------------
  207|    155|        return false;
  208|    155|    }
  209|    321|    param->readsrc->skip(st.size());
  210|    321|    (void) param->readsrc->skip_chars("\t ");
  211|    321|    (void) param->readsrc->skip_eol();
  212|    321|    return true;
  213|    476|}
stream-armor.cpp:_ZL18armored_update_crcP26pgp_source_armored_param_tPKvmb:
  220|  2.51k|{
  221|  2.51k|    if (param->noheaders) {
  ------------------
  |  Branch (221:9): [True: 0, False: 2.51k]
  ------------------
  222|      0|        return true;
  223|      0|    }
  224|  2.51k|    try {
  225|  2.51k|        param->crc_ctx->add(buf, len);
  226|  2.51k|        if (!finish) {
  ------------------
  |  Branch (226:13): [True: 2.27k, False: 249]
  ------------------
  227|  2.27k|            return true;
  228|  2.27k|        }
  229|    249|        auto crc = param->crc_ctx->finish();
  230|    249|        if (param->has_crc && memcmp(param->readcrc, crc.data(), 3)) {
  ------------------
  |  Branch (230:13): [True: 127, False: 122]
  |  Branch (230:31): [True: 125, False: 2]
  ------------------
  231|    125|            RNP_LOG("Warning: CRC mismatch");
  ------------------
  |  |   76|    125|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    125|    do {                                                                                 \
  |  |  |  |   69|    125|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 125, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    125|            break;                                                                       \
  |  |  |  |   71|    125|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  232|    125|        }
  233|    249|        return true;
  234|  2.51k|    } catch (const std::exception &e) {
  235|      0|        RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  236|      0|        return false;
  237|      0|    }
  238|  2.51k|}
stream-armor.cpp:_ZL17armored_src_closeP12pgp_source_t:
  452|  2.83k|{
  453|  2.83k|    auto param = (pgp_source_armored_param_t *) src->param;
  454|  2.83k|    delete param;
  455|       |    src->param = NULL;
  456|  2.83k|}
stream-armor.cpp:_ZL18armor_parse_headerP26pgp_source_armored_param_t:
  607|  1.82k|{
  608|  1.82k|    size_t      skip = 0;
  609|  1.82k|    std::string hdr = peek_armor_header(*param->readsrc, &skip, true);
  610|  1.82k|    if (hdr.empty()) {
  ------------------
  |  Branch (610:9): [True: 146, False: 1.67k]
  ------------------
  611|    146|        RNP_LOG("no armor header");
  ------------------
  |  |   76|    146|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    146|    do {                                                                                 \
  |  |  |  |   69|    146|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 146, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    146|            break;                                                                       \
  |  |  |  |   71|    146|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  612|    146|        return false;
  613|    146|    }
  614|       |
  615|  1.67k|    param->type = armor_str_to_data_type(hdr);
  616|  1.67k|    if (param->type == PGP_ARMORED_UNKNOWN) {
  ------------------
  |  Branch (616:9): [True: 316, False: 1.36k]
  ------------------
  617|    316|        RNP_LOG("unknown armor header");
  ------------------
  |  |   76|    316|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    316|    do {                                                                                 \
  |  |  |  |   69|    316|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 316, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    316|            break;                                                                       \
  |  |  |  |   71|    316|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  618|    316|        return false;
  619|    316|    }
  620|       |
  621|  1.36k|    param->armorhdr = std::move(hdr);
  622|  1.36k|    param->readsrc->skip(skip);
  623|  1.36k|    param->readsrc->skip_chars("\t ");
  624|  1.36k|    return true;
  625|  1.67k|}
stream-armor.cpp:_ZL19armor_parse_headersP26pgp_source_armored_param_t:
  662|  1.29k|{
  663|  1.29k|    std::vector<char> header(ARMORED_PEEK_BUF_SIZE, '\0');
  ------------------
  |  |   46|  1.29k|#define ARMORED_PEEK_BUF_SIZE 1024
  ------------------
  664|       |
  665|  16.9k|    do {
  666|  16.9k|        size_t hdrlen = 0;
  667|  16.9k|        if (!param->readsrc->peek_line(header.data(), header.size(), &hdrlen)) {
  ------------------
  |  Branch (667:13): [True: 1.15k, False: 15.8k]
  ------------------
  668|       |            /* if line is too long let's cut it to the reasonable size */
  669|  1.15k|            param->readsrc->skip(hdrlen);
  670|  1.15k|            if ((hdrlen != header.size() - 1) || !armor_skip_line(*param->readsrc)) {
  ------------------
  |  Branch (670:17): [True: 444, False: 706]
  |  Branch (670:50): [True: 38, False: 668]
  ------------------
  671|    482|                RNP_LOG("failed to peek line: unexpected end of data");
  ------------------
  |  |   76|    482|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    482|    do {                                                                                 \
  |  |  |  |   69|    482|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 482, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    482|            break;                                                                       \
  |  |  |  |   71|    482|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  672|    482|                return false;
  673|    482|            }
  674|    668|            RNP_LOG("Too long armor header - truncated.");
  ------------------
  |  |   76|    668|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    668|    do {                                                                                 \
  |  |  |  |   69|    668|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 668, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    668|            break;                                                                       \
  |  |  |  |   71|    668|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  675|  15.8k|        } else if (hdrlen) {
  ------------------
  |  Branch (675:20): [True: 15.3k, False: 432]
  ------------------
  676|  15.3k|            if (is_base64_line(header.data(), hdrlen)) {
  ------------------
  |  Branch (676:17): [True: 378, False: 15.0k]
  ------------------
  677|    378|                RNP_LOG("Warning: no empty line after the base64 headers");
  ------------------
  |  |   76|    378|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    378|    do {                                                                                 \
  |  |  |  |   69|    378|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 378, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    378|            break;                                                                       \
  |  |  |  |   71|    378|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  678|    378|                return true;
  679|    378|            }
  680|  15.0k|            param->readsrc->skip(hdrlen);
  681|  15.0k|            if (rnp::is_blank_line(header.data(), hdrlen)) {
  ------------------
  |  Branch (681:17): [True: 0, False: 15.0k]
  ------------------
  682|      0|                return param->readsrc->skip_eol();
  683|      0|            }
  684|  15.0k|        } else {
  685|       |            /* empty line - end of the headers */
  686|    432|            return param->readsrc->skip_eol();
  687|    432|        }
  688|       |
  689|  15.6k|        std::string hdrst(header.begin(), header.begin() + hdrlen);
  690|  15.6k|        size_t      pos = hdrst.find(": ");
  691|  15.6k|        if ((pos != std::string::npos) && armor_header_known(hdrst.substr(0, pos + 2))) {
  ------------------
  |  Branch (691:13): [True: 9.77k, False: 5.90k]
  |  Branch (691:13): [True: 5.66k, False: 10.0k]
  |  Branch (691:43): [True: 5.66k, False: 4.11k]
  ------------------
  692|       |            // do nothing at the moment, just check whether header is known
  693|  10.0k|        } else {
  694|  10.0k|            RNP_LOG("unknown header '%s'", hdrst.c_str());
  ------------------
  |  |   76|  10.0k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  10.0k|    do {                                                                                 \
  |  |  |  |   69|  10.0k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 10.0k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  10.0k|            break;                                                                       \
  |  |  |  |   71|  10.0k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  695|  10.0k|        }
  696|       |
  697|  15.6k|        if (!param->readsrc->skip_eol()) {
  ------------------
  |  Branch (697:13): [True: 0, False: 15.6k]
  ------------------
  698|      0|            return false;
  699|      0|        }
  700|  15.6k|    } while (1);
  ------------------
  |  Branch (700:14): [True: 15.6k, Folded]
  ------------------
  701|  1.29k|}
stream-armor.cpp:_ZL15armor_skip_lineR12pgp_source_t:
  629|    706|{
  630|    706|    char header[ARMORED_PEEK_BUF_SIZE] = {0};
  631|  1.75k|    do {
  632|  1.75k|        size_t hdrlen = 0;
  633|  1.75k|        bool   res = src.peek_line(header, sizeof(header), &hdrlen);
  634|  1.75k|        if (hdrlen) {
  ------------------
  |  Branch (634:13): [True: 1.39k, False: 368]
  ------------------
  635|  1.39k|            src.skip(hdrlen);
  636|  1.39k|        }
  637|  1.75k|        if (res || (hdrlen < sizeof(header) - 1)) {
  ------------------
  |  Branch (637:13): [True: 668, False: 1.09k]
  |  Branch (637:20): [True: 38, False: 1.05k]
  ------------------
  638|    706|            return res;
  639|    706|        }
  640|  1.75k|    } while (1);
  ------------------
  |  Branch (640:14): [True: 1.05k, Folded]
  ------------------
  641|    706|}
stream-armor.cpp:_ZL18armor_header_knownRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  655|  9.77k|{
  656|  9.77k|    return (name == ST_HEADER_VERSION) || (name == ST_HEADER_COMMENT) ||
  ------------------
  |  |   50|  9.77k|#define ST_HEADER_VERSION ("Version: ")
  ------------------
                  return (name == ST_HEADER_VERSION) || (name == ST_HEADER_COMMENT) ||
  ------------------
  |  |   51|  8.58k|#define ST_HEADER_COMMENT ("Comment: ")
  ------------------
  |  Branch (656:12): [True: 1.19k, False: 8.58k]
  |  Branch (656:43): [True: 1.63k, False: 6.94k]
  ------------------
  657|  6.94k|           (name == ST_HEADER_CHARSET) || (name == ST_HEADER_HASH);
  ------------------
  |  |   53|  6.94k|#define ST_HEADER_CHARSET ("Charset: ")
  ------------------
                         (name == ST_HEADER_CHARSET) || (name == ST_HEADER_HASH);
  ------------------
  |  |   52|  5.15k|#define ST_HEADER_HASH ("Hash: ")
  ------------------
  |  Branch (657:12): [True: 1.78k, False: 5.15k]
  |  Branch (657:43): [True: 1.04k, False: 4.11k]
  ------------------
  658|  9.77k|}
stream-armor.cpp:_ZL14is_base64_linePKcm:
  645|  15.3k|{
  646|   119k|    for (size_t i = 0; i < len && line[i]; i++) {
  ------------------
  |  Branch (646:24): [True: 119k, False: 332]
  |  Branch (646:35): [True: 118k, False: 46]
  ------------------
  647|   118k|        if (B64DEC[(uint8_t) line[i]] == 0xff)
  ------------------
  |  Branch (647:13): [True: 15.0k, False: 103k]
  ------------------
  648|  15.0k|            return false;
  649|   118k|    }
  650|    378|    return true;
  651|  15.3k|}

_ZN12pgp_source_t4readEPvmPm:
   57|  49.9M|{
   58|  49.9M|    size_t left = len;
   59|  49.9M|    size_t read;
   60|  49.9M|    bool   readahead = cache ? cache->readahead : false;
  ------------------
  |  Branch (60:24): [True: 49.9M, False: 0]
  ------------------
   61|       |
   62|  49.9M|    if (error_) {
  ------------------
  |  Branch (62:9): [True: 65, False: 49.9M]
  ------------------
   63|     65|        return false;
   64|     65|    }
   65|       |
   66|  49.9M|    if (eof_ || (len == 0)) {
  ------------------
  |  Branch (66:9): [True: 51.6k, False: 49.9M]
  |  Branch (66:17): [True: 0, False: 49.9M]
  ------------------
   67|  51.6k|        *readres = 0;
   68|  51.6k|        return true;
   69|  51.6k|    }
   70|       |
   71|       |    // Do not read more then available if source size is known
   72|  49.9M|    if (knownsize && (readb + len > size)) {
  ------------------
  |  Branch (72:9): [True: 120k, False: 49.8M]
  |  Branch (72:22): [True: 10.3k, False: 110k]
  ------------------
   73|  10.3k|        len = size - readb;
   74|  10.3k|        left = len;
   75|  10.3k|        readahead = false;
   76|  10.3k|    }
   77|       |
   78|       |    // Check whether we have cache and there is data inside
   79|  49.9M|    if (cache && (cache->len > cache->pos)) {
  ------------------
  |  Branch (79:9): [True: 49.9M, False: 0]
  |  Branch (79:18): [True: 49.9M, False: 13.2k]
  ------------------
   80|  49.9M|        read = cache->len - cache->pos;
   81|  49.9M|        if (read >= len) {
  ------------------
  |  Branch (81:13): [True: 48.4M, False: 1.43M]
  ------------------
   82|  48.4M|            memcpy(buf, &cache->buf[cache->pos], len);
   83|  48.4M|            cache->pos += len;
   84|  48.4M|            goto finish;
   85|  48.4M|        } else {
   86|  1.43M|            memcpy(buf, &cache->buf[cache->pos], read);
   87|  1.43M|            cache->pos += read;
   88|  1.43M|            buf = (uint8_t *) buf + read;
   89|  1.43M|            left = len - read;
   90|  1.43M|        }
   91|  49.9M|    }
   92|       |
   93|       |    // If we got here then we have empty cache or no cache at all
   94|  1.45M|    while (left > 0) {
  ------------------
  |  Branch (94:12): [True: 1.45M, False: 1.25k]
  ------------------
   95|  1.45M|        if (left > sizeof(cache->buf) || !readahead || !cache) {
  ------------------
  |  Branch (95:13): [True: 1.56k, False: 1.44M]
  |  Branch (95:42): [True: 168, False: 1.44M]
  |  Branch (95:56): [True: 0, False: 1.44M]
  ------------------
   96|       |            // If there is no cache or chunk is larger then read directly
   97|  1.73k|            if (!raw_read(this, buf, left, &read)) {
  ------------------
  |  Branch (97:17): [True: 95, False: 1.63k]
  ------------------
   98|     95|                error_ = 1;
   99|     95|                return false;
  100|     95|            }
  101|  1.63k|            if (!read) {
  ------------------
  |  Branch (101:17): [True: 388, False: 1.25k]
  ------------------
  102|    388|                eof_ = true;
  103|    388|                len = len - left;
  104|    388|                goto finish;
  105|    388|            }
  106|  1.25k|            left -= read;
  107|  1.25k|            buf = (uint8_t *) buf + read;
  108|  1.44M|        } else {
  109|       |            // Try to fill the cache to avoid small reads
  110|  1.44M|            if (!raw_read(this, &cache->buf[0], sizeof(cache->buf), &read)) {
  ------------------
  |  Branch (110:17): [True: 1.10k, False: 1.44M]
  ------------------
  111|  1.10k|                error_ = true;
  112|  1.10k|                return false;
  113|  1.10k|            }
  114|  1.44M|            if (!read) {
  ------------------
  |  Branch (114:17): [True: 18.4k, False: 1.42M]
  ------------------
  115|  18.4k|                eof_ = true;
  116|  18.4k|                len = len - left;
  117|  18.4k|                goto finish;
  118|  1.42M|            } else if (read < left) {
  ------------------
  |  Branch (118:24): [True: 132, False: 1.42M]
  ------------------
  119|    132|                memcpy(buf, &cache->buf[0], read);
  120|    132|                left -= read;
  121|    132|                buf = (uint8_t *) buf + read;
  122|  1.42M|            } else {
  123|  1.42M|                memcpy(buf, &cache->buf[0], left);
  124|  1.42M|                cache->pos = left;
  125|  1.42M|                cache->len = read;
  126|  1.42M|                goto finish;
  127|  1.42M|            }
  128|  1.44M|        }
  129|  1.45M|    }
  130|       |
  131|  49.9M|finish:
  132|  49.9M|    readb += len;
  133|  49.9M|    if (knownsize && (readb == size)) {
  ------------------
  |  Branch (133:9): [True: 120k, False: 49.8M]
  |  Branch (133:22): [True: 13.1k, False: 107k]
  ------------------
  134|  13.1k|        eof_ = true;
  135|  13.1k|    }
  136|  49.9M|    *readres = len;
  137|  49.9M|    return true;
  138|  1.45M|}
_ZN12pgp_source_t7read_eqEPvm:
  142|  23.2M|{
  143|  23.2M|    size_t res = 0;
  144|  23.2M|    return read(buf, len, &res) && (res == len);
  ------------------
  |  Branch (144:12): [True: 23.2M, False: 258]
  |  Branch (144:36): [True: 23.2M, False: 1.53k]
  ------------------
  145|  23.2M|}
_ZN12pgp_source_t4peekEPvmPm:
  149|  5.35M|{
  150|  5.35M|    if (error_) {
  ------------------
  |  Branch (150:9): [True: 6.47k, False: 5.34M]
  ------------------
  151|  6.47k|        return false;
  152|  6.47k|    }
  153|  5.34M|    if (!cache || (len > sizeof(cache->buf))) {
  ------------------
  |  Branch (153:9): [True: 0, False: 5.34M]
  |  Branch (153:19): [True: 0, False: 5.34M]
  ------------------
  154|      0|        return false;
  155|      0|    }
  156|  5.34M|    if (eof_) {
  ------------------
  |  Branch (156:9): [True: 0, False: 5.34M]
  ------------------
  157|      0|        *peeked = 0;
  158|      0|        return true;
  159|      0|    }
  160|       |
  161|  5.34M|    size_t read = 0;
  162|  5.34M|    bool   readahead = cache->readahead;
  163|       |    // Do not read more then available if source size is known
  164|  5.34M|    if (knownsize && (readb + len > size)) {
  ------------------
  |  Branch (164:9): [True: 471k, False: 4.87M]
  |  Branch (164:22): [True: 52.7k, False: 418k]
  ------------------
  165|  52.7k|        len = size - readb;
  166|  52.7k|        readahead = false;
  167|  52.7k|    }
  168|       |
  169|  5.34M|    if (cache->len - cache->pos >= len) {
  ------------------
  |  Branch (169:9): [True: 4.56M, False: 778k]
  ------------------
  170|  4.56M|        if (buf) {
  ------------------
  |  Branch (170:13): [True: 4.56M, False: 0]
  ------------------
  171|  4.56M|            memcpy(buf, &cache->buf[cache->pos], len);
  172|  4.56M|        }
  173|  4.56M|        *peeked = len;
  174|  4.56M|        return true;
  175|  4.56M|    }
  176|       |
  177|   778k|    if (cache->pos > 0) {
  ------------------
  |  Branch (177:9): [True: 732k, False: 46.3k]
  ------------------
  178|   732k|        memmove(&cache->buf[0], &cache->buf[cache->pos], cache->len - cache->pos);
  179|   732k|        cache->len -= cache->pos;
  180|   732k|        cache->pos = 0;
  181|   732k|    }
  182|       |
  183|   778k|    while (cache->len < len) {
  ------------------
  |  Branch (183:12): [True: 778k, False: 0]
  ------------------
  184|   778k|        read = readahead ? sizeof(cache->buf) - cache->len : len - cache->len;
  ------------------
  |  Branch (184:16): [True: 764k, False: 14.6k]
  ------------------
  185|   778k|        if (knownsize && (readb + read > size)) {
  ------------------
  |  Branch (185:13): [True: 19.4k, False: 759k]
  |  Branch (185:26): [True: 1.16k, False: 18.2k]
  ------------------
  186|  1.16k|            read = size - readb;
  187|  1.16k|        }
  188|   778k|        if (!raw_read(this, &cache->buf[cache->len], read, &read)) {
  ------------------
  |  Branch (188:13): [True: 1.70k, False: 777k]
  ------------------
  189|  1.70k|            error_ = true;
  190|  1.70k|            return false;
  191|  1.70k|        }
  192|   777k|        if (!read) {
  ------------------
  |  Branch (192:13): [True: 137k, False: 639k]
  ------------------
  193|   137k|            if (buf) {
  ------------------
  |  Branch (193:17): [True: 137k, False: 0]
  ------------------
  194|   137k|                memcpy(buf, &cache->buf[0], cache->len);
  195|   137k|            }
  196|   137k|            *peeked = cache->len;
  197|   137k|            return true;
  198|   137k|        }
  199|   639k|        cache->len += read;
  200|   639k|        if (cache->len >= len) {
  ------------------
  |  Branch (200:13): [True: 639k, False: 29]
  ------------------
  201|   639k|            if (buf) {
  ------------------
  |  Branch (201:17): [True: 639k, False: 0]
  ------------------
  202|   639k|                memcpy(buf, cache->buf, len);
  203|   639k|            }
  204|   639k|            *peeked = len;
  205|   639k|            return true;
  206|   639k|        }
  207|   639k|    }
  208|      0|    return false;
  209|   778k|}
_ZN12pgp_source_t7peek_eqEPvm:
  213|  3.16M|{
  214|  3.16M|    size_t res = 0;
  215|  3.16M|    return peek(buf, len, &res) && (res == len);
  ------------------
  |  Branch (215:12): [True: 3.15M, False: 3.91k]
  |  Branch (215:36): [True: 3.15M, False: 3.03k]
  ------------------
  216|  3.16M|}
_ZN12pgp_source_t4skipEm:
  220|  77.0k|{
  221|  77.0k|    if (cache && (cache->len - cache->pos >= len)) {
  ------------------
  |  Branch (221:9): [True: 77.0k, False: 0]
  |  Branch (221:18): [True: 77.0k, False: 0]
  ------------------
  222|  77.0k|        readb += len;
  223|  77.0k|        cache->pos += len;
  224|  77.0k|        return;
  225|  77.0k|    }
  226|       |
  227|      0|    size_t  res = 0;
  228|      0|    uint8_t sbuf[16];
  229|      0|    if (len < sizeof(sbuf)) {
  ------------------
  |  Branch (229:9): [True: 0, False: 0]
  ------------------
  230|      0|        (void) read(sbuf, len, &res);
  231|      0|        return;
  232|      0|    }
  233|      0|    if (eof()) {
  ------------------
  |  Branch (233:9): [True: 0, False: 0]
  ------------------
  234|      0|        return;
  235|      0|    }
  236|       |
  237|      0|    void *buf = calloc(1, std::min((size_t) PGP_INPUT_CACHE_SIZE, len));
  ------------------
  |  |   35|      0|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  238|      0|    if (!buf) {
  ------------------
  |  Branch (238:9): [True: 0, False: 0]
  ------------------
  239|      0|        error_ = true;
  240|      0|        return;
  241|      0|    }
  242|       |
  243|      0|    while (len && !eof()) {
  ------------------
  |  Branch (243:12): [True: 0, False: 0]
  |  Branch (243:19): [True: 0, False: 0]
  ------------------
  244|      0|        if (!read(buf, std::min((size_t) PGP_INPUT_CACHE_SIZE, len), &res)) {
  ------------------
  |  |   35|      0|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  |  Branch (244:13): [True: 0, False: 0]
  ------------------
  245|      0|            break;
  246|      0|        }
  247|      0|        len -= res;
  248|      0|    }
  249|      0|    free(buf);
  250|      0|}
_ZN12pgp_source_t3eofEv:
  269|  1.77M|{
  270|  1.77M|    if (eof_) {
  ------------------
  |  Branch (270:9): [True: 20.2k, False: 1.75M]
  ------------------
  271|  20.2k|        return true;
  272|  20.2k|    }
  273|       |    /* Error on stream read is NOT considered as eof. See error(). */
  274|  1.75M|    uint8_t check;
  275|  1.75M|    size_t  read = 0;
  276|  1.75M|    return peek(&check, 1, &read) && (read == 0);
  ------------------
  |  Branch (276:12): [True: 1.74M, False: 3.79k]
  |  Branch (276:38): [True: 694, False: 1.74M]
  ------------------
  277|  1.77M|}
_ZN12pgp_source_t5closeEv:
  281|  53.0k|{
  282|  53.0k|    if (raw_close) {
  ------------------
  |  Branch (282:9): [True: 53.0k, False: 0]
  ------------------
  283|  53.0k|        raw_close(this);
  284|  53.0k|    }
  285|       |
  286|  53.0k|    if (cache) {
  ------------------
  |  Branch (286:9): [True: 49.8k, False: 3.11k]
  ------------------
  287|  49.8k|        free(cache);
  288|       |        cache = NULL;
  289|  49.8k|    }
  290|  53.0k|}
_ZN12pgp_source_t8skip_eolEv:
  294|  18.2k|{
  295|  18.2k|    uint8_t eol[2];
  296|  18.2k|    size_t  read;
  297|       |
  298|  18.2k|    if (!peek(eol, 2, &read) || !read) {
  ------------------
  |  Branch (298:9): [True: 0, False: 18.2k]
  |  Branch (298:33): [True: 240, False: 17.9k]
  ------------------
  299|    240|        return false;
  300|    240|    }
  301|  17.9k|    if (eol[0] == '\n') {
  ------------------
  |  Branch (301:9): [True: 16.4k, False: 1.55k]
  ------------------
  302|  16.4k|        skip(1);
  303|  16.4k|        return true;
  304|  16.4k|    }
  305|  1.55k|    if ((read == 2) && (eol[0] == '\r') && (eol[1] == '\n')) {
  ------------------
  |  Branch (305:9): [True: 1.53k, False: 16]
  |  Branch (305:24): [True: 1.46k, False: 67]
  |  Branch (305:44): [True: 1.43k, False: 30]
  ------------------
  306|  1.43k|        skip(2);
  307|  1.43k|        return true;
  308|  1.43k|    }
  309|    113|    return false;
  310|  1.55k|}
_ZN12pgp_source_t10skip_charsERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  314|  2.15k|{
  315|  3.84k|    do {
  316|  3.84k|        char   ch = 0;
  317|  3.84k|        size_t read = 0;
  318|  3.84k|        if (!peek(&ch, 1, &read)) {
  ------------------
  |  Branch (318:13): [True: 0, False: 3.84k]
  ------------------
  319|      0|            return false;
  320|      0|        }
  321|  3.84k|        if (!read) {
  ------------------
  |  Branch (321:13): [True: 289, False: 3.55k]
  ------------------
  322|       |            /* return true only if there is no underlying read error */
  323|    289|            return true;
  324|    289|        }
  325|  3.55k|        if (chars.find(ch) == std::string::npos) {
  ------------------
  |  Branch (325:13): [True: 1.86k, False: 1.68k]
  ------------------
  326|  1.86k|            return true;
  327|  1.86k|        }
  328|  1.68k|        skip(1);
  329|  1.68k|    } while (1);
  ------------------
  |  Branch (329:14): [True: 1.68k, Folded]
  ------------------
  330|  2.15k|}
_ZN12pgp_source_t9peek_lineEPcmPm:
  334|  19.7k|{
  335|  19.7k|    size_t scan_pos = 0;
  336|  19.7k|    size_t inc = 64;
  337|  19.7k|    len = len - 1;
  338|       |
  339|  29.6k|    do {
  340|  29.6k|        size_t to_peek = scan_pos + inc;
  341|  29.6k|        to_peek = to_peek > len ? len : to_peek;
  ------------------
  |  Branch (341:19): [True: 2.83k, False: 26.8k]
  ------------------
  342|  29.6k|        inc = inc * 2;
  343|       |
  344|       |        /* inefficient, each time we again read from the beginning */
  345|  29.6k|        if (!peek(buf, to_peek, readres)) {
  ------------------
  |  Branch (345:13): [True: 0, False: 29.6k]
  ------------------
  346|      0|            return false;
  347|      0|        }
  348|       |
  349|       |        /* we continue scanning where we stopped previously */
  350|  2.50M|        for (; scan_pos < *readres; scan_pos++) {
  ------------------
  |  Branch (350:16): [True: 2.49M, False: 12.4k]
  ------------------
  351|  2.49M|            if (buf[scan_pos] == '\n') {
  ------------------
  |  Branch (351:17): [True: 17.2k, False: 2.47M]
  ------------------
  352|  17.2k|                if ((scan_pos > 0) && (buf[scan_pos - 1] == '\r')) {
  ------------------
  |  Branch (352:21): [True: 16.4k, False: 723]
  |  Branch (352:39): [True: 1.35k, False: 15.1k]
  ------------------
  353|  1.35k|                    scan_pos--;
  354|  1.35k|                }
  355|  17.2k|                buf[scan_pos] = '\0';
  356|  17.2k|                *readres = scan_pos;
  357|  17.2k|                return true;
  358|  17.2k|            }
  359|  2.49M|        }
  360|  12.4k|        if (*readres < to_peek) {
  ------------------
  |  Branch (360:13): [True: 527, False: 11.9k]
  ------------------
  361|    527|            return false;
  362|    527|        }
  363|  12.4k|    } while (scan_pos < len);
  ------------------
  |  Branch (363:14): [True: 9.93k, False: 2.01k]
  ------------------
  364|  2.01k|    return false;
  365|  19.7k|}
_Z15init_src_commonP12pgp_source_tm:
  369|  49.8k|{
  370|  49.8k|    memset(src, 0, sizeof(*src));
  371|  49.8k|    src->cache = (pgp_source_cache_t *) calloc(1, sizeof(*src->cache));
  372|  49.8k|    if (!src->cache) {
  ------------------
  |  Branch (372:9): [True: 0, False: 49.8k]
  ------------------
  373|      0|        RNP_LOG("cache allocation failed");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  374|      0|        return false;
  375|      0|    }
  376|  49.8k|    src->cache->readahead = true;
  377|  49.8k|    if (!paramsize) {
  ------------------
  |  Branch (377:9): [True: 1.82k, False: 48.0k]
  ------------------
  378|  1.82k|        return true;
  379|  1.82k|    }
  380|  48.0k|    src->param = calloc(1, paramsize);
  381|  48.0k|    if (!src->param) {
  ------------------
  |  Branch (381:9): [True: 0, False: 48.0k]
  ------------------
  382|      0|        RNP_LOG("param allocation failed");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  383|      0|        free(src->cache);
  384|      0|        src->cache = NULL;
  385|      0|        return false;
  386|      0|    }
  387|  48.0k|    return true;
  388|  48.0k|}
_Z12init_mem_srcP12pgp_source_tPKvmb:
  546|  16.4k|{
  547|  16.4k|    if (!mem && len) {
  ------------------
  |  Branch (547:9): [True: 0, False: 16.4k]
  |  Branch (547:17): [True: 0, False: 0]
  ------------------
  548|      0|        return RNP_ERROR_NULL_POINTER;
  549|      0|    }
  550|       |    /* this is actually double buffering, but then src_peek will fail */
  551|  16.4k|    if (!init_src_common(src, sizeof(pgp_source_mem_param_t))) {
  ------------------
  |  Branch (551:9): [True: 0, False: 16.4k]
  ------------------
  552|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  553|      0|    }
  554|       |
  555|  16.4k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  556|  16.4k|    param->memory = mem;
  557|  16.4k|    param->len = len;
  558|  16.4k|    param->pos = 0;
  559|  16.4k|    param->free = free;
  560|  16.4k|    src->raw_read = mem_src_read;
  561|  16.4k|    src->raw_close = mem_src_close;
  562|  16.4k|    src->raw_finish = NULL;
  563|  16.4k|    src->size = len;
  564|  16.4k|    src->knownsize = 1;
  565|  16.4k|    src->type = PGP_STREAM_MEMORY;
  566|       |
  567|  16.4k|    return RNP_SUCCESS;
  568|  16.4k|}
_Z15init_dst_commonP10pgp_dest_tm:
  629|  19.7k|{
  630|  19.7k|    memset(dst, 0, sizeof(*dst));
  631|  19.7k|    dst->werr = RNP_SUCCESS;
  632|  19.7k|    if (!paramsize) {
  ------------------
  |  Branch (632:9): [True: 0, False: 19.7k]
  ------------------
  633|      0|        return true;
  634|      0|    }
  635|       |    /* allocate param */
  636|  19.7k|    dst->param = calloc(1, paramsize);
  637|  19.7k|    if (!dst->param) {
  ------------------
  |  Branch (637:9): [True: 0, False: 19.7k]
  ------------------
  638|      0|        RNP_LOG("allocation failed");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  639|      0|    }
  640|  19.7k|    return dst->param;
  641|  19.7k|}
_Z9dst_writeP10pgp_dest_tPKvm:
  645|   177M|{
  646|       |    /* we call write function only if all previous calls succeeded */
  647|   177M|    if ((len > 0) && (dst->write) && (dst->werr == RNP_SUCCESS)) {
  ------------------
  |  Branch (647:9): [True: 177M, False: 13.4k]
  |  Branch (647:22): [True: 177M, False: 0]
  |  Branch (647:38): [True: 177M, False: 0]
  ------------------
  648|       |        /* if cache non-empty and len will overflow it then fill it and write out */
  649|   177M|        if ((dst->clen > 0) && (dst->clen + len > sizeof(dst->cache))) {
  ------------------
  |  Branch (649:13): [True: 0, False: 177M]
  |  Branch (649:32): [True: 0, False: 0]
  ------------------
  650|      0|            memcpy(dst->cache + dst->clen, buf, sizeof(dst->cache) - dst->clen);
  651|      0|            buf = (uint8_t *) buf + sizeof(dst->cache) - dst->clen;
  652|      0|            len -= sizeof(dst->cache) - dst->clen;
  653|      0|            dst->werr = dst->write(dst, dst->cache, sizeof(dst->cache));
  654|      0|            dst->writeb += sizeof(dst->cache);
  655|      0|            dst->clen = 0;
  656|      0|            if (dst->werr != RNP_SUCCESS) {
  ------------------
  |  Branch (656:17): [True: 0, False: 0]
  ------------------
  657|      0|                return;
  658|      0|            }
  659|      0|        }
  660|       |
  661|       |        /* here everything will fit into the cache or cache is empty */
  662|   177M|        if (dst->no_cache || (len > sizeof(dst->cache))) {
  ------------------
  |  Branch (662:13): [True: 177M, False: 0]
  |  Branch (662:30): [True: 0, False: 0]
  ------------------
  663|   177M|            dst->werr = dst->write(dst, buf, len);
  664|   177M|            if (!dst->werr) {
  ------------------
  |  Branch (664:17): [True: 177M, False: 0]
  ------------------
  665|   177M|                dst->writeb += len;
  666|   177M|            }
  667|   177M|        } else {
  668|      0|            memcpy(dst->cache + dst->clen, buf, len);
  669|      0|            dst->clen += len;
  670|      0|        }
  671|   177M|    }
  672|   177M|}
_Z9dst_writeR10pgp_dest_tRKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  676|  10.6k|{
  677|  10.6k|    dst_write(&dst, buf.data(), buf.size());
  678|  10.6k|}
_Z10dst_printfR10pgp_dest_tPKcz:
  682|  40.9M|{
  683|  40.9M|    char    buf[2048];
  684|  40.9M|    size_t  len;
  685|  40.9M|    va_list ap;
  686|       |
  687|  40.9M|    va_start(ap, format);
  688|  40.9M|    len = vsnprintf(buf, sizeof(buf), format, ap);
  689|  40.9M|    va_end(ap);
  690|       |
  691|  40.9M|    if (len >= sizeof(buf)) {
  ------------------
  |  Branch (691:9): [True: 0, False: 40.9M]
  ------------------
  692|      0|        RNP_LOG("too long dst_printf");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  693|      0|        len = sizeof(buf) - 1;
  694|      0|    }
  695|  40.9M|    dst_write(&dst, buf, len);
  696|  40.9M|}
_Z9dst_flushP10pgp_dest_t:
  700|  26.2k|{
  701|  26.2k|    if ((dst->clen > 0) && (dst->write) && (dst->werr == RNP_SUCCESS)) {
  ------------------
  |  Branch (701:9): [True: 0, False: 26.2k]
  |  Branch (701:28): [True: 0, False: 0]
  |  Branch (701:44): [True: 0, False: 0]
  ------------------
  702|      0|        dst->werr = dst->write(dst, dst->cache, dst->clen);
  703|      0|        dst->writeb += dst->clen;
  704|      0|        dst->clen = 0;
  705|      0|    }
  706|  26.2k|}
_Z10dst_finishP10pgp_dest_t:
  710|  26.2k|{
  711|  26.2k|    rnp_result_t res = RNP_SUCCESS;
  712|       |
  713|  26.2k|    if (!dst->finished) {
  ------------------
  |  Branch (713:9): [True: 26.2k, False: 0]
  ------------------
  714|       |        /* flush write cache in the dst */
  715|  26.2k|        dst_flush(dst);
  716|  26.2k|        if (dst->finish) {
  ------------------
  |  Branch (716:13): [True: 0, False: 26.2k]
  ------------------
  717|      0|            res = dst->finish(dst);
  718|      0|        }
  719|  26.2k|        dst->finished = true;
  720|  26.2k|    }
  721|       |
  722|  26.2k|    return res;
  723|  26.2k|}
_Z9dst_closeP10pgp_dest_tb:
  727|  27.5k|{
  728|  27.5k|    if (!discard && !dst->finished) {
  ------------------
  |  Branch (728:9): [True: 26.2k, False: 1.28k]
  |  Branch (728:21): [True: 26.2k, False: 0]
  ------------------
  729|  26.2k|        dst_finish(dst);
  730|  26.2k|    }
  731|       |
  732|  27.5k|    if (dst->close) {
  ------------------
  |  Branch (732:9): [True: 27.5k, False: 0]
  ------------------
  733|  27.5k|        dst->close(dst, discard);
  734|  27.5k|    }
  735|  27.5k|}
_Z13init_mem_destP10pgp_dest_tPvj:
 1035|  1.28k|{
 1036|  1.28k|    pgp_dest_mem_param_t *param;
 1037|       |
 1038|  1.28k|    if (!init_dst_common(dst, sizeof(*param))) {
  ------------------
  |  Branch (1038:9): [True: 0, False: 1.28k]
  ------------------
 1039|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1040|      0|    }
 1041|       |
 1042|  1.28k|    param = (pgp_dest_mem_param_t *) dst->param;
 1043|       |
 1044|  1.28k|    param->maxalloc = len;
 1045|  1.28k|    param->allocated = mem ? len : 0;
  ------------------
  |  Branch (1045:24): [True: 1.28k, False: 0]
  ------------------
 1046|  1.28k|    param->memory = mem;
 1047|  1.28k|    param->free = !mem;
 1048|  1.28k|    param->secure = false;
 1049|       |
 1050|  1.28k|    dst->write = mem_dst_write;
 1051|  1.28k|    dst->close = mem_dst_close;
 1052|  1.28k|    dst->type = PGP_STREAM_MEMORY;
 1053|  1.28k|    dst->werr = RNP_SUCCESS;
 1054|  1.28k|    dst->no_cache = true;
 1055|       |
 1056|  1.28k|    return RNP_SUCCESS;
 1057|  1.28k|}
_Z25mem_dest_discard_overflowP10pgp_dest_tb:
 1061|  1.28k|{
 1062|  1.28k|    if (dst->type != PGP_STREAM_MEMORY) {
  ------------------
  |  Branch (1062:9): [True: 0, False: 1.28k]
  ------------------
 1063|      0|        RNP_LOG("wrong function call");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1064|      0|        return;
 1065|      0|    }
 1066|       |
 1067|  1.28k|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
 1068|  1.28k|    if (param) {
  ------------------
  |  Branch (1068:9): [True: 1.28k, False: 0]
  ------------------
 1069|  1.28k|        param->discard_overflow = discard;
 1070|  1.28k|    }
 1071|  1.28k|}
_Z14init_null_destP10pgp_dest_t:
 1159|  7.83k|{
 1160|  7.83k|    dst->param = NULL;
 1161|  7.83k|    dst->write = null_dst_write;
 1162|  7.83k|    dst->close = null_dst_close;
 1163|  7.83k|    dst->type = PGP_STREAM_NULL;
 1164|  7.83k|    dst->writeb = 0;
 1165|  7.83k|    dst->clen = 0;
 1166|  7.83k|    dst->werr = RNP_SUCCESS;
 1167|  7.83k|    dst->no_cache = true;
 1168|       |
 1169|  7.83k|    return RNP_SUCCESS;
 1170|  7.83k|}
_Z13dst_write_srcP12pgp_source_tP10pgp_dest_tm:
 1174|    205|{
 1175|    205|    const size_t bufsize = PGP_INPUT_CACHE_SIZE;
  ------------------
  |  |   35|    205|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
 1176|    205|    uint8_t *    readbuf = (uint8_t *) malloc(bufsize);
 1177|    205|    if (!readbuf) {
  ------------------
  |  Branch (1177:9): [True: 0, False: 205]
  ------------------
 1178|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1179|      0|    }
 1180|    205|    rnp_result_t res = RNP_SUCCESS;
 1181|    205|    try {
 1182|    205|        size_t   read;
 1183|    205|        uint64_t totalread = 0;
 1184|       |
 1185|   166k|        while (!src->eof_) {
  ------------------
  |  Branch (1185:16): [True: 166k, False: 156]
  ------------------
 1186|   166k|            if (!src->read(readbuf, bufsize, &read)) {
  ------------------
  |  Branch (1186:17): [True: 44, False: 166k]
  ------------------
 1187|     44|                res = RNP_ERROR_GENERIC;
 1188|     44|                break;
 1189|     44|            }
 1190|   166k|            if (!read) {
  ------------------
  |  Branch (1190:17): [True: 7, False: 166k]
  ------------------
 1191|      7|                continue;
 1192|      7|            }
 1193|   166k|            totalread += read;
 1194|   166k|            if (limit && totalread > limit) {
  ------------------
  |  Branch (1194:17): [True: 166k, False: 0]
  |  Branch (1194:26): [True: 5, False: 166k]
  ------------------
 1195|      5|                res = RNP_ERROR_GENERIC;
 1196|      5|                break;
 1197|      5|            }
 1198|   166k|            if (dst) {
  ------------------
  |  Branch (1198:17): [True: 0, False: 166k]
  ------------------
 1199|      0|                dst_write(dst, readbuf, read);
 1200|      0|                if (dst->werr) {
  ------------------
  |  Branch (1200:21): [True: 0, False: 0]
  ------------------
 1201|      0|                    RNP_LOG("failed to output data");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1202|      0|                    res = RNP_ERROR_WRITE;
 1203|      0|                    break;
 1204|      0|                }
 1205|      0|            }
 1206|   166k|        }
 1207|    205|    } catch (...) {
 1208|      0|        free(readbuf);
 1209|      0|        throw;
 1210|      0|    }
 1211|    205|    free(readbuf);
 1212|    205|    if (res || !dst) {
  ------------------
  |  Branch (1212:9): [True: 49, False: 156]
  |  Branch (1212:16): [True: 156, False: 0]
  ------------------
 1213|    205|        return res;
 1214|    205|    }
 1215|      0|    dst_flush(dst);
 1216|      0|    return dst->werr;
 1217|    205|}
stream-common.cpp:_ZL12mem_src_readP12pgp_source_tPvmPm:
  516|  18.3k|{
  517|  18.3k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  518|  18.3k|    if (!param) {
  ------------------
  |  Branch (518:9): [True: 0, False: 18.3k]
  ------------------
  519|      0|        return false;
  520|      0|    }
  521|       |
  522|  18.3k|    if (len > param->len - param->pos) {
  ------------------
  |  Branch (522:9): [True: 858, False: 17.4k]
  ------------------
  523|    858|        len = param->len - param->pos;
  524|    858|    }
  525|  18.3k|    memcpy(buf, (uint8_t *) param->memory + param->pos, len);
  526|  18.3k|    param->pos += len;
  527|  18.3k|    *read = len;
  528|  18.3k|    return true;
  529|  18.3k|}
stream-common.cpp:_ZL13mem_src_closeP12pgp_source_t:
  533|  16.4k|{
  534|  16.4k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  535|  16.4k|    if (param) {
  ------------------
  |  Branch (535:9): [True: 16.4k, False: 0]
  ------------------
  536|  16.4k|        if (param->free) {
  ------------------
  |  Branch (536:13): [True: 0, False: 16.4k]
  ------------------
  537|      0|            free((void *) param->memory);
  538|      0|        }
  539|  16.4k|        free(src->param);
  540|       |        src->param = NULL;
  541|  16.4k|    }
  542|  16.4k|}
stream-common.cpp:_ZL13mem_dst_writeP10pgp_dest_tPKvm:
  972|  17.2M|{
  973|  17.2M|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
  974|  17.2M|    if (!param) {
  ------------------
  |  Branch (974:9): [True: 0, False: 17.2M]
  ------------------
  975|      0|        return RNP_ERROR_BAD_PARAMETERS;
  976|      0|    }
  977|       |
  978|       |    /* checking whether we need to realloc or discard extra bytes */
  979|  17.2M|    if (param->discard_overflow && (dst->writeb >= param->allocated)) {
  ------------------
  |  Branch (979:9): [True: 17.2M, False: 0]
  |  Branch (979:36): [True: 17.2M, False: 2.57k]
  ------------------
  980|  17.2M|        return RNP_SUCCESS;
  981|  17.2M|    }
  982|  2.57k|    if (param->discard_overflow && (dst->writeb + len > param->allocated)) {
  ------------------
  |  Branch (982:9): [True: 2.57k, False: 0]
  |  Branch (982:36): [True: 346, False: 2.23k]
  ------------------
  983|    346|        len = param->allocated - dst->writeb;
  984|    346|    }
  985|       |
  986|  2.57k|    if (dst->writeb + len > param->allocated) {
  ------------------
  |  Branch (986:9): [True: 0, False: 2.57k]
  ------------------
  987|      0|        if ((param->maxalloc > 0) && (dst->writeb + len > param->maxalloc)) {
  ------------------
  |  Branch (987:13): [True: 0, False: 0]
  |  Branch (987:38): [True: 0, False: 0]
  ------------------
  988|      0|            RNP_LOG("attempt to alloc more then allowed");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  989|      0|            return RNP_ERROR_OUT_OF_MEMORY;
  990|      0|        }
  991|       |
  992|       |        /* round up to the page boundary and do it exponentially */
  993|      0|        size_t alloc = ((dst->writeb + len) * 2 + 4095) / 4096 * 4096;
  994|      0|        if ((param->maxalloc > 0) && (alloc > param->maxalloc)) {
  ------------------
  |  Branch (994:13): [True: 0, False: 0]
  |  Branch (994:38): [True: 0, False: 0]
  ------------------
  995|      0|            alloc = param->maxalloc;
  996|      0|        }
  997|       |
  998|      0|        void *newalloc = param->secure ? calloc(1, alloc) : realloc(param->memory, alloc);
  ------------------
  |  Branch (998:26): [True: 0, False: 0]
  ------------------
  999|      0|        if (!newalloc) {
  ------------------
  |  Branch (999:13): [True: 0, False: 0]
  ------------------
 1000|      0|            return RNP_ERROR_OUT_OF_MEMORY;
 1001|      0|        }
 1002|      0|        if (param->secure && param->memory) {
  ------------------
  |  Branch (1002:13): [True: 0, False: 0]
  |  Branch (1002:30): [True: 0, False: 0]
  ------------------
 1003|      0|            memcpy(newalloc, param->memory, dst->writeb);
 1004|      0|            secure_clear(param->memory, dst->writeb);
 1005|      0|            free(param->memory);
 1006|      0|        }
 1007|      0|        param->memory = newalloc;
 1008|      0|        param->allocated = alloc;
 1009|      0|    }
 1010|       |
 1011|  2.57k|    memcpy((uint8_t *) param->memory + dst->writeb, buf, len);
 1012|  2.57k|    return RNP_SUCCESS;
 1013|  2.57k|}
stream-common.cpp:_ZL13mem_dst_closeP10pgp_dest_tb:
 1017|  1.28k|{
 1018|  1.28k|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
 1019|  1.28k|    if (!param) {
  ------------------
  |  Branch (1019:9): [True: 0, False: 1.28k]
  ------------------
 1020|      0|        return;
 1021|      0|    }
 1022|       |
 1023|  1.28k|    if (param->free) {
  ------------------
  |  Branch (1023:9): [True: 0, False: 1.28k]
  ------------------
 1024|      0|        if (param->secure) {
  ------------------
  |  Branch (1024:13): [True: 0, False: 0]
  ------------------
 1025|      0|            secure_clear(param->memory, param->allocated);
 1026|      0|        }
 1027|      0|        free(param->memory);
 1028|      0|    }
 1029|  1.28k|    free(param);
 1030|       |    dst->param = NULL;
 1031|  1.28k|}
stream-common.cpp:_ZL14null_dst_writeP10pgp_dest_tPKvm:
 1147|  48.6M|{
 1148|  48.6M|    return RNP_SUCCESS;
 1149|  48.6M|}
stream-common.cpp:_ZL14null_dst_closeP10pgp_dest_tb:
 1153|  7.83k|{
 1154|  7.83k|    ;
 1155|  7.83k|}

_ZN3rnp6SourceC2Ev:
  399|  25.3k|    Source() : src_({})
  400|  25.3k|    {
  401|  25.3k|    }
_ZN3rnp6Source3srcEv:
  410|  2.46M|    {
  411|  2.46M|        return src_;
  412|  2.46M|    }
_ZN3rnp6SourceD2Ev:
  404|  25.3k|    {
  405|  25.3k|        src_.close();
  406|  25.3k|    }
_ZN3rnp6Source5readbEv:
  422|    623|    {
  423|    623|        return src().readb;
  424|    623|    }
_ZN3rnp6Source3eofEv:
  428|  1.20M|    {
  429|  1.20M|        return src().eof();
  430|  1.20M|    }
_ZN3rnp12MemorySourceC2EPKvmb:
  451|    776|    MemorySource(const void *mem, size_t len, bool free) : Source()
  452|    776|    {
  453|    776|        auto res = init_mem_src(&src_, mem, len, free);
  454|    776|        if (res) {
  ------------------
  |  Branch (454:13): [True: 0, False: 776]
  ------------------
  455|      0|            throw std::bad_alloc();
  456|      0|        }
  457|    776|    }
_ZN3rnp4DestC2Ev:
  493|  1.28k|    Dest() : dst_({}), discard_(false)
  494|  1.28k|    {
  495|  1.28k|    }
_ZN3rnp4DestD2Ev:
  498|  1.28k|    {
  499|  1.28k|        dst_close(&dst_, discard_);
  500|  1.28k|    }
_ZN3rnp4Dest3dstEv:
  516|  2.57k|    {
  517|  2.57k|        return dst_;
  518|  2.57k|    }
_ZN3rnp4Dest6writebEv:
  522|    776|    {
  523|    776|        return dst_.writeb;
  524|    776|    }
_ZN3rnp10MemoryDestC2EPvm:
  538|  1.28k|    MemoryDest(void *mem = NULL, size_t len = 0) : Dest()
  539|  1.28k|    {
  540|  1.28k|        auto res = init_mem_dest(&dst_, mem, len);
  541|  1.28k|        if (res) {
  ------------------
  |  Branch (541:13): [True: 0, False: 1.28k]
  ------------------
  542|      0|            throw std::bad_alloc();
  543|      0|        }
  544|  1.28k|        discard_ = true;
  545|  1.28k|    }

_ZN3rnp11DumpContext11copy_paramsERKS0_:
  567|  40.8k|{
  568|  40.8k|    dump_mpi = ctx.dump_mpi;
  569|  40.8k|    dump_packets = ctx.dump_packets;
  570|  40.8k|    dump_grips = ctx.dump_grips;
  571|       |    /* this could be called only from upper layer dumper */
  572|  40.8k|    layers = ctx.layers;
  573|  40.8k|    stream_pkts = ctx.stream_pkts;
  574|  40.8k|    failures = ctx.failures;
  575|  40.8k|}
_ZN3rnp11DumpContext12get_aead_hdrER14pgp_aead_hdr_t:
  579|  1.28k|{
  580|  1.28k|    uint8_t    encpkt[64] = {0};
  581|  1.28k|    MemoryDest encdst(encpkt, sizeof(encpkt));
  582|       |
  583|  1.28k|    mem_dest_discard_overflow(&encdst.dst(), true);
  584|       |
  585|  1.28k|    if (stream_read_packet(&src, &encdst.dst())) {
  ------------------
  |  Branch (585:9): [True: 511, False: 776]
  ------------------
  586|    511|        return false;
  587|    511|    }
  588|    776|    size_t len = std::min(encdst.writeb(), sizeof(encpkt));
  589|       |
  590|    776|    MemorySource memsrc(encpkt, len, false);
  591|    776|    return get_aead_src_hdr(&memsrc.src(), &hdr);
  592|  1.28k|}
_ZN3rnp11DumpContext14skip_cleartextEv:
  596|     36|{
  597|     36|    char   buf[4096];
  598|     36|    size_t read = 0;
  599|     36|    size_t siglen = strlen(ST_SIG_BEGIN);
  ------------------
  |  |   49|     36|#define ST_SIG_BEGIN ("\n-----BEGIN PGP SIGNATURE-----")
  ------------------
  600|     36|    char * hdrpos;
  601|       |
  602|    340|    while (!src.eof()) {
  ------------------
  |  Branch (602:12): [True: 340, False: 0]
  ------------------
  603|    340|        if (!src.peek(buf, sizeof(buf) - 1, &read) || (read <= siglen)) {
  ------------------
  |  Branch (603:13): [True: 0, False: 340]
  |  Branch (603:55): [True: 28, False: 312]
  ------------------
  604|     28|            return false;
  605|     28|        }
  606|    312|        buf[read] = '\0';
  607|       |
  608|    312|        if ((hdrpos = strstr(buf, ST_SIG_BEGIN))) {
  ------------------
  |  |   49|    312|#define ST_SIG_BEGIN ("\n-----BEGIN PGP SIGNATURE-----")
  ------------------
  |  Branch (608:13): [True: 8, False: 304]
  ------------------
  609|       |            /* +1 here is to skip \n on the beginning of ST_SIG_BEGIN */
  610|      8|            src.skip(hdrpos - buf + 1);
  611|      8|            return true;
  612|      8|        }
  613|    304|        src.skip(read - siglen + 1);
  614|    304|    }
  615|      0|    return false;
  616|     36|}
_ZN3rnp14DumpContextDstC2ER12pgp_source_tR10pgp_dest_t:
  618|  18.4k|DumpContextDst::DumpContextDst(pgp_source_t &asrc, pgp_dest_t &adst) : DumpContext(asrc)
  619|  18.4k|{
  620|  18.4k|    auto ret = init_indent_dest(dst, &adst);
  621|  18.4k|    if (ret) {
  ------------------
  |  Branch (621:9): [True: 0, False: 18.4k]
  ------------------
  622|      0|        RNP_LOG("failed to init indent dest");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  623|      0|        throw rnp_exception(RNP_ERROR_OUT_OF_MEMORY);
  624|      0|    }
  625|  18.4k|}
_ZN3rnp14DumpContextDstD2Ev:
  628|  18.4k|{
  629|  18.4k|    if (dst.param) {
  ------------------
  |  Branch (629:9): [True: 18.4k, False: 0]
  ------------------
  630|  18.4k|        dst_close(&dst, false);
  631|  18.4k|    }
  632|  18.4k|}
_ZN3rnp14DumpContextDst24dump_signature_subpacketERKN3pgp3pkt6sigsub3RawE:
  636|  25.7k|{
  637|  25.7k|    auto sname = id_str_pair::lookup(sig_subpkt_type_map, subpkt.raw_type(), "Unknown");
  638|       |
  639|  25.7k|    switch (subpkt.type()) {
  640|    529|    case pkt::sigsub::Type::CreationTime: {
  ------------------
  |  Branch (640:5): [True: 529, False: 25.1k]
  ------------------
  641|    529|        auto &sub = dynamic_cast<const pkt::sigsub::CreationTime &>(subpkt);
  642|    529|        dst_print_time(dst, sname, sub.time());
  643|    529|        break;
  644|      0|    }
  645|    647|    case pkt::sigsub::Type::ExpirationTime: {
  ------------------
  |  Branch (645:5): [True: 647, False: 25.0k]
  ------------------
  646|    647|        auto &sub = dynamic_cast<const pkt::sigsub::ExpirationTime &>(subpkt);
  647|    647|        dst_print_expiration(dst, sname, sub.time());
  648|    647|        break;
  649|      0|    }
  650|     86|    case pkt::sigsub::Type::ExportableCert: {
  ------------------
  |  Branch (650:5): [True: 86, False: 25.6k]
  ------------------
  651|     86|        auto &sub = dynamic_cast<const pkt::sigsub::ExportableCert &>(subpkt);
  652|     86|        dst_printf(dst, "%s: %d\n", sname, sub.exportable());
  653|     86|        break;
  654|      0|    }
  655|    213|    case pkt::sigsub::Type::Trust: {
  ------------------
  |  Branch (655:5): [True: 213, False: 25.5k]
  ------------------
  656|    213|        auto &sub = dynamic_cast<const pkt::sigsub::Trust &>(subpkt);
  657|    213|        dst_printf(
  658|    213|          dst, "%s: amount %" PRIu8 ", level %" PRIu8 "\n", sname, sub.amount(), sub.level());
  659|    213|        break;
  660|      0|    }
  661|    573|    case pkt::sigsub::Type::RegExp: {
  ------------------
  |  Branch (661:5): [True: 573, False: 25.1k]
  ------------------
  662|    573|        auto &sub = dynamic_cast<const pkt::sigsub::RegExp &>(subpkt);
  663|    573|        dst_print_str(dst, sname, sub.regexp());
  664|    573|        break;
  665|      0|    }
  666|    110|    case pkt::sigsub::Type::Revocable: {
  ------------------
  |  Branch (666:5): [True: 110, False: 25.6k]
  ------------------
  667|    110|        auto &sub = dynamic_cast<const pkt::sigsub::Revocable &>(subpkt);
  668|    110|        dst_printf(dst, "%s: %d\n", sname, sub.revocable());
  669|    110|        break;
  670|      0|    }
  671|  2.22k|    case pkt::sigsub::Type::KeyExpirationTime: {
  ------------------
  |  Branch (671:5): [True: 2.22k, False: 23.5k]
  ------------------
  672|  2.22k|        auto &sub = dynamic_cast<const pkt::sigsub::KeyExpirationTime &>(subpkt);
  673|  2.22k|        dst_print_expiration(dst, sname, sub.time());
  674|  2.22k|        break;
  675|      0|    }
  676|  1.53k|    case pkt::sigsub::Type::PreferredSymmetric: {
  ------------------
  |  Branch (676:5): [True: 1.53k, False: 24.1k]
  ------------------
  677|  1.53k|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredSymmetric &>(subpkt);
  678|  1.53k|        dst_print_algs(dst, "preferred symmetric algorithms", sub.algs(), symm_alg_map);
  679|  1.53k|        break;
  680|      0|    }
  681|  1.01k|    case pkt::sigsub::Type::RevocationKey: {
  ------------------
  |  Branch (681:5): [True: 1.01k, False: 24.7k]
  ------------------
  682|  1.01k|        auto &sub = dynamic_cast<const pkt::sigsub::RevocationKey &>(subpkt);
  683|  1.01k|        dst_printf(dst, "%s\n", sname);
  684|  1.01k|        dst_printf(dst, "class: %" PRIu8 "\n", sub.rev_class());
  685|  1.01k|        dst_print_palg(dst, NULL, sub.alg());
  686|  1.01k|        dst_print_fp(dst, "fingerprint", sub.fp());
  687|  1.01k|        break;
  688|      0|    }
  689|    600|    case pkt::sigsub::Type::IssuerKeyID: {
  ------------------
  |  Branch (689:5): [True: 600, False: 25.1k]
  ------------------
  690|    600|        auto &sub = dynamic_cast<const pkt::sigsub::IssuerKeyID &>(subpkt);
  691|    600|        dst_print_keyid(dst, sname, sub.keyid());
  692|    600|        break;
  693|      0|    }
  694|    959|    case pkt::sigsub::Type::NotationData: {
  ------------------
  |  Branch (694:5): [True: 959, False: 24.7k]
  ------------------
  695|    959|        auto &sub = dynamic_cast<const pkt::sigsub::NotationData &>(subpkt);
  696|    959|        if (sub.human_readable()) {
  ------------------
  |  Branch (696:13): [True: 329, False: 630]
  ------------------
  697|    329|            dst_printf(dst, "%s: %s = ", sname, sub.name().c_str());
  698|    329|            dst_printf(
  699|    329|              dst, "%.*s\n", (int) sub.value().size(), (const char *) sub.value().data());
  700|    630|        } else {
  701|    630|            char hex[64];
  702|    630|            vsnprinthex(hex, sizeof(hex), sub.value().data(), sub.value().size());
  703|    630|            dst_printf(dst, "%s: %s = ", sname, sub.name().c_str());
  704|    630|            dst_printf(dst, "0x%s (%zu bytes)\n", hex, sub.value().size());
  705|    630|        }
  706|    959|        break;
  707|      0|    }
  708|    551|    case pkt::sigsub::Type::PreferredHash: {
  ------------------
  |  Branch (708:5): [True: 551, False: 25.1k]
  ------------------
  709|    551|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredHash &>(subpkt);
  710|    551|        dst_print_algs(dst, "preferred hash algorithms", sub.algs(), hash_alg_map);
  711|    551|        break;
  712|      0|    }
  713|    562|    case pkt::sigsub::Type::PreferredCompress: {
  ------------------
  |  Branch (713:5): [True: 562, False: 25.1k]
  ------------------
  714|    562|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredCompress &>(subpkt);
  715|    562|        dst_print_algs(dst, "preferred compression algorithms", sub.algs(), z_alg_map);
  716|    562|        break;
  717|      0|    }
  718|    215|    case pkt::sigsub::Type::KeyserverPrefs: {
  ------------------
  |  Branch (718:5): [True: 215, False: 25.5k]
  ------------------
  719|    215|        auto &sub = dynamic_cast<const pkt::sigsub::KeyserverPrefs &>(subpkt);
  720|    215|        dst_printf(dst, "%s\n", sname);
  721|    215|        dst_printf(dst, "no-modify: %d\n", sub.no_modify());
  722|    215|        break;
  723|      0|    }
  724|    510|    case pkt::sigsub::Type::PreferredKeyserver: {
  ------------------
  |  Branch (724:5): [True: 510, False: 25.2k]
  ------------------
  725|    510|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredKeyserver &>(subpkt);
  726|    510|        dst_print_str(dst, sname, sub.keyserver());
  727|    510|        break;
  728|      0|    }
  729|    255|    case pkt::sigsub::Type::PrimaryUserID: {
  ------------------
  |  Branch (729:5): [True: 255, False: 25.4k]
  ------------------
  730|    255|        auto &sub = dynamic_cast<const pkt::sigsub::PrimaryUserID &>(subpkt);
  731|    255|        dst_printf(dst, "%s: %d\n", sname, sub.primary());
  732|    255|        break;
  733|      0|    }
  734|    471|    case pkt::sigsub::Type::PolicyURI: {
  ------------------
  |  Branch (734:5): [True: 471, False: 25.2k]
  ------------------
  735|    471|        auto &sub = dynamic_cast<const pkt::sigsub::PolicyURI &>(subpkt);
  736|    471|        dst_print_str(dst, sname, sub.URI());
  737|    471|        break;
  738|      0|    }
  739|  1.43k|    case pkt::sigsub::Type::KeyFlags: {
  ------------------
  |  Branch (739:5): [True: 1.43k, False: 24.2k]
  ------------------
  740|  1.43k|        auto &  sub = dynamic_cast<const pkt::sigsub::KeyFlags &>(subpkt);
  741|  1.43k|        uint8_t flg = sub.flags();
  742|  1.43k|        dst_printf(dst, "%s: 0x%02x ( ", sname, flg);
  743|  1.43k|        dst_printf(dst, "%s", flg ? "" : "none");
  ------------------
  |  Branch (743:31): [True: 1.22k, False: 215]
  ------------------
  744|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_CERTIFY ? "certify " : "");
  ------------------
  |  Branch (744:31): [True: 686, False: 750]
  ------------------
  745|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_SIGN ? "sign " : "");
  ------------------
  |  Branch (745:31): [True: 687, False: 749]
  ------------------
  746|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_ENCRYPT_COMMS ? "encrypt_comm " : "");
  ------------------
  |  Branch (746:31): [True: 416, False: 1.02k]
  ------------------
  747|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_ENCRYPT_STORAGE ? "encrypt_storage " : "");
  ------------------
  |  Branch (747:31): [True: 521, False: 915]
  ------------------
  748|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_SPLIT ? "split " : "");
  ------------------
  |  Branch (748:31): [True: 456, False: 980]
  ------------------
  749|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_AUTH ? "auth " : "");
  ------------------
  |  Branch (749:31): [True: 456, False: 980]
  ------------------
  750|  1.43k|        dst_printf(dst, "%s", flg & PGP_KF_SHARED ? "shared " : "");
  ------------------
  |  Branch (750:31): [True: 216, False: 1.22k]
  ------------------
  751|  1.43k|        dst_printf(dst, ")\n");
  752|  1.43k|        break;
  753|      0|    }
  754|  2.51k|    case pkt::sigsub::Type::SignersUserID: {
  ------------------
  |  Branch (754:5): [True: 2.51k, False: 23.2k]
  ------------------
  755|  2.51k|        auto &sub = dynamic_cast<const pkt::sigsub::SignersUserID &>(subpkt);
  756|  2.51k|        dst_print_str(dst, sname, sub.signer());
  757|  2.51k|        break;
  758|      0|    }
  759|    641|    case pkt::sigsub::Type::RevocationReason: {
  ------------------
  |  Branch (759:5): [True: 641, False: 25.0k]
  ------------------
  760|    641|        auto &sub = dynamic_cast<const pkt::sigsub::RevocationReason &>(subpkt);
  761|    641|        auto  reason = id_str_pair::lookup(revoc_reason_map, sub.code(), "Unknown");
  762|    641|        dst_printf(dst, "%s: %" PRIu8 " (%s)\n", sname, sub.code(), reason);
  763|    641|        dst_print_str(dst, "message", sub.reason());
  764|    641|        break;
  765|      0|    }
  766|    983|    case pkt::sigsub::Type::Features: {
  ------------------
  |  Branch (766:5): [True: 983, False: 24.7k]
  ------------------
  767|    983|        auto &sub = dynamic_cast<const pkt::sigsub::Features &>(subpkt);
  768|    983|        dst_printf(dst, "%s: 0x%02x ( ", sname, sub.features());
  769|    983|        dst_printf(dst, "%s", sub.features() & PGP_KEY_FEATURE_MDC ? "mdc " : "");
  ------------------
  |  Branch (769:31): [True: 249, False: 734]
  ------------------
  770|    983|        dst_printf(dst, "%s", sub.features() & PGP_KEY_FEATURE_AEAD ? "aead " : "");
  ------------------
  |  Branch (770:31): [True: 234, False: 749]
  ------------------
  771|    983|        dst_printf(dst, "%s", sub.features() & PGP_KEY_FEATURE_V5 ? "v5 keys " : "");
  ------------------
  |  Branch (771:31): [True: 172, False: 811]
  ------------------
  772|    983|#if defined(ENABLE_CRYPTO_REFRESH)
  773|    983|        dst_printf(dst, "%s", sub.features() & PGP_KEY_FEATURE_SEIPDV2 ? "SEIPD v2 " : "");
  ------------------
  |  Branch (773:31): [True: 278, False: 705]
  ------------------
  774|    983|#endif
  775|    983|        dst_printf(dst, ")\n");
  776|    983|        break;
  777|      0|    }
  778|    567|    case pkt::sigsub::Type::EmbeddedSignature: {
  ------------------
  |  Branch (778:5): [True: 567, False: 25.1k]
  ------------------
  779|    567|        auto &sub = dynamic_cast<const pkt::sigsub::EmbeddedSignature &>(subpkt);
  780|    567|        dst_printf(dst, "%s:\n", sname);
  781|    567|        pkt::Signature sig(*sub.signature());
  782|    567|        dump_signature_pkt(sig);
  783|    567|        break;
  784|      0|    }
  785|  1.16k|    case pkt::sigsub::Type::IssuerFingerprint: {
  ------------------
  |  Branch (785:5): [True: 1.16k, False: 24.5k]
  ------------------
  786|  1.16k|        auto &sub = dynamic_cast<const pkt::sigsub::IssuerFingerprint &>(subpkt);
  787|  1.16k|        dst_print_fp(dst, sname, sub.fp());
  788|  1.16k|        break;
  789|      0|    }
  790|    285|    case pkt::sigsub::Type::PreferredAEAD: {
  ------------------
  |  Branch (790:5): [True: 285, False: 25.4k]
  ------------------
  791|    285|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredAEAD &>(subpkt);
  792|    285|        dst_print_algs(dst, "preferred aead algorithms", sub.algs(), aead_alg_map);
  793|    285|        break;
  794|      0|    }
  795|  7.09k|    default:
  ------------------
  |  Branch (795:5): [True: 7.09k, False: 18.6k]
  ------------------
  796|  7.09k|        if (!dump_packets) {
  ------------------
  |  Branch (796:13): [True: 0, False: 7.09k]
  ------------------
  797|      0|            indent_dest_increase(dst);
  798|      0|            dst_hexdump(dst, subpkt.data());
  799|      0|            indent_dest_decrease(dst);
  800|      0|        }
  801|  25.7k|    }
  802|  25.7k|}
_ZN3rnp14DumpContextDst25dump_signature_subpacketsERKN3pgp3pkt9SignatureEb:
  806|  17.7k|{
  807|  17.7k|    bool empty = true;
  808|       |
  809|  51.4k|    for (auto &subpkt : sig.subpkts) {
  ------------------
  |  Branch (809:23): [True: 51.4k, False: 17.7k]
  ------------------
  810|  51.4k|        if (subpkt->hashed() != hashed) {
  ------------------
  |  Branch (810:13): [True: 25.7k, False: 25.7k]
  ------------------
  811|  25.7k|            continue;
  812|  25.7k|        }
  813|  25.7k|        empty = false;
  814|  25.7k|        dst_printf(
  815|  25.7k|          dst, ":type %" PRIu8 ", len %zu", subpkt->raw_type(), subpkt->data().size());
  816|  25.7k|        dst_printf(dst, "%s\n", subpkt->critical() ? ", critical" : "");
  ------------------
  |  Branch (816:33): [True: 1.42k, False: 24.3k]
  ------------------
  817|  25.7k|        if (dump_packets) {
  ------------------
  |  Branch (817:13): [True: 25.7k, False: 0]
  ------------------
  818|  25.7k|            dst_printf(dst, ":subpacket contents:\n");
  819|  25.7k|            indent_dest_increase(dst);
  820|  25.7k|            dst_hexdump(dst, subpkt->data());
  821|  25.7k|            indent_dest_decrease(dst);
  822|  25.7k|        }
  823|  25.7k|        dump_signature_subpacket(*subpkt);
  824|  25.7k|    }
  825|       |
  826|  17.7k|    if (empty) {
  ------------------
  |  Branch (826:9): [True: 9.41k, False: 8.37k]
  ------------------
  827|  9.41k|        dst_printf(dst, "none\n");
  828|  9.41k|    }
  829|  17.7k|}
_ZN3rnp14DumpContextDst18dump_signature_pktERKN3pgp3pkt9SignatureE:
  833|  9.44k|{
  834|  9.44k|    indent_dest_increase(dst);
  835|       |
  836|  9.44k|    dst_printf(dst, "version: %d\n", (int) sig.version);
  837|  9.44k|    dst_print_sig_type(dst, "type", sig.type());
  838|  9.44k|    if (sig.version < PGP_V4) {
  ------------------
  |  Branch (838:9): [True: 547, False: 8.89k]
  ------------------
  839|    547|        dst_print_time(dst, "creation time", sig.creation_time);
  840|    547|        dst_print_keyid(dst, "signing key id", sig.signer);
  841|    547|    }
  842|  9.44k|    dst_print_palg(dst, NULL, sig.palg);
  843|  9.44k|    dst_print_halg(dst, NULL, sig.halg);
  844|       |
  845|  9.44k|    if (sig.version >= PGP_V4) {
  ------------------
  |  Branch (845:9): [True: 8.89k, False: 547]
  ------------------
  846|  8.89k|        dst_printf(dst, "hashed subpackets:\n");
  847|  8.89k|        indent_dest_increase(dst);
  848|  8.89k|        dump_signature_subpackets(sig, true);
  849|  8.89k|        indent_dest_decrease(dst);
  850|       |
  851|  8.89k|        dst_printf(dst, "unhashed subpackets:\n");
  852|  8.89k|        indent_dest_increase(dst);
  853|  8.89k|        dump_signature_subpackets(sig, false);
  854|  8.89k|        indent_dest_decrease(dst);
  855|  8.89k|    }
  856|       |
  857|  9.44k|    dst_print_hex(dst, "lbits", sig.lbits.data(), sig.lbits.size(), false);
  858|  9.44k|    dst_printf(dst, "signature material:\n");
  859|  9.44k|    indent_dest_increase(dst);
  860|       |
  861|  9.44k|    auto material = sig.parse_material();
  862|  9.44k|    assert(material);
  863|       |    /* LCOV_EXCL_START */
  864|  9.44k|    if (!material) {
  ------------------
  |  Branch (864:9): [True: 0, False: 9.44k]
  ------------------
  865|      0|        indent_dest_decrease(dst);
  866|      0|        indent_dest_decrease(dst);
  867|      0|        return;
  868|      0|    }
  869|       |    /* LCOV_EXCL_END */
  870|  9.44k|    switch (sig.palg) {
  871|  3.75k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (871:5): [True: 3.75k, False: 5.68k]
  ------------------
  872|  3.75k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (872:5): [True: 0, False: 9.44k]
  ------------------
  873|  6.79k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (873:5): [True: 3.04k, False: 6.40k]
  ------------------
  874|  6.79k|        auto &rsa = dynamic_cast<const RSASigMaterial &>(*material);
  875|  6.79k|        dst_print_mpi(dst, "rsa s", rsa.sig.s, dump_mpi);
  876|  6.79k|        break;
  877|  3.75k|    }
  878|    347|    case PGP_PKA_DSA: {
  ------------------
  |  Branch (878:5): [True: 347, False: 9.09k]
  ------------------
  879|    347|        auto &dsa = dynamic_cast<const DSASigMaterial &>(*material);
  880|    347|        dst_print_mpi(dst, "dsa r", dsa.sig.r, dump_mpi);
  881|    347|        dst_print_mpi(dst, "dsa s", dsa.sig.s, dump_mpi);
  882|    347|        break;
  883|  3.75k|    }
  884|    507|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (884:5): [True: 507, False: 8.93k]
  ------------------
  885|    967|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (885:5): [True: 460, False: 8.98k]
  ------------------
  886|  1.16k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (886:5): [True: 200, False: 9.24k]
  ------------------
  887|  1.60k|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (887:5): [True: 434, False: 9.00k]
  ------------------
  888|  1.60k|        auto &ec = dynamic_cast<const ECSigMaterial &>(*material);
  889|  1.60k|        dst_print_mpi(dst, "ecc r", ec.sig.r, dump_mpi);
  890|  1.60k|        dst_print_mpi(dst, "ecc s", ec.sig.s, dump_mpi);
  891|  1.60k|        break;
  892|  1.16k|    }
  893|       |    /* Wasn't able to find ElGamal sig artifacts so let's ignore this for coverage */
  894|       |    /* LCOV_EXCL_START */
  895|    282|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (895:5): [True: 282, False: 9.15k]
  ------------------
  896|    635|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (896:5): [True: 353, False: 9.08k]
  ------------------
  897|    635|        auto &eg = dynamic_cast<const EGSigMaterial &>(*material);
  898|    635|        dst_print_mpi(dst, "eg r", eg.sig.r, dump_mpi);
  899|    635|        dst_print_mpi(dst, "eg s", eg.sig.s, dump_mpi);
  900|    635|        break;
  901|    282|    }
  902|       |    /* LCOV_EXCL_END */
  903|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  904|     66|    case PGP_PKA_ED25519: {
  ------------------
  |  Branch (904:5): [True: 66, False: 9.37k]
  ------------------
  905|     66|        auto &ed = dynamic_cast<const Ed25519SigMaterial &>(*material);
  906|     66|        dst_print_vec(dst, "ed25519 sig", ed.sig.sig, dump_mpi);
  907|     66|        break;
  908|    282|    }
  909|      0|#endif
  910|      0|#if defined(ENABLE_PQC)
  911|      0|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (911:5): [True: 0, False: 9.44k]
  ------------------
  912|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  913|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
  914|      0|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (914:5): [True: 0, False: 9.44k]
  ------------------
  915|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  916|      0|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (916:5): [True: 0, False: 9.44k]
  ------------------
  917|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  918|      0|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (918:5): [True: 0, False: 9.44k]
  ------------------
  919|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  920|      0|    case PGP_PKA_DILITHIUM5_BP384: {
  ------------------
  |  Branch (920:5): [True: 0, False: 9.44k]
  ------------------
  921|      0|        auto &dilithium = dynamic_cast<const DilithiumSigMaterial &>(*material);
  922|      0|        dst_print_vec(dst, "mldsa-ecdsa/eddsa sig", dilithium.sig.sig, dump_mpi);
  923|      0|        break;
  924|      0|    }
  925|      0|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (925:5): [True: 0, False: 9.44k]
  ------------------
  926|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  927|      0|    case PGP_PKA_SPHINCSPLUS_SHAKE: {
  ------------------
  |  Branch (927:5): [True: 0, False: 9.44k]
  ------------------
  928|      0|        auto &slhdsa = dynamic_cast<const SlhdsaSigMaterial &>(*material);
  929|      0|        dst_print_vec(dst, "slhdsa sig", slhdsa.sig.sig, dump_mpi);
  930|      0|        break;
  931|      0|    }
  932|      0|#endif
  933|      0|    default:
  ------------------
  |  Branch (933:5): [True: 0, False: 9.44k]
  ------------------
  934|      0|        dst_printf(dst, "unknown algorithm\n");
  935|  9.44k|    }
  936|  9.44k|    indent_dest_decrease(dst);
  937|  9.44k|    indent_dest_decrease(dst);
  938|  9.44k|}
_ZN3rnp14DumpContextDst14dump_signatureEv:
  942|  23.7k|{
  943|  23.7k|    dst_printf(dst, "Signature packet\n");
  944|  23.7k|    pkt::Signature sig;
  945|  23.7k|    auto           ret = sig.parse(src);
  946|  23.7k|    if (ret) {
  ------------------
  |  Branch (946:9): [True: 14.9k, False: 8.87k]
  ------------------
  947|  14.9k|        indent_dest_increase(dst);
  948|  14.9k|        dst_printf(dst, "failed to parse\n");
  949|  14.9k|        indent_dest_decrease(dst);
  950|  14.9k|        return ret;
  951|  14.9k|    }
  952|  8.87k|    dump_signature_pkt(sig);
  953|  8.87k|    return RNP_SUCCESS;
  954|  23.7k|}
_ZN3rnp14DumpContextDst17dump_key_materialEPKN3pgp11KeyMaterialE:
  958|  20.4k|{
  959|  20.4k|    if (!material) {
  ------------------
  |  Branch (959:9): [True: 0, False: 20.4k]
  ------------------
  960|      0|        return;
  961|      0|    }
  962|  20.4k|    switch (material->alg()) {
  963|  2.98k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (963:5): [True: 2.98k, False: 17.4k]
  ------------------
  964|  6.39k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (964:5): [True: 3.41k, False: 17.0k]
  ------------------
  965|  10.4k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (965:5): [True: 4.08k, False: 16.3k]
  ------------------
  966|  10.4k|        auto &rsa = dynamic_cast<const RSAKeyMaterial &>(*material);
  967|  10.4k|        dst_print_mpi(dst, "rsa n", rsa.n(), dump_mpi);
  968|  10.4k|        dst_print_mpi(dst, "rsa e", rsa.e(), dump_mpi);
  969|  10.4k|        return;
  970|  6.39k|    }
  971|    354|    case PGP_PKA_DSA: {
  ------------------
  |  Branch (971:5): [True: 354, False: 20.0k]
  ------------------
  972|    354|        auto &dsa = dynamic_cast<const DSAKeyMaterial &>(*material);
  973|    354|        dst_print_mpi(dst, "dsa p", dsa.p(), dump_mpi);
  974|    354|        dst_print_mpi(dst, "dsa q", dsa.q(), dump_mpi);
  975|    354|        dst_print_mpi(dst, "dsa g", dsa.g(), dump_mpi);
  976|    354|        dst_print_mpi(dst, "dsa y", dsa.y(), dump_mpi);
  977|    354|        return;
  978|  6.39k|    }
  979|    549|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (979:5): [True: 549, False: 19.8k]
  ------------------
  980|    863|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (980:5): [True: 314, False: 20.1k]
  ------------------
  981|    863|        auto &eg = dynamic_cast<const EGKeyMaterial &>(*material);
  982|    863|        dst_print_mpi(dst, "eg p", eg.p(), dump_mpi);
  983|    863|        dst_print_mpi(dst, "eg g", eg.g(), dump_mpi);
  984|    863|        dst_print_mpi(dst, "eg y", eg.y(), dump_mpi);
  985|    863|        return;
  986|    549|    }
  987|    477|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (987:5): [True: 477, False: 19.9k]
  ------------------
  988|    791|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (988:5): [True: 314, False: 20.1k]
  ------------------
  989|  1.21k|    case PGP_PKA_SM2: {
  ------------------
  |  Branch (989:5): [True: 423, False: 20.0k]
  ------------------
  990|  1.21k|        auto &ec = dynamic_cast<const ECKeyMaterial &>(*material);
  991|  1.21k|        auto  cdesc = ec::Curve::get(ec.curve());
  992|  1.21k|        dst_print_mpi(dst, "ecc p", ec.p(), dump_mpi);
  993|  1.21k|        dst_printf(dst, "ecc curve: %s\n", cdesc ? cdesc->pgp_name : "unknown");
  ------------------
  |  Branch (993:44): [True: 490, False: 724]
  ------------------
  994|  1.21k|        return;
  995|    791|    }
  996|    426|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (996:5): [True: 426, False: 20.0k]
  ------------------
  997|    426|        auto &ec = dynamic_cast<const ECDHKeyMaterial &>(*material);
  998|    426|        auto  cdesc = ec::Curve::get(ec.curve());
  999|       |        /* Common EC fields */
 1000|    426|        dst_print_mpi(dst, "ecdh p", ec.p(), dump_mpi);
 1001|    426|        dst_printf(dst, "ecdh curve: %s\n", cdesc ? cdesc->pgp_name : "unknown");
  ------------------
  |  Branch (1001:45): [True: 135, False: 291]
  ------------------
 1002|       |        /* ECDH-only fields */
 1003|    426|        dst_print_halg(dst, "ecdh hash algorithm", ec.kdf_hash_alg());
 1004|    426|        dst_printf(dst, "ecdh key wrap algorithm: %d\n", (int) ec.key_wrap_alg());
 1005|    426|        return;
 1006|    791|    }
 1007|      0|#if defined(ENABLE_CRYPTO_REFRESH)
 1008|    380|    case PGP_PKA_ED25519: {
  ------------------
  |  Branch (1008:5): [True: 380, False: 20.0k]
  ------------------
 1009|    380|        auto &ed25519 = dynamic_cast<const Ed25519KeyMaterial &>(*material);
 1010|    380|        dst_print_vec(dst, "ed25519", ed25519.pub(), dump_mpi);
 1011|    380|        return;
 1012|    791|    }
 1013|    511|    case PGP_PKA_X25519: {
  ------------------
  |  Branch (1013:5): [True: 511, False: 19.9k]
  ------------------
 1014|    511|        auto &x25519 = dynamic_cast<const X25519KeyMaterial &>(*material);
 1015|    511|        dst_print_vec(dst, "x25519", x25519.pub(), dump_mpi);
 1016|    511|        return;
 1017|    791|    }
 1018|      0|#endif
 1019|      0|#if defined(ENABLE_PQC)
 1020|    217|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (1020:5): [True: 217, False: 20.2k]
  ------------------
 1021|    217|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    217|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1022|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
 1023|    404|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (1023:5): [True: 187, False: 20.2k]
  ------------------
 1024|    404|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    404|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1025|  1.09k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (1025:5): [True: 692, False: 19.7k]
  ------------------
 1026|  1.09k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.09k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1027|  1.30k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (1027:5): [True: 212, False: 20.2k]
  ------------------
 1028|  1.30k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.30k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1029|  1.66k|    case PGP_PKA_KYBER1024_BP384: {
  ------------------
  |  Branch (1029:5): [True: 353, False: 20.0k]
  ------------------
 1030|  1.66k|        auto &kyber = dynamic_cast<const MlkemEcdhKeyMaterial &>(*material);
 1031|  1.66k|        dst_print_vec(dst, "mlkem-ecdh encoded pubkey", kyber.pub().get_encoded(), dump_mpi);
 1032|  1.66k|        return;
 1033|  1.30k|    }
 1034|  2.07k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (1034:5): [True: 2.07k, False: 18.3k]
  ------------------
 1035|  2.07k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.07k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1036|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
 1037|  2.52k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (1037:5): [True: 450, False: 19.9k]
  ------------------
 1038|  2.52k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.52k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1039|  2.80k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (1039:5): [True: 275, False: 20.1k]
  ------------------
 1040|  2.80k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.80k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1041|  3.34k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (1041:5): [True: 536, False: 19.9k]
  ------------------
 1042|  3.34k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.34k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1043|  3.61k|    case PGP_PKA_DILITHIUM5_BP384: {
  ------------------
  |  Branch (1043:5): [True: 279, False: 20.1k]
  ------------------
 1044|  3.61k|        auto &dilithium = dynamic_cast<const DilithiumEccKeyMaterial &>(*material);
 1045|  3.61k|        dst_print_vec(
 1046|  3.61k|          dst, "mldsa-ecdsa/eddsa encodced pubkey", dilithium.pub().get_encoded(), dump_mpi);
 1047|  3.61k|        return;
 1048|  3.34k|    }
 1049|    278|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (1049:5): [True: 278, False: 20.1k]
  ------------------
 1050|    278|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    278|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1051|    932|    case PGP_PKA_SPHINCSPLUS_SHAKE: {
  ------------------
  |  Branch (1051:5): [True: 654, False: 19.7k]
  ------------------
 1052|    932|        auto &sphincs = dynamic_cast<const SlhdsaKeyMaterial &>(*material);
 1053|    932|        dst_print_vec(dst, "slhdsa encoded pubkey", sphincs.pub().get_encoded(), dump_mpi);
 1054|    932|        return;
 1055|    278|    }
 1056|      0|#endif
 1057|      0|    default:
  ------------------
  |  Branch (1057:5): [True: 0, False: 20.4k]
  ------------------
 1058|      0|        dst_printf(dst, "unknown public key algorithm\n");
 1059|  20.4k|    }
 1060|  20.4k|}
_ZN3rnp14DumpContextDst8dump_keyEv:
 1064|  33.8k|{
 1065|  33.8k|    pgp_key_pkt_t key;
 1066|  33.8k|    auto          ret = key.parse(src);
 1067|  33.8k|    if (ret) {
  ------------------
  |  Branch (1067:9): [True: 13.4k, False: 20.4k]
  ------------------
 1068|  13.4k|        return ret;
 1069|  13.4k|    }
 1070|       |
 1071|  20.4k|    dst_printf(dst, "%s packet\n", id_str_pair::lookup(key_type_map, key.tag, "Unknown"));
 1072|  20.4k|    indent_dest_increase(dst);
 1073|       |
 1074|  20.4k|    dst_printf(dst, "version: %d\n", (int) key.version);
 1075|  20.4k|    dst_print_time(dst, "creation time", key.creation_time);
 1076|  20.4k|    if (key.version < PGP_V4) {
  ------------------
  |  Branch (1076:9): [True: 1.58k, False: 18.8k]
  ------------------
 1077|  1.58k|        dst_printf(dst, "v3 validity days: %d\n", (int) key.v3_days);
 1078|  1.58k|    }
 1079|  20.4k|    dst_print_palg(dst, NULL, key.alg);
 1080|  20.4k|    if (key.version == PGP_V5) {
  ------------------
  |  Branch (1080:9): [True: 332, False: 20.1k]
  ------------------
 1081|    332|        dst_printf(dst, "v5 public key material length: %" PRIu32 "\n", key.v5_pub_len);
 1082|    332|    }
 1083|  20.4k|    dst_printf(dst, "public key material:\n");
 1084|  20.4k|    indent_dest_increase(dst);
 1085|  20.4k|    dump_key_material(key.material.get());
 1086|  20.4k|    indent_dest_decrease(dst);
 1087|       |
 1088|  20.4k|    if (is_secret_key_pkt(key.tag)) {
  ------------------
  |  Branch (1088:9): [True: 13.6k, False: 6.82k]
  ------------------
 1089|  13.6k|        dst_printf(dst, "secret key material:\n");
 1090|  13.6k|        indent_dest_increase(dst);
 1091|       |
 1092|  13.6k|        dst_printf(dst, "s2k usage: %d\n", (int) key.sec_protection.s2k.usage);
 1093|  13.6k|        if (key.version == PGP_V5) {
  ------------------
  |  Branch (1093:13): [True: 332, False: 13.2k]
  ------------------
 1094|    332|            dst_printf(dst, "v5 s2k length: %" PRIu8 "\n", key.v5_s2k_len);
 1095|    332|        }
 1096|  13.6k|        if ((key.sec_protection.s2k.usage == PGP_S2KU_ENCRYPTED) ||
  ------------------
  |  Branch (1096:13): [True: 8.98k, False: 4.63k]
  ------------------
 1097|  9.45k|            (key.sec_protection.s2k.usage == PGP_S2KU_ENCRYPTED_AND_HASHED)) {
  ------------------
  |  Branch (1097:13): [True: 475, False: 4.16k]
  ------------------
 1098|  9.45k|            dst_print_salg(dst, NULL, key.sec_protection.symm_alg);
 1099|  9.45k|            dst_print_s2k(dst, key.sec_protection.s2k);
 1100|  9.45k|            if (key.sec_protection.s2k.specifier != PGP_S2KS_EXPERIMENTAL) {
  ------------------
  |  Branch (1100:17): [True: 9.19k, False: 267]
  ------------------
 1101|  9.19k|                size_t bl_size = pgp_block_size(key.sec_protection.symm_alg);
 1102|  9.19k|                if (bl_size) {
  ------------------
  |  Branch (1102:21): [True: 9.19k, False: 0]
  ------------------
 1103|  9.19k|                    dst_print_hex(dst, "cipher iv", key.sec_protection.iv, bl_size, true);
 1104|  9.19k|                } else {
 1105|      0|                    dst_printf(dst, "cipher iv: unknown algorithm\n");
 1106|      0|                }
 1107|  9.19k|            }
 1108|  9.45k|        }
 1109|       |
 1110|  13.6k|        if (key.version == PGP_V5) {
  ------------------
  |  Branch (1110:13): [True: 332, False: 13.2k]
  ------------------
 1111|    332|            dst_printf(dst, "v5 secret key data length: %" PRIu32 "\n", key.v5_sec_len);
 1112|    332|        }
 1113|  13.6k|        if (!key.sec_protection.s2k.usage) {
  ------------------
  |  Branch (1113:13): [True: 4.16k, False: 9.45k]
  ------------------
 1114|  4.16k|            dst_printf(dst, "cleartext secret key data: %zu bytes\n", key.sec_data.size());
 1115|  9.45k|        } else {
 1116|  9.45k|            dst_printf(dst, "encrypted secret key data: %zu bytes\n", key.sec_data.size());
 1117|  9.45k|        }
 1118|  13.6k|        indent_dest_decrease(dst);
 1119|  13.6k|    }
 1120|       |
 1121|  20.4k|    try {
 1122|  20.4k|        Fingerprint fp(key);
 1123|  20.4k|        dst_print_keyid(dst, "keyid", fp.keyid());
 1124|       |
 1125|  20.4k|        if (dump_grips) {
  ------------------
  |  Branch (1125:13): [True: 0, False: 20.4k]
  ------------------
 1126|      0|            dst_print_fp(dst, "fingerprint", fp, false);
 1127|      0|        }
 1128|  20.4k|    } catch (const std::exception &e) {
 1129|      0|        dst_printf(dst, "failed to calculate fingerprint and/or keyid\n");
 1130|      0|    }
 1131|       |
 1132|  20.4k|    if (dump_grips) {
  ------------------
  |  Branch (1132:9): [True: 0, False: 20.4k]
  ------------------
 1133|      0|        if (key.material) {
  ------------------
  |  Branch (1133:13): [True: 0, False: 0]
  ------------------
 1134|      0|            KeyGrip grip = key.material->grip();
 1135|      0|            dst_print_hex(dst, "grip", grip.data(), grip.size(), false);
 1136|      0|        } else {
 1137|      0|            dst_printf(dst, "grip: failed to calculate\n");
 1138|      0|        }
 1139|      0|    }
 1140|       |
 1141|  20.4k|    indent_dest_decrease(dst);
 1142|  20.4k|    return RNP_SUCCESS;
 1143|  20.4k|}
_ZN3rnp14DumpContextDst11dump_useridEv:
 1147|  13.6k|{
 1148|  13.6k|    pgp_userid_pkt_t uid;
 1149|  13.6k|    auto             ret = uid.parse(src);
 1150|  13.6k|    if (ret) {
  ------------------
  |  Branch (1150:9): [True: 546, False: 13.1k]
  ------------------
 1151|    546|        return ret;
 1152|    546|    }
 1153|       |
 1154|  13.1k|    const char *utype = NULL;
 1155|  13.1k|    switch (uid.tag) {
 1156|  10.6k|    case PGP_PKT_USER_ID:
  ------------------
  |  Branch (1156:5): [True: 10.6k, False: 2.51k]
  ------------------
 1157|  10.6k|        utype = "UserID";
 1158|  10.6k|        break;
 1159|  2.51k|    case PGP_PKT_USER_ATTR:
  ------------------
  |  Branch (1159:5): [True: 2.51k, False: 10.6k]
  ------------------
 1160|  2.51k|        utype = "UserAttr";
 1161|  2.51k|        break;
 1162|      0|    default:
  ------------------
  |  Branch (1162:5): [True: 0, False: 13.1k]
  ------------------
 1163|      0|        utype = "Unknown user id";
 1164|  13.1k|    }
 1165|       |
 1166|  13.1k|    dst_printf(dst, "%s packet\n", utype);
 1167|  13.1k|    indent_dest_increase(dst);
 1168|       |
 1169|  13.1k|    switch (uid.tag) {
 1170|  10.6k|    case PGP_PKT_USER_ID:
  ------------------
  |  Branch (1170:5): [True: 10.6k, False: 2.51k]
  ------------------
 1171|  10.6k|        dst_printf(dst, "id: ");
 1172|  10.6k|        dst_write(dst, uid.uid);
 1173|  10.6k|        dst_printf(dst, "\n");
 1174|  10.6k|        break;
 1175|  2.51k|    case PGP_PKT_USER_ATTR:
  ------------------
  |  Branch (1175:5): [True: 2.51k, False: 10.6k]
  ------------------
 1176|  2.51k|        dst_printf(dst, "id: (%zu bytes of data)\n", uid.uid.size());
 1177|  2.51k|        break;
 1178|      0|    default:;
  ------------------
  |  Branch (1178:5): [True: 0, False: 13.1k]
  ------------------
 1179|  13.1k|    }
 1180|       |
 1181|  13.1k|    indent_dest_decrease(dst);
 1182|  13.1k|    return RNP_SUCCESS;
 1183|  13.1k|}
_ZN3rnp14DumpContextDst19dump_pk_session_keyEv:
 1187|  8.51k|{
 1188|  8.51k|    pgp_pk_sesskey_t pkey;
 1189|  8.51k|    auto             ret = pkey.parse(src);
 1190|  8.51k|    if (ret) {
  ------------------
  |  Branch (1190:9): [True: 5.42k, False: 3.08k]
  ------------------
 1191|  5.42k|        return ret;
 1192|  5.42k|    }
 1193|  3.08k|    auto material = pkey.parse_material();
 1194|  3.08k|    if (!material) {
  ------------------
  |  Branch (1194:9): [True: 0, False: 3.08k]
  ------------------
 1195|      0|        return RNP_ERROR_BAD_FORMAT;
 1196|      0|    }
 1197|       |
 1198|  3.08k|    dst_printf(dst, "Public-key encrypted session key packet\n");
 1199|  3.08k|    indent_dest_increase(dst);
 1200|       |
 1201|  3.08k|    dst_printf(dst, "version: %d\n", (int) pkey.version);
 1202|  3.08k|#if defined(ENABLE_CRYPTO_REFRESH)
 1203|  3.08k|    if (pkey.version == PGP_PKSK_V6) {
  ------------------
  |  Branch (1203:9): [True: 1.32k, False: 1.76k]
  ------------------
 1204|  1.32k|        dst_print_fp(dst, "fingerprint", pkey.fp);
 1205|  1.76k|    } else {
 1206|  1.76k|        dst_print_keyid(dst, "key id", pkey.key_id);
 1207|  1.76k|    }
 1208|       |#else
 1209|       |    dst_print_keyid(dst, "key id", pkey.key_id);
 1210|       |#endif
 1211|  3.08k|    dst_print_palg(dst, NULL, pkey.alg);
 1212|  3.08k|    dst_printf(dst, "encrypted material:\n");
 1213|  3.08k|    indent_dest_increase(dst);
 1214|       |
 1215|  3.08k|    switch (pkey.alg) {
 1216|  1.40k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (1216:5): [True: 1.40k, False: 1.68k]
  ------------------
 1217|  1.67k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (1217:5): [True: 277, False: 2.81k]
  ------------------
 1218|  1.67k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (1218:5): [True: 0, False: 3.08k]
  ------------------
 1219|  1.67k|        auto &rsa = dynamic_cast<const RSAEncMaterial &>(*material).enc;
 1220|  1.67k|        dst_print_mpi(dst, "rsa m", rsa.m, dump_mpi);
 1221|  1.67k|        break;
 1222|  1.67k|    }
 1223|    219|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (1223:5): [True: 219, False: 2.86k]
  ------------------
 1224|    424|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (1224:5): [True: 205, False: 2.88k]
  ------------------
 1225|    424|        auto &eg = dynamic_cast<const EGEncMaterial &>(*material).enc;
 1226|    424|        dst_print_mpi(dst, "eg g", eg.g, dump_mpi);
 1227|    424|        dst_print_mpi(dst, "eg m", eg.m, dump_mpi);
 1228|    424|        break;
 1229|    219|    }
 1230|    216|    case PGP_PKA_SM2: {
  ------------------
  |  Branch (1230:5): [True: 216, False: 2.87k]
  ------------------
 1231|    216|        auto &sm2 = dynamic_cast<const SM2EncMaterial &>(*material).enc;
 1232|    216|        dst_print_mpi(dst, "sm2 m", sm2.m, dump_mpi);
 1233|    216|        break;
 1234|    219|    }
 1235|    325|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (1235:5): [True: 325, False: 2.76k]
  ------------------
 1236|    325|        auto &ecdh = dynamic_cast<const ECDHEncMaterial &>(*material).enc;
 1237|    325|        dst_print_mpi(dst, "ecdh p", ecdh.p, dump_mpi);
 1238|    325|        if (dump_mpi) {
  ------------------
  |  Branch (1238:13): [True: 0, False: 325]
  ------------------
 1239|      0|            dst_print_hex(dst, "ecdh m", ecdh.m.data(), ecdh.m.size(), true);
 1240|    325|        } else {
 1241|    325|            dst_printf(dst, "ecdh m: %zu bytes\n", ecdh.m.size());
 1242|    325|        }
 1243|    325|        break;
 1244|    219|    }
 1245|      0|#if defined(ENABLE_CRYPTO_REFRESH)
 1246|    325|    case PGP_PKA_X25519: {
  ------------------
  |  Branch (1246:5): [True: 325, False: 2.76k]
  ------------------
 1247|    325|        auto &x25519 = dynamic_cast<const X25519EncMaterial &>(*material).enc;
 1248|    325|        dst_print_vec(dst, "x25519 ephemeral public key", x25519.eph_key, dump_mpi);
 1249|    325|        dst_print_vec(dst, "x25519 encrypted session key", x25519.enc_sess_key, dump_mpi);
 1250|    325|        break;
 1251|    219|    }
 1252|      0|#endif
 1253|      0|#if defined(ENABLE_PQC)
 1254|     17|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (1254:5): [True: 17, False: 3.07k]
  ------------------
 1255|     17|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     17|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1256|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
 1257|     28|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (1257:5): [True: 11, False: 3.07k]
  ------------------
 1258|     28|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     28|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1259|     59|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (1259:5): [True: 31, False: 3.05k]
  ------------------
 1260|     59|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     59|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1261|    101|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (1261:5): [True: 42, False: 3.04k]
  ------------------
 1262|    101|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    101|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 1263|    119|    case PGP_PKA_KYBER1024_BP384: {
  ------------------
  |  Branch (1263:5): [True: 18, False: 3.06k]
  ------------------
 1264|    119|        auto &mlkem = dynamic_cast<const MlkemEcdhEncMaterial &>(*material).enc;
 1265|    119|        dst_print_vec(
 1266|    119|          dst, "mlkem-ecdh composite ciphertext", mlkem.composite_ciphertext, dump_mpi);
 1267|    119|        dst_print_vec(dst, "mlkem-ecdh wrapped session key", mlkem.wrapped_sesskey, dump_mpi);
 1268|    119|        break;
 1269|    101|    }
 1270|      0|#endif
 1271|      0|    default:
  ------------------
  |  Branch (1271:5): [True: 0, False: 3.08k]
  ------------------
 1272|      0|        dst_printf(dst, "unknown public key algorithm\n");
 1273|  3.08k|    }
 1274|       |
 1275|  3.08k|    indent_dest_decrease(dst);
 1276|  3.08k|    indent_dest_decrease(dst);
 1277|  3.08k|    return RNP_SUCCESS;
 1278|  3.08k|}
_ZN3rnp14DumpContextDst19dump_sk_session_keyEv:
 1282|  7.36k|{
 1283|  7.36k|    pgp_sk_sesskey_t skey;
 1284|  7.36k|    auto             ret = skey.parse(src);
 1285|  7.36k|    if (ret) {
  ------------------
  |  Branch (1285:9): [True: 3.73k, False: 3.62k]
  ------------------
 1286|  3.73k|        return ret;
 1287|  3.73k|    }
 1288|       |
 1289|  3.62k|    dst_printf(dst, "Symmetric-key encrypted session key packet\n");
 1290|  3.62k|    indent_dest_increase(dst);
 1291|  3.62k|    dst_printf(dst, "version: %d\n", (int) skey.version);
 1292|  3.62k|    dst_print_salg(dst, NULL, skey.alg);
 1293|  3.62k|    if (skey.version == PGP_SKSK_V5) {
  ------------------
  |  Branch (1293:9): [True: 485, False: 3.13k]
  ------------------
 1294|    485|        dst_print_aalg(dst, NULL, skey.aalg);
 1295|    485|    }
 1296|  3.62k|    dst_print_s2k(dst, skey.s2k);
 1297|  3.62k|    if (skey.version == PGP_SKSK_V5) {
  ------------------
  |  Branch (1297:9): [True: 485, False: 3.13k]
  ------------------
 1298|    485|        dst_print_hex(dst, "aead iv", skey.iv, skey.ivlen, true);
 1299|    485|    }
 1300|  3.62k|    dst_print_hex(dst, "encrypted key", skey.enckey, skey.enckeylen, true);
 1301|  3.62k|    indent_dest_decrease(dst);
 1302|       |
 1303|  3.62k|    return RNP_SUCCESS;
 1304|  7.36k|}
_ZN3rnp14DumpContextDst19dump_aead_encryptedEv:
 1308|    658|{
 1309|    658|    dst_printf(dst, "AEAD-encrypted data packet\n");
 1310|       |
 1311|    658|    pgp_aead_hdr_t aead{};
 1312|    658|    if (!get_aead_hdr(aead)) {
  ------------------
  |  Branch (1312:9): [True: 582, False: 76]
  ------------------
 1313|    582|        dst_printf(dst, "ERROR: failed to read AEAD header\n");
 1314|    582|        return RNP_ERROR_READ;
 1315|    582|    }
 1316|       |
 1317|     76|    indent_dest_increase(dst);
 1318|       |
 1319|     76|    dst_printf(dst, "version: %d\n", (int) aead.version);
 1320|     76|    dst_print_salg(dst, NULL, aead.ealg);
 1321|     76|    dst_print_aalg(dst, NULL, aead.aalg);
 1322|     76|    dst_printf(dst, "chunk size: %d\n", (int) aead.csize);
 1323|     76|    dst_print_hex(dst, "initialization vector", aead.iv, aead.ivlen, true);
 1324|       |
 1325|     76|    indent_dest_decrease(dst);
 1326|     76|    return RNP_SUCCESS;
 1327|    658|}
_ZN3rnp14DumpContextDst14dump_encryptedEi:
 1331|    861|{
 1332|    861|    switch (tag) {
 1333|    107|    case PGP_PKT_SE_DATA:
  ------------------
  |  Branch (1333:5): [True: 107, False: 754]
  ------------------
 1334|    107|        dst_printf(dst, "Symmetrically-encrypted data packet\n\n");
 1335|    107|        break;
 1336|     96|    case PGP_PKT_SE_IP_DATA:
  ------------------
  |  Branch (1336:5): [True: 96, False: 765]
  ------------------
 1337|     96|        dst_printf(dst, "Symmetrically-encrypted integrity protected data packet\n\n");
 1338|     96|        break;
 1339|    658|    case PGP_PKT_AEAD_ENCRYPTED:
  ------------------
  |  Branch (1339:5): [True: 658, False: 203]
  ------------------
 1340|    658|        return dump_aead_encrypted();
 1341|      0|    default:
  ------------------
  |  Branch (1341:5): [True: 0, False: 861]
  ------------------
 1342|      0|        dst_printf(dst, "Unknown encrypted data packet\n\n");
 1343|      0|        break;
 1344|    861|    }
 1345|       |
 1346|    203|    return stream_skip_packet(&src);
 1347|    861|}
_ZN3rnp14DumpContextDst13dump_one_passEv:
 1351|  1.27k|{
 1352|  1.27k|    pgp_one_pass_sig_t onepass;
 1353|  1.27k|    auto               ret = onepass.parse(src);
 1354|  1.27k|    if (ret) {
  ------------------
  |  Branch (1354:9): [True: 873, False: 404]
  ------------------
 1355|    873|        return ret;
 1356|    873|    }
 1357|       |
 1358|    404|    dst_printf(dst, "One-pass signature packet\n");
 1359|    404|    indent_dest_increase(dst);
 1360|       |
 1361|    404|    dst_printf(dst, "version: %d\n", (int) onepass.version);
 1362|    404|    dst_print_sig_type(dst, NULL, onepass.type);
 1363|    404|    dst_print_halg(dst, NULL, onepass.halg);
 1364|    404|    dst_print_palg(dst, NULL, onepass.palg);
 1365|    404|    dst_print_keyid(dst, "signing key id", onepass.keyid);
 1366|    404|    dst_printf(dst, "nested: %d\n", (int) onepass.nested);
 1367|       |
 1368|    404|    indent_dest_decrease(dst);
 1369|    404|    return RNP_SUCCESS;
 1370|  1.27k|}
_ZN3rnp14DumpContextDst15dump_compressedEv:
 1374|  10.7k|{
 1375|  10.7k|    std::unique_ptr<Source> zsrc(new Source());
 1376|  10.7k|    auto                    ret = init_compressed_src(&zsrc->src(), &src);
 1377|  10.7k|    if (ret) {
  ------------------
  |  Branch (1377:9): [True: 582, False: 10.1k]
  ------------------
 1378|    582|        return ret;
 1379|    582|    }
 1380|       |
 1381|  10.1k|    dst_printf(dst, "Compressed data packet\n");
 1382|  10.1k|    indent_dest_increase(dst);
 1383|       |
 1384|  10.1k|    uint8_t zalg = 0;
 1385|  10.1k|    get_compressed_src_alg(&zsrc->src(), &zalg);
 1386|  10.1k|    dst_print_zalg(dst, NULL, (pgp_compression_type_t) zalg);
 1387|  10.1k|    dst_printf(dst, "Decompressed contents:\n");
 1388|       |
 1389|  10.1k|    std::unique_ptr<DumpContextDst> ctx(new DumpContextDst(zsrc->src(), dst));
 1390|  10.1k|    ctx->copy_params(*this);
 1391|  10.1k|    ret = ctx->dump(true);
 1392|  10.1k|    copy_params(*ctx);
 1393|  10.1k|    indent_dest_decrease(dst);
 1394|  10.1k|    return ret;
 1395|  10.7k|}
_ZN3rnp14DumpContextDst12dump_literalEv:
 1399|    846|{
 1400|    846|    Source lsrc;
 1401|    846|    auto   ret = init_literal_src(&lsrc.src(), &src);
 1402|    846|    if (ret) {
  ------------------
  |  Branch (1402:9): [True: 505, False: 341]
  ------------------
 1403|    505|        return ret;
 1404|    505|    }
 1405|       |
 1406|    341|    dst_printf(dst, "Literal data packet\n");
 1407|    341|    indent_dest_increase(dst);
 1408|       |
 1409|    341|    auto &lhdr = get_literal_src_hdr(lsrc.src());
 1410|    341|    dst_printf(dst, "data format: '%c'\n", lhdr.format);
 1411|    341|    dst_printf(dst, "filename: %s (len %" PRIu8 ")\n", lhdr.fname, lhdr.fname_len);
 1412|    341|    dst_print_time(dst, "timestamp", lhdr.timestamp);
 1413|       |
 1414|    341|    ret = RNP_SUCCESS;
 1415|   980k|    while (!lsrc.eof()) {
  ------------------
  |  Branch (1415:12): [True: 979k, False: 307]
  ------------------
 1416|   979k|        uint8_t readbuf[16384];
 1417|   979k|        size_t  read = 0;
 1418|   979k|        if (!lsrc.src().read(readbuf, sizeof(readbuf), &read)) {
  ------------------
  |  Branch (1418:13): [True: 34, False: 979k]
  ------------------
 1419|     34|            ret = RNP_ERROR_READ;
 1420|     34|            break;
 1421|     34|        }
 1422|   979k|    }
 1423|       |
 1424|    341|    dst_printf(dst, "data bytes: %zu\n", lsrc.readb());
 1425|    341|    indent_dest_decrease(dst);
 1426|    341|    return ret;
 1427|    846|}
_ZN3rnp14DumpContextDst11dump_markerEv:
 1431|  1.63k|{
 1432|  1.63k|    dst_printf(dst, "Marker packet\n");
 1433|  1.63k|    indent_dest_increase(dst);
 1434|  1.63k|    auto ret = stream_parse_marker(src);
 1435|  1.63k|    dst_printf(dst, "contents: %s\n", ret ? "invalid" : PGP_MARKER_CONTENTS);
  ------------------
  |  |  103|    162|#define PGP_MARKER_CONTENTS "PGP"
  ------------------
  |  Branch (1435:39): [True: 1.47k, False: 162]
  ------------------
 1436|  1.63k|    indent_dest_decrease(dst);
 1437|  1.63k|    return ret;
 1438|  1.63k|}
_ZN3rnp14DumpContextDst16dump_raw_packetsEv:
 1442|  17.3k|{
 1443|  17.3k|    char         msg[1024 + PGP_MAX_HEADER_SIZE] = {0};
 1444|  17.3k|    char         smsg[128] = {0};
 1445|  17.3k|    rnp_result_t ret = RNP_ERROR_GENERIC;
 1446|       |
 1447|  17.3k|    if (src.eof()) {
  ------------------
  |  Branch (1447:9): [True: 0, False: 17.3k]
  ------------------
 1448|      0|        return RNP_SUCCESS;
 1449|      0|    }
 1450|       |
 1451|       |    /* do not allow endless recursion */
 1452|  17.3k|    if (++layers > MAXIMUM_NESTING_LEVEL) {
  ------------------
  |  |   60|  17.3k|#define MAXIMUM_NESTING_LEVEL 32
  ------------------
  |  Branch (1452:9): [True: 19, False: 17.3k]
  ------------------
 1453|     19|        RNP_LOG("Too many OpenPGP nested layers during the dump.");
  ------------------
  |  |   76|     19|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     19|    do {                                                                                 \
  |  |  |  |   69|     19|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 19, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     19|            break;                                                                       \
  |  |  |  |   71|     19|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1454|     19|        dst_printf(dst, ":too many OpenPGP packet layers, stopping.\n");
 1455|     19|        return RNP_SUCCESS;
 1456|     19|    }
 1457|       |
 1458|   184k|    while (!src.eof()) {
  ------------------
  |  Branch (1458:12): [True: 174k, False: 9.55k]
  ------------------
 1459|   174k|        pgp_packet_hdr_t hdr{};
 1460|   174k|        size_t           off = src.readb;
 1461|   174k|        rnp_result_t     hdrret = stream_peek_packet_hdr(&src, &hdr);
 1462|   174k|        if (hdrret) {
  ------------------
  |  Branch (1462:13): [True: 3.42k, False: 171k]
  ------------------
 1463|  3.42k|            return hdrret;
 1464|  3.42k|        }
 1465|       |
 1466|   171k|        if (hdr.partial) {
  ------------------
  |  Branch (1466:13): [True: 6.71k, False: 164k]
  ------------------
 1467|  6.71k|            snprintf(msg, sizeof(msg), "partial len");
 1468|   164k|        } else if (hdr.indeterminate) {
  ------------------
  |  Branch (1468:20): [True: 13.0k, False: 151k]
  ------------------
 1469|  13.0k|            snprintf(msg, sizeof(msg), "indeterminate len");
 1470|   151k|        } else {
 1471|   151k|            snprintf(msg, sizeof(msg), "len %zu", hdr.pkt_len);
 1472|   151k|        }
 1473|   171k|        vsnprinthex(smsg, sizeof(smsg), hdr.hdr, hdr.hdr_len);
 1474|   171k|        dst_printf(
 1475|   171k|          dst, ":off %zu: packet header 0x%s (tag %d, %s)\n", off, smsg, hdr.tag, msg);
 1476|       |
 1477|   171k|        if (dump_packets) {
  ------------------
  |  Branch (1477:13): [True: 171k, False: 0]
  ------------------
 1478|   171k|            size_t rlen = hdr.pkt_len + hdr.hdr_len;
 1479|   171k|            bool   part = false;
 1480|       |
 1481|   171k|            if (!hdr.pkt_len || (rlen > 1024 + hdr.hdr_len)) {
  ------------------
  |  Branch (1481:17): [True: 76.9k, False: 94.5k]
  |  Branch (1481:33): [True: 15.6k, False: 78.8k]
  ------------------
 1482|  92.6k|                rlen = 1024 + hdr.hdr_len;
 1483|  92.6k|                part = true;
 1484|  92.6k|            }
 1485|       |
 1486|   171k|            dst_printf(dst, ":off %zu: packet contents ", off + hdr.hdr_len);
 1487|   171k|            if (!src.peek(msg, rlen, &rlen)) {
  ------------------
  |  Branch (1487:17): [True: 175, False: 171k]
  ------------------
 1488|    175|                dst_printf(dst, "- failed to read\n");
 1489|   171k|            } else {
 1490|   171k|                rlen -= hdr.hdr_len;
 1491|   171k|                if (part || (rlen < hdr.pkt_len)) {
  ------------------
  |  Branch (1491:21): [True: 92.5k, False: 78.7k]
  |  Branch (1491:29): [True: 2.33k, False: 76.4k]
  ------------------
 1492|  94.9k|                    dst_printf(dst, "(first %zu bytes)\n", rlen);
 1493|  94.9k|                } else {
 1494|  76.4k|                    dst_printf(dst, "(%zu bytes)\n", rlen);
 1495|  76.4k|                }
 1496|   171k|                indent_dest_increase(dst);
 1497|   171k|                dst_hexdump(dst, (uint8_t *) msg + hdr.hdr_len, rlen);
 1498|   171k|                indent_dest_decrease(dst);
 1499|   171k|            }
 1500|   171k|            dst_printf(dst, "\n");
 1501|   171k|        }
 1502|       |
 1503|   171k|        switch (hdr.tag) {
 1504|  23.7k|        case PGP_PKT_SIGNATURE:
  ------------------
  |  Branch (1504:9): [True: 23.7k, False: 147k]
  ------------------
 1505|  23.7k|            ret = dump_signature();
 1506|  23.7k|            break;
 1507|  12.2k|        case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (1507:9): [True: 12.2k, False: 159k]
  ------------------
 1508|  17.5k|        case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (1508:9): [True: 5.30k, False: 166k]
  ------------------
 1509|  27.3k|        case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (1509:9): [True: 9.76k, False: 161k]
  ------------------
 1510|  33.8k|        case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (1510:9): [True: 6.56k, False: 164k]
  ------------------
 1511|  33.8k|            ret = dump_key();
 1512|  33.8k|            break;
 1513|  11.0k|        case PGP_PKT_USER_ID:
  ------------------
  |  Branch (1513:9): [True: 11.0k, False: 160k]
  ------------------
 1514|  13.6k|        case PGP_PKT_USER_ATTR:
  ------------------
  |  Branch (1514:9): [True: 2.64k, False: 168k]
  ------------------
 1515|  13.6k|            ret = dump_userid();
 1516|  13.6k|            break;
 1517|  8.51k|        case PGP_PKT_PK_SESSION_KEY:
  ------------------
  |  Branch (1517:9): [True: 8.51k, False: 162k]
  ------------------
 1518|  8.51k|            ret = dump_pk_session_key();
 1519|  8.51k|            break;
 1520|  7.36k|        case PGP_PKT_SK_SESSION_KEY:
  ------------------
  |  Branch (1520:9): [True: 7.36k, False: 164k]
  ------------------
 1521|  7.36k|            ret = dump_sk_session_key();
 1522|  7.36k|            break;
 1523|    107|        case PGP_PKT_SE_DATA:
  ------------------
  |  Branch (1523:9): [True: 107, False: 171k]
  ------------------
 1524|    203|        case PGP_PKT_SE_IP_DATA:
  ------------------
  |  Branch (1524:9): [True: 96, False: 171k]
  ------------------
 1525|    861|        case PGP_PKT_AEAD_ENCRYPTED:
  ------------------
  |  Branch (1525:9): [True: 658, False: 170k]
  ------------------
 1526|    861|            stream_pkts++;
 1527|    861|            ret = dump_encrypted(hdr.tag);
 1528|    861|            break;
 1529|  1.27k|        case PGP_PKT_ONE_PASS_SIG:
  ------------------
  |  Branch (1529:9): [True: 1.27k, False: 170k]
  ------------------
 1530|  1.27k|            ret = dump_one_pass();
 1531|  1.27k|            break;
 1532|  10.7k|        case PGP_PKT_COMPRESSED:
  ------------------
  |  Branch (1532:9): [True: 10.7k, False: 160k]
  ------------------
 1533|  10.7k|            stream_pkts++;
 1534|  10.7k|            ret = dump_compressed();
 1535|  10.7k|            break;
 1536|    846|        case PGP_PKT_LITDATA:
  ------------------
  |  Branch (1536:9): [True: 846, False: 170k]
  ------------------
 1537|    846|            stream_pkts++;
 1538|    846|            ret = dump_literal();
 1539|    846|            break;
 1540|  1.63k|        case PGP_PKT_MARKER:
  ------------------
  |  Branch (1540:9): [True: 1.63k, False: 169k]
  ------------------
 1541|  1.63k|            ret = dump_marker();
 1542|  1.63k|            break;
 1543|  4.42k|        case PGP_PKT_TRUST:
  ------------------
  |  Branch (1543:9): [True: 4.42k, False: 167k]
  ------------------
 1544|  7.04k|        case PGP_PKT_MDC:
  ------------------
  |  Branch (1544:9): [True: 2.62k, False: 168k]
  ------------------
 1545|  7.04k|            dst_printf(dst, "Skipping unhandled pkt: %d\n\n", (int) hdr.tag);
 1546|  7.04k|            ret = stream_skip_packet(&src);
 1547|  7.04k|            break;
 1548|  61.8k|        default:
  ------------------
  |  Branch (1548:9): [True: 61.8k, False: 109k]
  ------------------
 1549|  61.8k|            dst_printf(dst, "Skipping Unknown pkt: %d\n\n", (int) hdr.tag);
 1550|  61.8k|            ret = stream_skip_packet(&src);
 1551|  61.8k|            if (ret) {
  ------------------
  |  Branch (1551:17): [True: 533, False: 61.3k]
  ------------------
 1552|    533|                return ret;
 1553|    533|            }
 1554|  61.3k|            if (++failures > MAXIMUM_ERROR_PKTS) {
  ------------------
  |  |   62|  61.3k|#define MAXIMUM_ERROR_PKTS 64
  ------------------
  |  Branch (1554:17): [True: 981, False: 60.3k]
  ------------------
 1555|    981|                RNP_LOG("too many packet dump errors or unknown packets.");
  ------------------
  |  |   76|    981|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    981|    do {                                                                                 \
  |  |  |  |   69|    981|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 981, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    981|            break;                                                                       \
  |  |  |  |   71|    981|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1556|    981|                return ret;
 1557|    981|            }
 1558|   171k|        }
 1559|       |
 1560|   169k|        if (ret) {
  ------------------
  |  Branch (1560:13): [True: 46.6k, False: 123k]
  ------------------
 1561|  46.6k|            RNP_LOG("failed to process packet");
  ------------------
  |  |   76|  46.6k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  46.6k|    do {                                                                                 \
  |  |  |  |   69|  46.6k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 46.6k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  46.6k|            break;                                                                       \
  |  |  |  |   71|  46.6k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1562|  46.6k|            if (++failures > MAXIMUM_ERROR_PKTS) {
  ------------------
  |  |   62|  46.6k|#define MAXIMUM_ERROR_PKTS 64
  ------------------
  |  Branch (1562:17): [True: 1.74k, False: 44.9k]
  ------------------
 1563|  1.74k|                RNP_LOG("too many packet dump errors.");
  ------------------
  |  |   76|  1.74k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.74k|    do {                                                                                 \
  |  |  |  |   69|  1.74k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.74k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.74k|            break;                                                                       \
  |  |  |  |   71|  1.74k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1564|  1.74k|                return ret;
 1565|  1.74k|            }
 1566|  46.6k|        }
 1567|       |
 1568|   168k|        if (stream_pkts > MAXIMUM_STREAM_PKTS) {
  ------------------
  |  |   61|   168k|#define MAXIMUM_STREAM_PKTS 16
  ------------------
  |  Branch (1568:13): [True: 1.13k, False: 167k]
  ------------------
 1569|  1.13k|            RNP_LOG("Too many OpenPGP stream packets during the dump.");
  ------------------
  |  |   76|  1.13k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.13k|    do {                                                                                 \
  |  |  |  |   69|  1.13k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.13k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.13k|            break;                                                                       \
  |  |  |  |   71|  1.13k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1570|  1.13k|            dst_printf(dst, ":too many OpenPGP stream packets, stopping.\n");
 1571|  1.13k|            return RNP_SUCCESS;
 1572|  1.13k|        }
 1573|   168k|    }
 1574|  9.55k|    return RNP_SUCCESS;
 1575|  17.3k|}
_ZN3rnp14DumpContextDst4dumpEb:
 1579|  18.4k|{
 1580|       |    /* check whether source is cleartext - then skip till the signature */
 1581|  18.4k|    if (!raw_only && src.is_cleartext()) {
  ------------------
  |  Branch (1581:9): [True: 7.83k, False: 10.5k]
  |  Branch (1581:22): [True: 18, False: 7.81k]
  ------------------
 1582|     18|        dst_printf(dst, ":cleartext signed data\n");
 1583|     18|        if (!skip_cleartext()) {
  ------------------
  |  Branch (1583:13): [True: 14, False: 4]
  ------------------
 1584|     14|            RNP_LOG("malformed cleartext signed data");
  ------------------
  |  |   76|     14|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     14|    do {                                                                                 \
  |  |  |  |   69|     14|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 14, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     14|            break;                                                                       \
  |  |  |  |   71|     14|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1585|     14|            return RNP_ERROR_BAD_FORMAT;
 1586|     14|        }
 1587|     18|    }
 1588|       |
 1589|       |    /* check whether source is armored */
 1590|  18.4k|    if (!raw_only && src.is_armored()) {
  ------------------
  |  Branch (1590:9): [True: 7.82k, False: 10.5k]
  |  Branch (1590:22): [True: 911, False: 6.90k]
  ------------------
 1591|    911|        std::unique_ptr<Source> armor(new Source());
 1592|    911|        auto                    ret = init_armored_src(&armor->src(), &src);
 1593|    911|        if (ret) {
  ------------------
  |  Branch (1593:13): [True: 506, False: 405]
  ------------------
 1594|    506|            RNP_LOG("failed to parse armored data");
  ------------------
  |  |   76|    506|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    506|    do {                                                                                 \
  |  |  |  |   69|    506|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 506, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    506|            break;                                                                       \
  |  |  |  |   71|    506|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1595|    506|            return ret;
 1596|    506|        }
 1597|    405|        dst_printf(dst, ":armored input\n");
 1598|       |
 1599|    405|        std::unique_ptr<DumpContextDst> ctx(new DumpContextDst(armor->src(), dst));
 1600|    405|        ctx->copy_params(*this);
 1601|    405|        return ctx->dump(true);
 1602|    911|    }
 1603|       |
 1604|  17.5k|    if (src.eof()) {
  ------------------
  |  Branch (1604:9): [True: 116, False: 17.3k]
  ------------------
 1605|    116|        dst_printf(dst, ":empty input\n");
 1606|    116|        return RNP_SUCCESS;
 1607|    116|    }
 1608|       |
 1609|  17.3k|    return dump_raw_packets();
 1610|  17.5k|}
_ZN3rnp15DumpContextJson24dump_signature_subpacketERKN3pgp3pkt6sigsub3RawEP11json_object:
 1719|  25.6k|{
 1720|  25.6k|    switch (subpkt.type()) {
 1721|    518|    case pkt::sigsub::Type::CreationTime: {
  ------------------
  |  Branch (1721:5): [True: 518, False: 25.1k]
  ------------------
 1722|    518|        auto &sub = dynamic_cast<const pkt::sigsub::CreationTime &>(subpkt);
 1723|    518|        return json_add(obj, "creation time", (uint64_t) sub.time());
 1724|      0|    }
 1725|    636|    case pkt::sigsub::Type::ExpirationTime: {
  ------------------
  |  Branch (1725:5): [True: 636, False: 25.0k]
  ------------------
 1726|    636|        auto &sub = dynamic_cast<const pkt::sigsub::ExpirationTime &>(subpkt);
 1727|    636|        return json_add(obj, "expiration time", (uint64_t) sub.time());
 1728|      0|    }
 1729|     86|    case pkt::sigsub::Type::ExportableCert: {
  ------------------
  |  Branch (1729:5): [True: 86, False: 25.5k]
  ------------------
 1730|     86|        auto &sub = dynamic_cast<const pkt::sigsub::ExportableCert &>(subpkt);
 1731|     86|        return json_add(obj, "exportable", sub.exportable());
 1732|      0|    }
 1733|    213|    case pkt::sigsub::Type::Trust: {
  ------------------
  |  Branch (1733:5): [True: 213, False: 25.4k]
  ------------------
 1734|    213|        auto &sub = dynamic_cast<const pkt::sigsub::Trust &>(subpkt);
 1735|    213|        return json_add(obj, "amount", (int) sub.amount()) &&
  ------------------
  |  Branch (1735:16): [True: 213, False: 0]
  ------------------
 1736|    213|               json_add(obj, "level", (int) sub.level());
  ------------------
  |  Branch (1736:16): [True: 213, False: 0]
  ------------------
 1737|      0|    }
 1738|    573|    case pkt::sigsub::Type::RegExp: {
  ------------------
  |  Branch (1738:5): [True: 573, False: 25.0k]
  ------------------
 1739|    573|        auto &sub = dynamic_cast<const pkt::sigsub::RegExp &>(subpkt);
 1740|    573|        return json_add(obj, "regexp", sub.regexp());
 1741|      0|    }
 1742|    110|    case pkt::sigsub::Type::Revocable: {
  ------------------
  |  Branch (1742:5): [True: 110, False: 25.5k]
  ------------------
 1743|    110|        auto &sub = dynamic_cast<const pkt::sigsub::Revocable &>(subpkt);
 1744|    110|        return json_add(obj, "revocable", sub.revocable());
 1745|      0|    }
 1746|  2.22k|    case pkt::sigsub::Type::KeyExpirationTime: {
  ------------------
  |  Branch (1746:5): [True: 2.22k, False: 23.4k]
  ------------------
 1747|  2.22k|        auto &sub = dynamic_cast<const pkt::sigsub::KeyExpirationTime &>(subpkt);
 1748|  2.22k|        return json_add(obj, "key expiration", (uint64_t) sub.time());
 1749|      0|    }
 1750|  1.53k|    case pkt::sigsub::Type::PreferredSymmetric: {
  ------------------
  |  Branch (1750:5): [True: 1.53k, False: 24.1k]
  ------------------
 1751|  1.53k|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredSymmetric &>(subpkt);
 1752|  1.53k|        return subpacket_obj_add_algs(obj, "algorithms", sub.algs(), symm_alg_map);
 1753|      0|    }
 1754|    551|    case pkt::sigsub::Type::PreferredHash: {
  ------------------
  |  Branch (1754:5): [True: 551, False: 25.1k]
  ------------------
 1755|    551|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredHash &>(subpkt);
 1756|    551|        return subpacket_obj_add_algs(obj, "algorithms", sub.algs(), hash_alg_map);
 1757|      0|    }
 1758|    562|    case pkt::sigsub::Type::PreferredCompress: {
  ------------------
  |  Branch (1758:5): [True: 562, False: 25.1k]
  ------------------
 1759|    562|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredCompress &>(subpkt);
 1760|    562|        return subpacket_obj_add_algs(obj, "algorithms", sub.algs(), z_alg_map);
 1761|      0|    }
 1762|    285|    case pkt::sigsub::Type::PreferredAEAD: {
  ------------------
  |  Branch (1762:5): [True: 285, False: 25.3k]
  ------------------
 1763|    285|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredAEAD &>(subpkt);
 1764|    285|        return subpacket_obj_add_algs(obj, "algorithms", sub.algs(), aead_alg_map);
 1765|      0|    }
 1766|  1.01k|    case pkt::sigsub::Type::RevocationKey: {
  ------------------
  |  Branch (1766:5): [True: 1.01k, False: 24.6k]
  ------------------
 1767|  1.01k|        auto &sub = dynamic_cast<const pkt::sigsub::RevocationKey &>(subpkt);
 1768|  1.01k|        return json_add(obj, "class", (int) sub.rev_class()) &&
  ------------------
  |  Branch (1768:16): [True: 1.01k, False: 0]
  ------------------
 1769|  1.01k|               json_add(obj, "algorithm", (int) sub.alg()) &&
  ------------------
  |  Branch (1769:16): [True: 1.01k, False: 0]
  ------------------
 1770|  1.01k|               json_add(obj, "fingerprint", sub.fp());
  ------------------
  |  Branch (1770:16): [True: 1.01k, False: 0]
  ------------------
 1771|      0|    }
 1772|    589|    case pkt::sigsub::Type::IssuerKeyID: {
  ------------------
  |  Branch (1772:5): [True: 589, False: 25.0k]
  ------------------
 1773|    589|        auto &sub = dynamic_cast<const pkt::sigsub::IssuerKeyID &>(subpkt);
 1774|    589|        return json_add(obj, "issuer keyid", sub.keyid());
 1775|      0|    }
 1776|    215|    case pkt::sigsub::Type::KeyserverPrefs: {
  ------------------
  |  Branch (1776:5): [True: 215, False: 25.4k]
  ------------------
 1777|    215|        auto &sub = dynamic_cast<const pkt::sigsub::KeyserverPrefs &>(subpkt);
 1778|    215|        return json_add(obj, "no-modify", sub.no_modify());
 1779|      0|    }
 1780|    510|    case pkt::sigsub::Type::PreferredKeyserver: {
  ------------------
  |  Branch (1780:5): [True: 510, False: 25.1k]
  ------------------
 1781|    510|        auto &sub = dynamic_cast<const pkt::sigsub::PreferredKeyserver &>(subpkt);
 1782|    510|        return json_add(obj, "uri", sub.keyserver());
 1783|      0|    }
 1784|    255|    case pkt::sigsub::Type::PrimaryUserID: {
  ------------------
  |  Branch (1784:5): [True: 255, False: 25.4k]
  ------------------
 1785|    255|        auto &sub = dynamic_cast<const pkt::sigsub::PrimaryUserID &>(subpkt);
 1786|    255|        return json_add(obj, "primary", sub.primary());
 1787|      0|    }
 1788|    471|    case pkt::sigsub::Type::PolicyURI: {
  ------------------
  |  Branch (1788:5): [True: 471, False: 25.1k]
  ------------------
 1789|    471|        auto &sub = dynamic_cast<const pkt::sigsub::PolicyURI &>(subpkt);
 1790|    471|        return json_add(obj, "uri", sub.URI());
 1791|      0|    }
 1792|  1.43k|    case pkt::sigsub::Type::KeyFlags: {
  ------------------
  |  Branch (1792:5): [True: 1.43k, False: 24.2k]
  ------------------
 1793|  1.43k|        auto &  sub = dynamic_cast<const pkt::sigsub::KeyFlags &>(subpkt);
 1794|  1.43k|        uint8_t flg = sub.flags();
 1795|  1.43k|        if (!json_add(obj, "flags", (int) flg)) {
  ------------------
  |  Branch (1795:13): [True: 0, False: 1.43k]
  ------------------
 1796|      0|            return false; // LCOV_EXCL_LINE
 1797|      0|        }
 1798|  1.43k|        json_object *jso_flg = json_object_new_array();
 1799|  1.43k|        if (!jso_flg || !json_add(obj, "flags.str", jso_flg)) {
  ------------------
  |  Branch (1799:13): [True: 0, False: 1.43k]
  |  Branch (1799:25): [True: 0, False: 1.43k]
  ------------------
 1800|      0|            return false; // LCOV_EXCL_LINE
 1801|      0|        }
 1802|  1.43k|        if ((flg & PGP_KF_CERTIFY) && !json_array_add(jso_flg, "certify")) {
  ------------------
  |  Branch (1802:13): [True: 686, False: 750]
  |  Branch (1802:39): [True: 0, False: 686]
  ------------------
 1803|      0|            return false; // LCOV_EXCL_LINE
 1804|      0|        }
 1805|  1.43k|        if ((flg & PGP_KF_SIGN) && !json_array_add(jso_flg, "sign")) {
  ------------------
  |  Branch (1805:13): [True: 687, False: 749]
  |  Branch (1805:36): [True: 0, False: 687]
  ------------------
 1806|      0|            return false; // LCOV_EXCL_LINE
 1807|      0|        }
 1808|  1.43k|        if ((flg & PGP_KF_ENCRYPT_COMMS) && !json_array_add(jso_flg, "encrypt_comm")) {
  ------------------
  |  Branch (1808:13): [True: 416, False: 1.02k]
  |  Branch (1808:45): [True: 0, False: 416]
  ------------------
 1809|      0|            return false; // LCOV_EXCL_LINE
 1810|      0|        }
 1811|  1.43k|        if ((flg & PGP_KF_ENCRYPT_STORAGE) && !json_array_add(jso_flg, "encrypt_storage")) {
  ------------------
  |  Branch (1811:13): [True: 521, False: 915]
  |  Branch (1811:47): [True: 0, False: 521]
  ------------------
 1812|      0|            return false; // LCOV_EXCL_LINE
 1813|      0|        }
 1814|  1.43k|        if ((flg & PGP_KF_SPLIT) && !json_array_add(jso_flg, "split")) {
  ------------------
  |  Branch (1814:13): [True: 456, False: 980]
  |  Branch (1814:37): [True: 0, False: 456]
  ------------------
 1815|      0|            return false; // LCOV_EXCL_LINE
 1816|      0|        }
 1817|  1.43k|        if ((flg & PGP_KF_AUTH) && !json_array_add(jso_flg, "auth")) {
  ------------------
  |  Branch (1817:13): [True: 456, False: 980]
  |  Branch (1817:36): [True: 0, False: 456]
  ------------------
 1818|      0|            return false; // LCOV_EXCL_LINE
 1819|      0|        }
 1820|  1.43k|        if ((flg & PGP_KF_SHARED) && !json_array_add(jso_flg, "shared")) {
  ------------------
  |  Branch (1820:13): [True: 216, False: 1.22k]
  |  Branch (1820:38): [True: 0, False: 216]
  ------------------
 1821|      0|            return false; // LCOV_EXCL_LINE
 1822|      0|        }
 1823|  1.43k|        return true;
 1824|  1.43k|    }
 1825|  2.51k|    case pkt::sigsub::Type::SignersUserID: {
  ------------------
  |  Branch (1825:5): [True: 2.51k, False: 23.1k]
  ------------------
 1826|  2.51k|        auto &sub = dynamic_cast<const pkt::sigsub::SignersUserID &>(subpkt);
 1827|  2.51k|        return json_add(obj, "uid", sub.signer());
 1828|  1.43k|    }
 1829|    641|    case pkt::sigsub::Type::RevocationReason: {
  ------------------
  |  Branch (1829:5): [True: 641, False: 25.0k]
  ------------------
 1830|    641|        auto &sub = dynamic_cast<const pkt::sigsub::RevocationReason &>(subpkt);
 1831|    641|        if (!obj_add_intstr_json(obj, "code", sub.code(), revoc_reason_map)) {
  ------------------
  |  Branch (1831:13): [True: 0, False: 641]
  ------------------
 1832|      0|            return false;
 1833|      0|        }
 1834|    641|        return json_add(obj, "message", sub.reason());
 1835|    641|    }
 1836|    983|    case pkt::sigsub::Type::Features: {
  ------------------
  |  Branch (1836:5): [True: 983, False: 24.6k]
  ------------------
 1837|    983|        auto &sub = dynamic_cast<const pkt::sigsub::Features &>(subpkt);
 1838|    983|        return json_add(obj, "mdc", (bool) (sub.features() & PGP_KEY_FEATURE_MDC)) &&
  ------------------
  |  Branch (1838:16): [True: 983, False: 0]
  ------------------
 1839|    983|               json_add(obj, "aead", (bool) (sub.features() & PGP_KEY_FEATURE_AEAD)) &&
  ------------------
  |  Branch (1839:16): [True: 983, False: 0]
  ------------------
 1840|    983|               json_add(obj, "v5 keys", (bool) (sub.features() & PGP_KEY_FEATURE_V5));
  ------------------
  |  Branch (1840:16): [True: 983, False: 0]
  ------------------
 1841|    641|    }
 1842|    564|    case pkt::sigsub::Type::EmbeddedSignature: {
  ------------------
  |  Branch (1842:5): [True: 564, False: 25.1k]
  ------------------
 1843|    564|        auto &       sub = dynamic_cast<const pkt::sigsub::EmbeddedSignature &>(subpkt);
 1844|    564|        json_object *sig = json_object_new_object();
 1845|    564|        if (!sub.signature() || !sig || !json_add(obj, "signature", sig)) {
  ------------------
  |  Branch (1845:13): [True: 0, False: 564]
  |  Branch (1845:33): [True: 0, False: 564]
  |  Branch (1845:41): [True: 0, False: 564]
  ------------------
 1846|      0|            return false; // LCOV_EXCL_LINE
 1847|      0|        }
 1848|    564|        return !dump_signature_pkt(*sub.signature(), sig);
 1849|    564|    }
 1850|  1.15k|    case pkt::sigsub::Type::IssuerFingerprint: {
  ------------------
  |  Branch (1850:5): [True: 1.15k, False: 24.5k]
  ------------------
 1851|  1.15k|        auto &sub = dynamic_cast<const pkt::sigsub::IssuerFingerprint &>(subpkt);
 1852|  1.15k|        return json_add(obj, "fingerprint", sub.fp());
 1853|    564|    }
 1854|    957|    case pkt::sigsub::Type::NotationData: {
  ------------------
  |  Branch (1854:5): [True: 957, False: 24.7k]
  ------------------
 1855|    957|        auto &sub = dynamic_cast<const pkt::sigsub::NotationData &>(subpkt);
 1856|    957|        if (!json_add(obj, "human", sub.human_readable()) ||
  ------------------
  |  Branch (1856:13): [True: 0, False: 957]
  ------------------
 1857|    957|            !json_add(obj, "name", sub.name())) {
  ------------------
  |  Branch (1857:13): [True: 0, False: 957]
  ------------------
 1858|      0|            return false; // LCOV_EXCL_LINE
 1859|      0|        }
 1860|    957|        if (sub.human_readable()) {
  ------------------
  |  Branch (1860:13): [True: 329, False: 628]
  ------------------
 1861|    329|            return json_add(obj, "value", (char *) sub.value().data(), sub.value().size());
 1862|    329|        }
 1863|    628|        return json_add_hex(obj, "value", sub.value());
 1864|    957|    }
 1865|  7.08k|    default:
  ------------------
  |  Branch (1865:5): [True: 7.08k, False: 18.5k]
  ------------------
 1866|  7.08k|        if (!dump_packets) {
  ------------------
  |  Branch (1866:13): [True: 0, False: 7.08k]
  ------------------
 1867|      0|            return json_add_hex(obj, "raw", subpkt.data());
 1868|      0|        }
 1869|  7.08k|        return true;
 1870|  25.6k|    }
 1871|      0|    return true;
 1872|  25.6k|}
_ZN3rnp15DumpContextJson25dump_signature_subpacketsERKN3pgp3pkt9SignatureE:
 1876|  8.87k|{
 1877|  8.87k|    json_object *res = json_object_new_array();
 1878|  8.87k|    if (!res) {
  ------------------
  |  Branch (1878:9): [True: 0, False: 8.87k]
  ------------------
 1879|      0|        return NULL; // LCOV_EXCL_LINE
 1880|      0|    }
 1881|  8.87k|    JSONObject reswrap(res);
 1882|       |
 1883|  25.6k|    for (auto &subpkt : sig.subpkts) {
  ------------------
  |  Branch (1883:23): [True: 25.6k, False: 8.87k]
  ------------------
 1884|  25.6k|        json_object *jso_subpkt = json_object_new_object();
 1885|  25.6k|        if (json_object_array_add(res, jso_subpkt)) {
  ------------------
  |  Branch (1885:13): [True: 0, False: 25.6k]
  ------------------
 1886|      0|            json_object_put(jso_subpkt);
 1887|      0|            return NULL; // LCOV_EXCL_LINE
 1888|      0|        }
 1889|       |
 1890|  25.6k|        if (!obj_add_intstr_json(
  ------------------
  |  Branch (1890:13): [True: 0, False: 25.6k]
  ------------------
 1891|  25.6k|              jso_subpkt, "type", subpkt->raw_type(), sig_subpkt_type_map)) {
 1892|      0|            return NULL; // LCOV_EXCL_LINE
 1893|      0|        }
 1894|  25.6k|        if (!json_add(jso_subpkt, "length", (int) subpkt->data().size())) {
  ------------------
  |  Branch (1894:13): [True: 0, False: 25.6k]
  ------------------
 1895|      0|            return NULL; // LCOV_EXCL_LINE
 1896|      0|        }
 1897|  25.6k|        if (!json_add(jso_subpkt, "hashed", subpkt->hashed())) {
  ------------------
  |  Branch (1897:13): [True: 0, False: 25.6k]
  ------------------
 1898|      0|            return NULL; // LCOV_EXCL_LINE
 1899|      0|        }
 1900|  25.6k|        if (!json_add(jso_subpkt, "critical", subpkt->critical())) {
  ------------------
  |  Branch (1900:13): [True: 0, False: 25.6k]
  ------------------
 1901|      0|            return NULL; // LCOV_EXCL_LINE
 1902|      0|        }
 1903|  25.6k|        if (dump_packets && !json_add_hex(jso_subpkt, "raw", subpkt->data())) {
  ------------------
  |  Branch (1903:13): [True: 25.6k, False: 0]
  |  Branch (1903:29): [True: 0, False: 25.6k]
  ------------------
 1904|      0|            return NULL; // LCOV_EXCL_LINE
 1905|      0|        }
 1906|  25.6k|        if (!dump_signature_subpacket(*subpkt, jso_subpkt)) {
  ------------------
  |  Branch (1906:13): [True: 0, False: 25.6k]
  ------------------
 1907|      0|            return NULL;
 1908|      0|        }
 1909|  25.6k|    }
 1910|  8.87k|    return reswrap.release();
 1911|  8.87k|}
_ZN3rnp15DumpContextJson18dump_signature_pktERKN3pgp3pkt9SignatureEP11json_object:
 1915|  9.41k|{
 1916|  9.41k|    json_object *material = NULL;
 1917|       |
 1918|  9.41k|    if (!json_add(pkt, "version", (int) sig.version)) {
  ------------------
  |  Branch (1918:9): [True: 0, False: 9.41k]
  ------------------
 1919|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1920|      0|    }
 1921|  9.41k|    if (!obj_add_intstr_json(pkt, "type", sig.type(), sig_type_map)) {
  ------------------
  |  Branch (1921:9): [True: 0, False: 9.41k]
  ------------------
 1922|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1923|      0|    }
 1924|       |
 1925|  9.41k|    if (sig.version < PGP_V4) {
  ------------------
  |  Branch (1925:9): [True: 543, False: 8.87k]
  ------------------
 1926|    543|        if (!json_add(pkt, "creation time", (uint64_t) sig.creation_time)) {
  ------------------
  |  Branch (1926:13): [True: 0, False: 543]
  ------------------
 1927|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1928|      0|        }
 1929|    543|        if (!json_add(pkt, "signer", sig.signer)) {
  ------------------
  |  Branch (1929:13): [True: 0, False: 543]
  ------------------
 1930|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1931|      0|        }
 1932|    543|    }
 1933|  9.41k|    if (!obj_add_intstr_json(pkt, "algorithm", sig.palg, pubkey_alg_map)) {
  ------------------
  |  Branch (1933:9): [True: 0, False: 9.41k]
  ------------------
 1934|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1935|      0|    }
 1936|  9.41k|    if (!obj_add_intstr_json(pkt, "hash algorithm", sig.halg, hash_alg_map)) {
  ------------------
  |  Branch (1936:9): [True: 0, False: 9.41k]
  ------------------
 1937|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1938|      0|    }
 1939|       |
 1940|  9.41k|    if (sig.version >= PGP_V4) {
  ------------------
  |  Branch (1940:9): [True: 8.87k, False: 543]
  ------------------
 1941|  8.87k|        json_object *subpkts = dump_signature_subpackets(sig);
 1942|  8.87k|        if (!subpkts || !json_add(pkt, "subpackets", subpkts)) {
  ------------------
  |  Branch (1942:13): [True: 0, False: 8.87k]
  |  Branch (1942:25): [True: 0, False: 8.87k]
  ------------------
 1943|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1944|      0|        }
 1945|  8.87k|    }
 1946|       |
 1947|  9.41k|    if (!json_add_hex(pkt, "lbits", sig.lbits.data(), sig.lbits.size())) {
  ------------------
  |  Branch (1947:9): [True: 0, False: 9.41k]
  ------------------
 1948|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1949|      0|    }
 1950|       |
 1951|  9.41k|    material = json_object_new_object();
 1952|  9.41k|    if (!material || !json_add(pkt, "material", material)) {
  ------------------
  |  Branch (1952:9): [True: 0, False: 9.41k]
  |  Branch (1952:22): [True: 0, False: 9.41k]
  ------------------
 1953|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1954|      0|    }
 1955|       |
 1956|  9.41k|    auto sigmaterial = sig.parse_material();
 1957|  9.41k|    if (!sigmaterial) {
  ------------------
  |  Branch (1957:9): [True: 0, False: 9.41k]
  ------------------
 1958|      0|        return RNP_ERROR_BAD_PARAMETERS;
 1959|      0|    }
 1960|  9.41k|    switch (sig.palg) {
 1961|  3.73k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (1961:5): [True: 3.73k, False: 5.68k]
  ------------------
 1962|  3.73k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (1962:5): [True: 0, False: 9.41k]
  ------------------
 1963|  6.76k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (1963:5): [True: 3.03k, False: 6.38k]
  ------------------
 1964|  6.76k|        auto &rsa = dynamic_cast<const RSASigMaterial &>(*sigmaterial);
 1965|  6.76k|        if (!obj_add_mpi_json(material, "s", rsa.sig.s, dump_mpi)) {
  ------------------
  |  Branch (1965:13): [True: 0, False: 6.76k]
  ------------------
 1966|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1967|      0|        }
 1968|  6.76k|        break;
 1969|  6.76k|    }
 1970|  6.76k|    case PGP_PKA_DSA: {
  ------------------
  |  Branch (1970:5): [True: 347, False: 9.07k]
  ------------------
 1971|    347|        auto &dsa = dynamic_cast<const DSASigMaterial &>(*sigmaterial);
 1972|    347|        if (!obj_add_mpi_json(material, "r", dsa.sig.r, dump_mpi) ||
  ------------------
  |  Branch (1972:13): [True: 0, False: 347]
  ------------------
 1973|    347|            !obj_add_mpi_json(material, "s", dsa.sig.s, dump_mpi)) {
  ------------------
  |  Branch (1973:13): [True: 0, False: 347]
  ------------------
 1974|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1975|      0|        }
 1976|    347|        break;
 1977|    347|    }
 1978|    507|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (1978:5): [True: 507, False: 8.91k]
  ------------------
 1979|    967|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (1979:5): [True: 460, False: 8.95k]
  ------------------
 1980|  1.16k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (1980:5): [True: 200, False: 9.21k]
  ------------------
 1981|  1.60k|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (1981:5): [True: 434, False: 8.98k]
  ------------------
 1982|  1.60k|        auto &ec = dynamic_cast<const ECSigMaterial &>(*sigmaterial);
 1983|  1.60k|        if (!obj_add_mpi_json(material, "r", ec.sig.r, dump_mpi) ||
  ------------------
  |  Branch (1983:13): [True: 0, False: 1.60k]
  ------------------
 1984|  1.60k|            !obj_add_mpi_json(material, "s", ec.sig.s, dump_mpi)) {
  ------------------
  |  Branch (1984:13): [True: 0, False: 1.60k]
  ------------------
 1985|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1986|      0|        }
 1987|  1.60k|        break;
 1988|  1.60k|    }
 1989|       |    /* Wasn't able to find ElGamal sig artifacts so let's ignore this for coverage */
 1990|       |    /* LCOV_EXCL_START */
 1991|  1.60k|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (1991:5): [True: 282, False: 9.13k]
  ------------------
 1992|    635|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (1992:5): [True: 353, False: 9.06k]
  ------------------
 1993|    635|        auto &eg = dynamic_cast<const EGSigMaterial &>(*sigmaterial);
 1994|    635|        if (!obj_add_mpi_json(material, "r", eg.sig.r, dump_mpi) ||
  ------------------
  |  Branch (1994:13): [True: 0, False: 635]
  ------------------
 1995|    635|            !obj_add_mpi_json(material, "s", eg.sig.s, dump_mpi)) {
  ------------------
  |  Branch (1995:13): [True: 0, False: 635]
  ------------------
 1996|      0|            return RNP_ERROR_OUT_OF_MEMORY;
 1997|      0|        }
 1998|    635|        break;
 1999|    635|    }
 2000|       |    /* LCOV_EXCL_END */
 2001|    635|#if defined(ENABLE_CRYPTO_REFRESH)
 2002|    635|    case PGP_PKA_ED25519:
  ------------------
  |  Branch (2002:5): [True: 66, False: 9.35k]
  ------------------
 2003|       |        /* TODO */
 2004|     66|        break;
 2005|      0|#endif
 2006|      0|#if defined(ENABLE_PQC)
 2007|      0|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (2007:5): [True: 0, False: 9.41k]
  ------------------
 2008|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2009|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
 2010|      0|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (2010:5): [True: 0, False: 9.41k]
  ------------------
 2011|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2012|      0|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (2012:5): [True: 0, False: 9.41k]
  ------------------
 2013|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2014|      0|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (2014:5): [True: 0, False: 9.41k]
  ------------------
 2015|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2016|      0|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (2016:5): [True: 0, False: 9.41k]
  ------------------
 2017|       |        /* TODO */
 2018|      0|        break;
 2019|      0|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (2019:5): [True: 0, False: 9.41k]
  ------------------
 2020|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2021|      0|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (2021:5): [True: 0, False: 9.41k]
  ------------------
 2022|       |        /* TODO */
 2023|      0|        break;
 2024|      0|#endif
 2025|      0|    default:
  ------------------
  |  Branch (2025:5): [True: 0, False: 9.41k]
  ------------------
 2026|      0|        break;
 2027|  9.41k|    }
 2028|  9.41k|    return RNP_SUCCESS;
 2029|  9.41k|}
_ZN3rnp15DumpContextJson14dump_signatureEP11json_object:
 2033|  23.5k|{
 2034|  23.5k|    pkt::Signature sig;
 2035|  23.5k|    auto           ret = sig.parse(src);
 2036|  23.5k|    if (ret) {
  ------------------
  |  Branch (2036:9): [True: 14.6k, False: 8.85k]
  ------------------
 2037|  14.6k|        return ret;
 2038|  14.6k|    }
 2039|  8.85k|    return dump_signature_pkt(sig, pkt);
 2040|  23.5k|}
_ZN3rnp15DumpContextJson17dump_key_materialEPKN3pgp11KeyMaterialEP11json_object:
 2044|  20.0k|{
 2045|  20.0k|    if (!material) {
  ------------------
  |  Branch (2045:9): [True: 0, False: 20.0k]
  ------------------
 2046|      0|        return false; // LCOV_EXCL_LINE
 2047|      0|    }
 2048|  20.0k|    switch (material->alg()) {
 2049|  2.72k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (2049:5): [True: 2.72k, False: 17.3k]
  ------------------
 2050|  6.10k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (2050:5): [True: 3.38k, False: 16.7k]
  ------------------
 2051|  10.1k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (2051:5): [True: 4.03k, False: 16.0k]
  ------------------
 2052|  10.1k|        auto &rsa = dynamic_cast<const RSAKeyMaterial &>(*material);
 2053|  10.1k|        if (!obj_add_mpi_json(jso, "n", rsa.n(), dump_mpi) ||
  ------------------
  |  Branch (2053:13): [True: 0, False: 10.1k]
  ------------------
 2054|  10.1k|            !obj_add_mpi_json(jso, "e", rsa.e(), dump_mpi)) {
  ------------------
  |  Branch (2054:13): [True: 0, False: 10.1k]
  ------------------
 2055|      0|            return false; // LCOV_EXCL_LINE
 2056|      0|        }
 2057|  10.1k|        return true;
 2058|  10.1k|    }
 2059|    355|    case PGP_PKA_DSA: {
  ------------------
  |  Branch (2059:5): [True: 355, False: 19.7k]
  ------------------
 2060|    355|        auto &dsa = dynamic_cast<const DSAKeyMaterial &>(*material);
 2061|    355|        if (!obj_add_mpi_json(jso, "p", dsa.p(), dump_mpi) ||
  ------------------
  |  Branch (2061:13): [True: 0, False: 355]
  ------------------
 2062|    355|            !obj_add_mpi_json(jso, "q", dsa.q(), dump_mpi) ||
  ------------------
  |  Branch (2062:13): [True: 0, False: 355]
  ------------------
 2063|    355|            !obj_add_mpi_json(jso, "g", dsa.g(), dump_mpi) ||
  ------------------
  |  Branch (2063:13): [True: 0, False: 355]
  ------------------
 2064|    355|            !obj_add_mpi_json(jso, "y", dsa.y(), dump_mpi)) {
  ------------------
  |  Branch (2064:13): [True: 0, False: 355]
  ------------------
 2065|      0|            return false; // LCOV_EXCL_LINE
 2066|      0|        }
 2067|    355|        return true;
 2068|    355|    }
 2069|    539|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (2069:5): [True: 539, False: 19.5k]
  ------------------
 2070|    850|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (2070:5): [True: 311, False: 19.7k]
  ------------------
 2071|    850|        auto &eg = dynamic_cast<const EGKeyMaterial &>(*material);
 2072|    850|        if (!obj_add_mpi_json(jso, "p", eg.p(), dump_mpi) ||
  ------------------
  |  Branch (2072:13): [True: 0, False: 850]
  ------------------
 2073|    850|            !obj_add_mpi_json(jso, "g", eg.g(), dump_mpi) ||
  ------------------
  |  Branch (2073:13): [True: 0, False: 850]
  ------------------
 2074|    850|            !obj_add_mpi_json(jso, "y", eg.y(), dump_mpi)) {
  ------------------
  |  Branch (2074:13): [True: 0, False: 850]
  ------------------
 2075|      0|            return false; // LCOV_EXCL_LINE
 2076|      0|        }
 2077|    850|        return true;
 2078|    850|    }
 2079|    477|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (2079:5): [True: 477, False: 19.6k]
  ------------------
 2080|    789|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (2080:5): [True: 312, False: 19.7k]
  ------------------
 2081|  1.20k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (2081:5): [True: 420, False: 19.6k]
  ------------------
 2082|  1.63k|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (2082:5): [True: 422, False: 19.6k]
  ------------------
 2083|  1.63k|        auto &ec = dynamic_cast<const ECKeyMaterial &>(*material);
 2084|  1.63k|        auto  cdesc = ec::Curve::get(ec.curve());
 2085|       |        /* Common EC fields */
 2086|  1.63k|        if (!obj_add_mpi_json(jso, "p", ec.p(), dump_mpi)) {
  ------------------
  |  Branch (2086:13): [True: 0, False: 1.63k]
  ------------------
 2087|      0|            return false; // LCOV_EXCL_LINE
 2088|      0|        }
 2089|  1.63k|        if (!json_add(jso, "curve", cdesc ? cdesc->pgp_name : "unknown")) {
  ------------------
  |  Branch (2089:13): [True: 0, False: 1.63k]
  |  Branch (2089:37): [True: 623, False: 1.00k]
  ------------------
 2090|      0|            return false; // LCOV_EXCL_LINE
 2091|      0|        }
 2092|  1.63k|        if (material->alg() != PGP_PKA_ECDH) {
  ------------------
  |  Branch (2092:13): [True: 1.20k, False: 422]
  ------------------
 2093|  1.20k|            return true;
 2094|  1.20k|        }
 2095|       |        /* ECDH-only fields */
 2096|    422|        auto &ecdh = dynamic_cast<const ECDHKeyMaterial &>(*material);
 2097|    422|        if (!obj_add_intstr_json(jso, "hash algorithm", ecdh.kdf_hash_alg(), hash_alg_map)) {
  ------------------
  |  Branch (2097:13): [True: 0, False: 422]
  ------------------
 2098|      0|            return false; // LCOV_EXCL_LINE
 2099|      0|        }
 2100|    422|        if (!obj_add_intstr_json(
  ------------------
  |  Branch (2100:13): [True: 0, False: 422]
  ------------------
 2101|    422|              jso, "key wrap algorithm", ecdh.key_wrap_alg(), symm_alg_map)) {
 2102|      0|            return false; // LCOV_EXCL_LINE
 2103|      0|        }
 2104|    422|        return true;
 2105|    422|    }
 2106|      0|#if defined(ENABLE_CRYPTO_REFRESH)
 2107|    376|    case PGP_PKA_ED25519:
  ------------------
  |  Branch (2107:5): [True: 376, False: 19.7k]
  ------------------
 2108|    877|    case PGP_PKA_X25519:
  ------------------
  |  Branch (2108:5): [True: 501, False: 19.5k]
  ------------------
 2109|       |        /* TODO */
 2110|    877|        return true;
 2111|      0|#endif
 2112|      0|#if defined(ENABLE_PQC)
 2113|    213|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (2113:5): [True: 213, False: 19.8k]
  ------------------
 2114|    213|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    213|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2115|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
 2116|    402|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (2116:5): [True: 189, False: 19.9k]
  ------------------
 2117|    402|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    402|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2118|  1.09k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (2118:5): [True: 692, False: 19.4k]
  ------------------
 2119|  1.09k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.09k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2120|  1.30k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (2120:5): [True: 211, False: 19.8k]
  ------------------
 2121|  1.30k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.30k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2122|  1.65k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (2122:5): [True: 350, False: 19.7k]
  ------------------
 2123|       |        // TODO
 2124|  1.65k|        return true;
 2125|  2.10k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (2125:5): [True: 2.10k, False: 17.9k]
  ------------------
 2126|  2.10k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.10k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2127|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
 2128|  2.56k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (2128:5): [True: 458, False: 19.6k]
  ------------------
 2129|  2.56k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.56k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2130|  2.83k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (2130:5): [True: 275, False: 19.8k]
  ------------------
 2131|  2.83k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.83k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2132|  3.37k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (2132:5): [True: 539, False: 19.5k]
  ------------------
 2133|  3.37k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.37k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2134|  3.65k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (2134:5): [True: 279, False: 19.8k]
  ------------------
 2135|       |        /* TODO */
 2136|  3.65k|        return true;
 2137|    272|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (2137:5): [True: 272, False: 19.8k]
  ------------------
 2138|    272|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    272|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2139|    935|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (2139:5): [True: 663, False: 19.4k]
  ------------------
 2140|       |        /* TODO */
 2141|    935|        return true;
 2142|      0|#endif
 2143|      0|    default:
  ------------------
  |  Branch (2143:5): [True: 0, False: 20.0k]
  ------------------
 2144|      0|        return false;
 2145|  20.0k|    }
 2146|  20.0k|}
_ZN3rnp15DumpContextJson8dump_keyEP11json_object:
 2150|  33.2k|{
 2151|  33.2k|    pgp_key_pkt_t key;
 2152|  33.2k|    auto          ret = key.parse(src);
 2153|  33.2k|    if (ret) {
  ------------------
  |  Branch (2153:9): [True: 13.1k, False: 20.0k]
  ------------------
 2154|  13.1k|        return ret;
 2155|  13.1k|    }
 2156|       |
 2157|  20.0k|    if (!json_add(pkt, "version", (int) key.version)) {
  ------------------
  |  Branch (2157:9): [True: 0, False: 20.0k]
  ------------------
 2158|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2159|      0|    }
 2160|  20.0k|    if (!json_add(pkt, "creation time", (uint64_t) key.creation_time)) {
  ------------------
  |  Branch (2160:9): [True: 0, False: 20.0k]
  ------------------
 2161|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2162|      0|    }
 2163|  20.0k|    if ((key.version < PGP_V4) && !json_add(pkt, "v3 days", (int) key.v3_days)) {
  ------------------
  |  Branch (2163:9): [True: 1.54k, False: 18.5k]
  |  Branch (2163:35): [True: 0, False: 1.54k]
  ------------------
 2164|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2165|      0|    }
 2166|  20.0k|    if (!obj_add_intstr_json(pkt, "algorithm", key.alg, pubkey_alg_map)) {
  ------------------
  |  Branch (2166:9): [True: 0, False: 20.0k]
  ------------------
 2167|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2168|      0|    }
 2169|  20.0k|    if ((key.version == PGP_V5) &&
  ------------------
  |  Branch (2169:9): [True: 328, False: 19.7k]
  ------------------
 2170|    328|        !json_add(pkt, "v5 public key material length", (int) key.v5_pub_len)) {
  ------------------
  |  Branch (2170:9): [True: 0, False: 328]
  ------------------
 2171|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2172|      0|    }
 2173|       |
 2174|  20.0k|    auto material = json_object_new_object();
 2175|  20.0k|    if (!material || !json_add(pkt, "material", material)) {
  ------------------
  |  Branch (2175:9): [True: 0, False: 20.0k]
  |  Branch (2175:22): [True: 0, False: 20.0k]
  ------------------
 2176|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2177|      0|    }
 2178|  20.0k|    if (!dump_key_material(key.material.get(), material)) {
  ------------------
  |  Branch (2178:9): [True: 0, False: 20.0k]
  ------------------
 2179|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 2180|      0|    }
 2181|       |
 2182|  20.0k|    if (is_secret_key_pkt(key.tag)) {
  ------------------
  |  Branch (2182:9): [True: 13.2k, False: 6.81k]
  ------------------
 2183|  13.2k|        if (!json_add(material, "s2k usage", (int) key.sec_protection.s2k.usage)) {
  ------------------
  |  Branch (2183:13): [True: 0, False: 13.2k]
  ------------------
 2184|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2185|      0|        }
 2186|  13.2k|        if ((key.version == PGP_V5) &&
  ------------------
  |  Branch (2186:13): [True: 328, False: 12.9k]
  ------------------
 2187|    328|            !json_add(material, "v5 s2k length", (int) key.v5_s2k_len)) {
  ------------------
  |  Branch (2187:13): [True: 0, False: 328]
  ------------------
 2188|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2189|      0|        }
 2190|  13.2k|        if (!obj_add_s2k_json(material, &key.sec_protection.s2k)) {
  ------------------
  |  Branch (2190:13): [True: 0, False: 13.2k]
  ------------------
 2191|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2192|      0|        }
 2193|  13.2k|        if (key.sec_protection.s2k.usage &&
  ------------------
  |  Branch (2193:13): [True: 9.20k, False: 4.07k]
  ------------------
 2194|  9.20k|            !obj_add_intstr_json(
  ------------------
  |  Branch (2194:13): [True: 0, False: 9.20k]
  ------------------
 2195|  9.20k|              material, "symmetric algorithm", key.sec_protection.symm_alg, symm_alg_map)) {
 2196|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2197|      0|        }
 2198|  13.2k|        if ((key.version == PGP_V5) &&
  ------------------
  |  Branch (2198:13): [True: 328, False: 12.9k]
  ------------------
 2199|    328|            !json_add(material, "v5 secret key data length", (int) key.v5_sec_len)) {
  ------------------
  |  Branch (2199:13): [True: 0, False: 328]
  ------------------
 2200|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2201|      0|        }
 2202|  13.2k|    }
 2203|       |
 2204|  20.0k|    Fingerprint fp(key);
 2205|  20.0k|    if (!json_add(pkt, "keyid", fp.keyid())) {
  ------------------
  |  Branch (2205:9): [True: 0, False: 20.0k]
  ------------------
 2206|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2207|      0|    }
 2208|       |
 2209|  20.0k|    if (dump_grips && !json_add(pkt, "fingerprint", fp)) {
  ------------------
  |  Branch (2209:9): [True: 0, False: 20.0k]
  |  Branch (2209:23): [True: 0, False: 0]
  ------------------
 2210|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2211|      0|    }
 2212|       |
 2213|  20.0k|    if (dump_grips) {
  ------------------
  |  Branch (2213:9): [True: 0, False: 20.0k]
  ------------------
 2214|      0|        if (key.material) {
  ------------------
  |  Branch (2214:13): [True: 0, False: 0]
  ------------------
 2215|      0|            KeyGrip grip = key.material->grip();
 2216|      0|            if (!json_add_hex(pkt, "grip", grip.data(), grip.size())) {
  ------------------
  |  Branch (2216:17): [True: 0, False: 0]
  ------------------
 2217|      0|                return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2218|      0|            }
 2219|      0|        } else {
 2220|      0|            return RNP_ERROR_BAD_PARAMETERS; // LCOV_EXCL_LINE
 2221|      0|        }
 2222|      0|    }
 2223|  20.0k|    return RNP_SUCCESS;
 2224|  20.0k|}
_ZN3rnp15DumpContextJson12dump_user_idEP11json_object:
 2228|  13.6k|{
 2229|  13.6k|    pgp_userid_pkt_t uid;
 2230|  13.6k|    auto             ret = uid.parse(src);
 2231|  13.6k|    if (ret) {
  ------------------
  |  Branch (2231:9): [True: 502, False: 13.1k]
  ------------------
 2232|    502|        return ret;
 2233|    502|    }
 2234|       |
 2235|  13.1k|    switch (uid.tag) {
 2236|  10.6k|    case PGP_PKT_USER_ID:
  ------------------
  |  Branch (2236:5): [True: 10.6k, False: 2.50k]
  ------------------
 2237|  10.6k|        if (!json_add(pkt, "userid", (char *) uid.uid.data(), uid.uid.size())) {
  ------------------
  |  Branch (2237:13): [True: 0, False: 10.6k]
  ------------------
 2238|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2239|      0|        }
 2240|  10.6k|        break;
 2241|  10.6k|    case PGP_PKT_USER_ATTR:
  ------------------
  |  Branch (2241:5): [True: 2.50k, False: 10.6k]
  ------------------
 2242|  2.50k|        if (!json_add_hex(pkt, "userattr", uid.uid.data(), uid.uid.size())) {
  ------------------
  |  Branch (2242:13): [True: 0, False: 2.50k]
  ------------------
 2243|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2244|      0|        }
 2245|  2.50k|        break;
 2246|  2.50k|    default:;
  ------------------
  |  Branch (2246:5): [True: 0, False: 13.1k]
  ------------------
 2247|  13.1k|    }
 2248|  13.1k|    return RNP_SUCCESS;
 2249|  13.1k|}
_ZN3rnp15DumpContextJson19dump_pk_session_keyEP11json_object:
 2253|  8.41k|{
 2254|  8.41k|    pgp_pk_sesskey_t pkey;
 2255|  8.41k|    auto             ret = pkey.parse(src);
 2256|  8.41k|    if (ret) {
  ------------------
  |  Branch (2256:9): [True: 5.33k, False: 3.08k]
  ------------------
 2257|  5.33k|        return ret;
 2258|  5.33k|    }
 2259|  3.08k|    auto pkmaterial = pkey.parse_material();
 2260|  3.08k|    if (!pkmaterial) {
  ------------------
  |  Branch (2260:9): [True: 0, False: 3.08k]
  ------------------
 2261|      0|        return RNP_ERROR_BAD_FORMAT;
 2262|      0|    }
 2263|       |
 2264|  3.08k|    if (!json_add(pkt, "version", (int) pkey.version) ||
  ------------------
  |  Branch (2264:9): [True: 0, False: 3.08k]
  ------------------
 2265|  3.08k|        !json_add(pkt, "keyid", pkey.key_id) ||
  ------------------
  |  Branch (2265:9): [True: 0, False: 3.08k]
  ------------------
 2266|  3.08k|        !obj_add_intstr_json(pkt, "algorithm", pkey.alg, pubkey_alg_map)) {
  ------------------
  |  Branch (2266:9): [True: 0, False: 3.08k]
  ------------------
 2267|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2268|      0|    }
 2269|       |
 2270|  3.08k|    json_object *material = json_object_new_object();
 2271|  3.08k|    if (!json_add(pkt, "material", material)) {
  ------------------
  |  Branch (2271:9): [True: 0, False: 3.08k]
  ------------------
 2272|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2273|      0|    }
 2274|       |
 2275|  3.08k|    switch (pkey.alg) {
 2276|  1.39k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (2276:5): [True: 1.39k, False: 1.68k]
  ------------------
 2277|  1.67k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (2277:5): [True: 277, False: 2.80k]
  ------------------
 2278|  1.67k|    case PGP_PKA_RSA_SIGN_ONLY: {
  ------------------
  |  Branch (2278:5): [True: 0, False: 3.08k]
  ------------------
 2279|  1.67k|        auto &rsa = dynamic_cast<const RSAEncMaterial &>(*pkmaterial).enc;
 2280|  1.67k|        if (!obj_add_mpi_json(material, "m", rsa.m, dump_mpi)) {
  ------------------
  |  Branch (2280:13): [True: 0, False: 1.67k]
  ------------------
 2281|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2282|      0|        }
 2283|  1.67k|        break;
 2284|  1.67k|    }
 2285|  1.67k|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (2285:5): [True: 216, False: 2.86k]
  ------------------
 2286|    421|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN: {
  ------------------
  |  Branch (2286:5): [True: 205, False: 2.87k]
  ------------------
 2287|    421|        auto &eg = dynamic_cast<const EGEncMaterial &>(*pkmaterial).enc;
 2288|    421|        if (!obj_add_mpi_json(material, "g", eg.g, dump_mpi) ||
  ------------------
  |  Branch (2288:13): [True: 0, False: 421]
  ------------------
 2289|    421|            !obj_add_mpi_json(material, "m", eg.m, dump_mpi)) {
  ------------------
  |  Branch (2289:13): [True: 0, False: 421]
  ------------------
 2290|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2291|      0|        }
 2292|    421|        break;
 2293|    421|    }
 2294|    421|    case PGP_PKA_SM2: {
  ------------------
  |  Branch (2294:5): [True: 216, False: 2.86k]
  ------------------
 2295|    216|        auto &sm2 = dynamic_cast<const SM2EncMaterial &>(*pkmaterial).enc;
 2296|    216|        if (!obj_add_mpi_json(material, "m", sm2.m, dump_mpi)) {
  ------------------
  |  Branch (2296:13): [True: 0, False: 216]
  ------------------
 2297|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2298|      0|        }
 2299|    216|        break;
 2300|    216|    }
 2301|    325|    case PGP_PKA_ECDH: {
  ------------------
  |  Branch (2301:5): [True: 325, False: 2.75k]
  ------------------
 2302|    325|        auto &ecdh = dynamic_cast<const ECDHEncMaterial &>(*pkmaterial).enc;
 2303|    325|        if (!obj_add_mpi_json(material, "p", ecdh.p, dump_mpi) ||
  ------------------
  |  Branch (2303:13): [True: 0, False: 325]
  ------------------
 2304|    325|            !json_add(material, "m.bytes", (int) ecdh.m.size())) {
  ------------------
  |  Branch (2304:13): [True: 0, False: 325]
  ------------------
 2305|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2306|      0|        }
 2307|    325|        if (dump_mpi && !json_add_hex(material, "m", ecdh.m.data(), ecdh.m.size())) {
  ------------------
  |  Branch (2307:13): [True: 0, False: 325]
  |  Branch (2307:25): [True: 0, False: 0]
  ------------------
 2308|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2309|      0|        }
 2310|    325|        break;
 2311|    325|    }
 2312|    325|#if defined(ENABLE_CRYPTO_REFRESH)
 2313|    325|    case PGP_PKA_ED25519:
  ------------------
  |  Branch (2313:5): [True: 0, False: 3.08k]
  ------------------
 2314|    324|    case PGP_PKA_X25519:
  ------------------
  |  Branch (2314:5): [True: 324, False: 2.75k]
  ------------------
 2315|       |        /* TODO */
 2316|    324|        break;
 2317|      0|#endif
 2318|      0|#if defined(ENABLE_PQC)
 2319|     17|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (2319:5): [True: 17, False: 3.06k]
  ------------------
 2320|     17|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     17|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2321|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
 2322|     28|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (2322:5): [True: 11, False: 3.07k]
  ------------------
 2323|     28|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     28|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2324|     59|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (2324:5): [True: 31, False: 3.05k]
  ------------------
 2325|     59|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|     59|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2326|    101|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (2326:5): [True: 42, False: 3.03k]
  ------------------
 2327|    101|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    101|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
 2328|    119|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (2328:5): [True: 18, False: 3.06k]
  ------------------
 2329|       |        // TODO
 2330|    119|        break;
 2331|      0|#endif
 2332|      0|    default:;
  ------------------
  |  Branch (2332:5): [True: 0, False: 3.08k]
  ------------------
 2333|  3.08k|    }
 2334|       |
 2335|  3.08k|    return RNP_SUCCESS;
 2336|  3.08k|}
_ZN3rnp15DumpContextJson19dump_sk_session_keyEP11json_object:
 2340|  7.28k|{
 2341|  7.28k|    pgp_sk_sesskey_t skey;
 2342|  7.28k|    auto             ret = skey.parse(src);
 2343|  7.28k|    if (ret) {
  ------------------
  |  Branch (2343:9): [True: 3.69k, False: 3.59k]
  ------------------
 2344|  3.69k|        return ret;
 2345|  3.69k|    }
 2346|       |
 2347|  3.59k|    if (!json_add(pkt, "version", (int) skey.version) ||
  ------------------
  |  Branch (2347:9): [True: 0, False: 3.59k]
  ------------------
 2348|  3.59k|        !obj_add_intstr_json(pkt, "algorithm", skey.alg, symm_alg_map)) {
  ------------------
  |  Branch (2348:9): [True: 0, False: 3.59k]
  ------------------
 2349|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2350|      0|    }
 2351|  3.59k|    if ((skey.version == PGP_SKSK_V5) &&
  ------------------
  |  Branch (2351:9): [True: 481, False: 3.11k]
  ------------------
 2352|    481|        !obj_add_intstr_json(pkt, "aead algorithm", skey.aalg, aead_alg_map)) {
  ------------------
  |  Branch (2352:9): [True: 0, False: 481]
  ------------------
 2353|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2354|      0|    }
 2355|  3.59k|    if (!obj_add_s2k_json(pkt, &skey.s2k)) {
  ------------------
  |  Branch (2355:9): [True: 0, False: 3.59k]
  ------------------
 2356|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2357|      0|    }
 2358|  3.59k|    if ((skey.version == PGP_SKSK_V5) && !json_add_hex(pkt, "aead iv", skey.iv, skey.ivlen)) {
  ------------------
  |  Branch (2358:9): [True: 481, False: 3.11k]
  |  Branch (2358:42): [True: 0, False: 481]
  ------------------
 2359|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2360|      0|    }
 2361|  3.59k|    if (!json_add_hex(pkt, "encrypted key", skey.enckey, skey.enckeylen)) {
  ------------------
  |  Branch (2361:9): [True: 0, False: 3.59k]
  ------------------
 2362|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2363|      0|    }
 2364|  3.59k|    return RNP_SUCCESS;
 2365|  3.59k|}
_ZN3rnp15DumpContextJson14dump_encryptedEP11json_object14pgp_pkt_type_t:
 2369|    833|{
 2370|    833|    if (tag != PGP_PKT_AEAD_ENCRYPTED) {
  ------------------
  |  Branch (2370:9): [True: 204, False: 629]
  ------------------
 2371|       |        /* packet header with tag is already in pkt */
 2372|    204|        return stream_skip_packet(&src);
 2373|    204|    }
 2374|       |
 2375|       |    /* dumping AEAD data */
 2376|    629|    pgp_aead_hdr_t aead{};
 2377|    629|    if (!get_aead_hdr(aead)) {
  ------------------
  |  Branch (2377:9): [True: 556, False: 73]
  ------------------
 2378|    556|        return RNP_ERROR_READ;
 2379|    556|    }
 2380|       |
 2381|     73|    if (!json_add(pkt, "version", (int) aead.version) ||
  ------------------
  |  Branch (2381:9): [True: 0, False: 73]
  ------------------
 2382|     73|        !obj_add_intstr_json(pkt, "algorithm", aead.ealg, symm_alg_map) ||
  ------------------
  |  Branch (2382:9): [True: 0, False: 73]
  ------------------
 2383|     73|        !obj_add_intstr_json(pkt, "aead algorithm", aead.aalg, aead_alg_map) ||
  ------------------
  |  Branch (2383:9): [True: 0, False: 73]
  ------------------
 2384|     73|        !json_add(pkt, "chunk size", (int) aead.csize) ||
  ------------------
  |  Branch (2384:9): [True: 0, False: 73]
  ------------------
 2385|     73|        !json_add_hex(pkt, "aead iv", aead.iv, aead.ivlen)) {
  ------------------
  |  Branch (2385:9): [True: 0, False: 73]
  ------------------
 2386|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2387|      0|    }
 2388|     73|    return RNP_SUCCESS;
 2389|     73|}
_ZN3rnp15DumpContextJson13dump_one_passEP11json_object:
 2393|  1.25k|{
 2394|  1.25k|    pgp_one_pass_sig_t onepass;
 2395|  1.25k|    auto               ret = onepass.parse(src);
 2396|  1.25k|    if (ret) {
  ------------------
  |  Branch (2396:9): [True: 864, False: 391]
  ------------------
 2397|    864|        return ret;
 2398|    864|    }
 2399|       |
 2400|    391|    if (!json_add(pkt, "version", (int) onepass.version)) {
  ------------------
  |  Branch (2400:9): [True: 0, False: 391]
  ------------------
 2401|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2402|      0|    }
 2403|    391|    if (!obj_add_intstr_json(pkt, "type", onepass.type, sig_type_map)) {
  ------------------
  |  Branch (2403:9): [True: 0, False: 391]
  ------------------
 2404|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2405|      0|    }
 2406|    391|    if (!obj_add_intstr_json(pkt, "hash algorithm", onepass.halg, hash_alg_map)) {
  ------------------
  |  Branch (2406:9): [True: 0, False: 391]
  ------------------
 2407|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2408|      0|    }
 2409|    391|    if (!obj_add_intstr_json(pkt, "public key algorithm", onepass.palg, pubkey_alg_map)) {
  ------------------
  |  Branch (2409:9): [True: 0, False: 391]
  ------------------
 2410|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2411|      0|    }
 2412|    391|    if (!json_add(pkt, "signer", onepass.keyid)) {
  ------------------
  |  Branch (2412:9): [True: 0, False: 391]
  ------------------
 2413|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2414|      0|    }
 2415|    391|    if (!json_add(pkt, "nested", (bool) onepass.nested)) {
  ------------------
  |  Branch (2415:9): [True: 0, False: 391]
  ------------------
 2416|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2417|      0|    }
 2418|    391|    return RNP_SUCCESS;
 2419|    391|}
_ZN3rnp15DumpContextJson11dump_markerEP11json_object:
 2423|  1.62k|{
 2424|  1.62k|    auto ret = stream_parse_marker(src);
 2425|  1.62k|    if (!json_add(pkt, "contents", ret ? "invalid" : PGP_MARKER_CONTENTS)) {
  ------------------
  |  |  103|    158|#define PGP_MARKER_CONTENTS "PGP"
  ------------------
  |  Branch (2425:9): [True: 0, False: 1.62k]
  |  Branch (2425:36): [True: 1.46k, False: 158]
  ------------------
 2426|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2427|      0|    }
 2428|  1.62k|    return ret;
 2429|  1.62k|}
_ZN3rnp15DumpContextJson15dump_compressedEP11json_object:
 2433|  10.3k|{
 2434|  10.3k|    std::unique_ptr<Source> zsrc(new Source());
 2435|  10.3k|    auto                    ret = init_compressed_src(&zsrc->src(), &src);
 2436|  10.3k|    if (ret) {
  ------------------
  |  Branch (2436:9): [True: 551, False: 9.84k]
  ------------------
 2437|    551|        return ret;
 2438|    551|    }
 2439|       |
 2440|  9.84k|    uint8_t zalg;
 2441|  9.84k|    get_compressed_src_alg(&zsrc->src(), &zalg);
 2442|  9.84k|    if (!obj_add_intstr_json(pkt, "algorithm", zalg, z_alg_map)) {
  ------------------
  |  Branch (2442:9): [True: 0, False: 9.84k]
  ------------------
 2443|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2444|      0|    }
 2445|       |
 2446|  9.84k|    json_object *   contents = NULL;
 2447|  9.84k|    DumpContextJson ctx(zsrc->src(), &contents);
 2448|  9.84k|    ctx.copy_params(*this);
 2449|  9.84k|    ret = ctx.dump(true);
 2450|  9.84k|    copy_params(ctx);
 2451|  9.84k|    if (!ret && !json_add(pkt, "contents", contents)) {
  ------------------
  |  Branch (2451:9): [True: 5.01k, False: 4.82k]
  |  Branch (2451:17): [True: 0, False: 5.01k]
  ------------------
 2452|      0|        json_object_put(contents);
 2453|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2454|      0|    }
 2455|  9.84k|    return ret;
 2456|  9.84k|}
_ZN3rnp15DumpContextJson12dump_literalEP11json_object:
 2460|    782|{
 2461|    782|    Source lsrc;
 2462|    782|    auto   ret = init_literal_src(&lsrc.src(), &src);
 2463|    782|    if (ret) {
  ------------------
  |  Branch (2463:9): [True: 469, False: 313]
  ------------------
 2464|    469|        return ret;
 2465|    469|    }
 2466|       |
 2467|    313|    ret = RNP_ERROR_OUT_OF_MEMORY;
 2468|    313|    auto &lhdr = get_literal_src_hdr(lsrc.src());
 2469|    313|    if (!json_add(pkt, "format", (char *) &lhdr.format, 1) ||
  ------------------
  |  Branch (2469:9): [True: 0, False: 313]
  ------------------
 2470|    313|        !json_add(pkt, "filename", (char *) lhdr.fname, lhdr.fname_len) ||
  ------------------
  |  Branch (2470:9): [True: 0, False: 313]
  ------------------
 2471|    313|        !json_add(pkt, "timestamp", (uint64_t) lhdr.timestamp)) {
  ------------------
  |  Branch (2471:9): [True: 0, False: 313]
  ------------------
 2472|      0|        return ret; // LCOV_EXCL_LINE
 2473|      0|    }
 2474|       |
 2475|   220k|    while (!lsrc.eof()) {
  ------------------
  |  Branch (2475:12): [True: 219k, False: 282]
  ------------------
 2476|   219k|        uint8_t readbuf[16384];
 2477|   219k|        size_t  read = 0;
 2478|   219k|        if (!lsrc.src().read(readbuf, sizeof(readbuf), &read)) {
  ------------------
  |  Branch (2478:13): [True: 31, False: 219k]
  ------------------
 2479|     31|            return RNP_ERROR_READ;
 2480|     31|        }
 2481|   219k|    }
 2482|       |
 2483|    282|    if (!json_add(pkt, "datalen", (uint64_t) lsrc.readb())) {
  ------------------
  |  Branch (2483:9): [True: 0, False: 282]
  ------------------
 2484|      0|        return ret; // LCOV_EXCL_LINE
 2485|      0|    }
 2486|    282|    return RNP_SUCCESS;
 2487|    282|}
_ZN3rnp15DumpContextJson12dump_pkt_hdrER16pgp_packet_hdr_tP11json_object:
 2491|   172k|{
 2492|   172k|    auto hdrret = stream_peek_packet_hdr(&src, &hdr);
 2493|   172k|    if (hdrret) {
  ------------------
  |  Branch (2493:9): [True: 3.03k, False: 168k]
  ------------------
 2494|  3.03k|        return false;
 2495|  3.03k|    }
 2496|       |
 2497|   168k|    json_object *jso_hdr = json_object_new_object();
 2498|   168k|    if (!jso_hdr) {
  ------------------
  |  Branch (2498:9): [True: 0, False: 168k]
  ------------------
 2499|      0|        return false;
 2500|      0|    }
 2501|   168k|    rnp::JSONObject jso_hdrwrap(jso_hdr);
 2502|       |
 2503|   168k|    if (!json_add(jso_hdr, "offset", (uint64_t) src.readb) ||
  ------------------
  |  Branch (2503:9): [True: 0, False: 168k]
  ------------------
 2504|   168k|        !obj_add_intstr_json(jso_hdr, "tag", hdr.tag, packet_tag_map) ||
  ------------------
  |  Branch (2504:9): [True: 0, False: 168k]
  ------------------
 2505|   168k|        !json_add_hex(jso_hdr, "raw", hdr.hdr, hdr.hdr_len)) {
  ------------------
  |  Branch (2505:9): [True: 0, False: 168k]
  ------------------
 2506|      0|        return false; // LCOV_EXCL_LINE
 2507|      0|    }
 2508|   168k|    if (!hdr.partial && !hdr.indeterminate &&
  ------------------
  |  Branch (2508:9): [True: 162k, False: 6.61k]
  |  Branch (2508:25): [True: 149k, False: 12.7k]
  ------------------
 2509|   149k|        !json_add(jso_hdr, "length", (uint64_t) hdr.pkt_len)) {
  ------------------
  |  Branch (2509:9): [True: 0, False: 149k]
  ------------------
 2510|      0|        return false; // LCOV_EXCL_LINE
 2511|      0|    }
 2512|   168k|    if (!json_add(jso_hdr, "partial", hdr.partial) ||
  ------------------
  |  Branch (2512:9): [True: 0, False: 168k]
  ------------------
 2513|   168k|        !json_add(jso_hdr, "indeterminate", hdr.indeterminate) ||
  ------------------
  |  Branch (2513:9): [True: 0, False: 168k]
  ------------------
 2514|   168k|        !json_add(pkt, "header", jso_hdr)) {
  ------------------
  |  Branch (2514:9): [True: 0, False: 168k]
  ------------------
 2515|      0|        return false; // LCOV_EXCL_LINE
 2516|      0|    }
 2517|   168k|    jso_hdrwrap.release();
 2518|   168k|    return true;
 2519|   168k|}
_ZN3rnp15DumpContextJson16dump_raw_packetsEv:
 2523|  17.0k|{
 2524|  17.0k|    rnp_result_t ret = RNP_ERROR_GENERIC;
 2525|       |
 2526|  17.0k|    json_object *pkts = json_object_new_array();
 2527|  17.0k|    if (!pkts) {
  ------------------
  |  Branch (2527:9): [True: 0, False: 17.0k]
  ------------------
 2528|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2529|      0|    }
 2530|  17.0k|    JSONObject pktswrap(pkts);
 2531|       |
 2532|  17.0k|    if (src.eof()) {
  ------------------
  |  Branch (2532:9): [True: 0, False: 17.0k]
  ------------------
 2533|      0|        *json = pktswrap.release();
 2534|      0|        return RNP_SUCCESS;
 2535|      0|    }
 2536|       |
 2537|       |    /* do not allow endless recursion */
 2538|  17.0k|    if (++layers > MAXIMUM_NESTING_LEVEL) {
  ------------------
  |  |   60|  17.0k|#define MAXIMUM_NESTING_LEVEL 32
  ------------------
  |  Branch (2538:9): [True: 18, False: 17.0k]
  ------------------
 2539|     18|        RNP_LOG("Too many OpenPGP nested layers during the dump.");
  ------------------
  |  |   76|     18|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     18|    do {                                                                                 \
  |  |  |  |   69|     18|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 18, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     18|            break;                                                                       \
  |  |  |  |   71|     18|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2540|     18|        *json = pktswrap.release();
 2541|     18|        return RNP_SUCCESS;
 2542|     18|    }
 2543|       |
 2544|   181k|    while (!src.eof()) {
  ------------------
  |  Branch (2544:12): [True: 172k, False: 9.36k]
  ------------------
 2545|   172k|        json_object *pkt = json_object_new_object();
 2546|   172k|        if (!pkt) {
  ------------------
  |  Branch (2546:13): [True: 0, False: 172k]
  ------------------
 2547|      0|            return RNP_ERROR_OUT_OF_MEMORY;
 2548|      0|        }
 2549|   172k|        JSONObject       pktwrap(pkt);
 2550|   172k|        pgp_packet_hdr_t hdr{};
 2551|   172k|        if (!dump_pkt_hdr(hdr, pkt)) {
  ------------------
  |  Branch (2551:13): [True: 3.03k, False: 168k]
  ------------------
 2552|  3.03k|            return RNP_ERROR_OUT_OF_MEMORY;
 2553|  3.03k|        }
 2554|       |
 2555|   168k|        if (dump_packets) {
  ------------------
  |  Branch (2555:13): [True: 168k, False: 0]
  ------------------
 2556|   168k|            size_t  rlen = hdr.pkt_len + hdr.hdr_len;
 2557|   168k|            uint8_t buf[2048 + sizeof(hdr.hdr)] = {0};
 2558|       |
 2559|   168k|            if (!hdr.pkt_len || (rlen > 2048 + hdr.hdr_len)) {
  ------------------
  |  Branch (2559:17): [True: 75.5k, False: 93.4k]
  |  Branch (2559:33): [True: 15.0k, False: 78.4k]
  ------------------
 2560|  90.5k|                rlen = 2048 + hdr.hdr_len;
 2561|  90.5k|            }
 2562|   168k|            if (!src.peek(buf, rlen, &rlen) || (rlen < hdr.hdr_len)) {
  ------------------
  |  Branch (2562:17): [True: 301, False: 168k]
  |  Branch (2562:48): [True: 0, False: 168k]
  ------------------
 2563|    301|                return RNP_ERROR_READ;
 2564|    301|            }
 2565|   168k|            if (!json_add_hex(pkt, "raw", buf + hdr.hdr_len, rlen - hdr.hdr_len)) {
  ------------------
  |  Branch (2565:17): [True: 0, False: 168k]
  ------------------
 2566|      0|                return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2567|      0|            }
 2568|   168k|        }
 2569|       |
 2570|   168k|        switch (hdr.tag) {
 2571|  23.5k|        case PGP_PKT_SIGNATURE:
  ------------------
  |  Branch (2571:9): [True: 23.5k, False: 145k]
  ------------------
 2572|  23.5k|            ret = dump_signature(pkt);
 2573|  23.5k|            break;
 2574|  11.9k|        case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (2574:9): [True: 11.9k, False: 156k]
  ------------------
 2575|  17.1k|        case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (2575:9): [True: 5.24k, False: 163k]
  ------------------
 2576|  26.6k|        case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (2576:9): [True: 9.50k, False: 159k]
  ------------------
 2577|  33.2k|        case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (2577:9): [True: 6.53k, False: 162k]
  ------------------
 2578|  33.2k|            ret = dump_key(pkt);
 2579|  33.2k|            break;
 2580|  10.9k|        case PGP_PKT_USER_ID:
  ------------------
  |  Branch (2580:9): [True: 10.9k, False: 157k]
  ------------------
 2581|  13.6k|        case PGP_PKT_USER_ATTR:
  ------------------
  |  Branch (2581:9): [True: 2.63k, False: 166k]
  ------------------
 2582|  13.6k|            ret = dump_user_id(pkt);
 2583|  13.6k|            break;
 2584|  8.41k|        case PGP_PKT_PK_SESSION_KEY:
  ------------------
  |  Branch (2584:9): [True: 8.41k, False: 160k]
  ------------------
 2585|  8.41k|            ret = dump_pk_session_key(pkt);
 2586|  8.41k|            break;
 2587|  7.28k|        case PGP_PKT_SK_SESSION_KEY:
  ------------------
  |  Branch (2587:9): [True: 7.28k, False: 161k]
  ------------------
 2588|  7.28k|            ret = dump_sk_session_key(pkt);
 2589|  7.28k|            break;
 2590|    108|        case PGP_PKT_SE_DATA:
  ------------------
  |  Branch (2590:9): [True: 108, False: 168k]
  ------------------
 2591|    204|        case PGP_PKT_SE_IP_DATA:
  ------------------
  |  Branch (2591:9): [True: 96, False: 168k]
  ------------------
 2592|    833|        case PGP_PKT_AEAD_ENCRYPTED:
  ------------------
  |  Branch (2592:9): [True: 629, False: 168k]
  ------------------
 2593|    833|            stream_pkts++;
 2594|    833|            ret = dump_encrypted(pkt, hdr.tag);
 2595|    833|            break;
 2596|  1.25k|        case PGP_PKT_ONE_PASS_SIG:
  ------------------
  |  Branch (2596:9): [True: 1.25k, False: 167k]
  ------------------
 2597|  1.25k|            ret = dump_one_pass(pkt);
 2598|  1.25k|            break;
 2599|  10.3k|        case PGP_PKT_COMPRESSED:
  ------------------
  |  Branch (2599:9): [True: 10.3k, False: 158k]
  ------------------
 2600|  10.3k|            stream_pkts++;
 2601|  10.3k|            ret = dump_compressed(pkt);
 2602|  10.3k|            break;
 2603|    782|        case PGP_PKT_LITDATA:
  ------------------
  |  Branch (2603:9): [True: 782, False: 167k]
  ------------------
 2604|    782|            stream_pkts++;
 2605|    782|            ret = dump_literal(pkt);
 2606|    782|            break;
 2607|  1.62k|        case PGP_PKT_MARKER:
  ------------------
  |  Branch (2607:9): [True: 1.62k, False: 167k]
  ------------------
 2608|  1.62k|            ret = dump_marker(pkt);
 2609|  1.62k|            break;
 2610|  4.39k|        case PGP_PKT_TRUST:
  ------------------
  |  Branch (2610:9): [True: 4.39k, False: 164k]
  ------------------
 2611|  6.01k|        case PGP_PKT_MDC:
  ------------------
  |  Branch (2611:9): [True: 1.61k, False: 167k]
  ------------------
 2612|  6.01k|            ret = stream_skip_packet(&src);
 2613|  6.01k|            break;
 2614|  61.7k|        default:
  ------------------
  |  Branch (2614:9): [True: 61.7k, False: 106k]
  ------------------
 2615|  61.7k|            ret = stream_skip_packet(&src);
 2616|  61.7k|            if (ret) {
  ------------------
  |  Branch (2616:17): [True: 470, False: 61.2k]
  ------------------
 2617|    470|                return ret;
 2618|    470|            }
 2619|  61.2k|            if (++failures > MAXIMUM_ERROR_PKTS) {
  ------------------
  |  |   62|  61.2k|#define MAXIMUM_ERROR_PKTS 64
  ------------------
  |  Branch (2619:17): [True: 918, False: 60.3k]
  ------------------
 2620|    918|                RNP_LOG("too many packet dump errors or unknown packets.");
  ------------------
  |  |   76|    918|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    918|    do {                                                                                 \
  |  |  |  |   69|    918|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 918, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    918|            break;                                                                       \
  |  |  |  |   71|    918|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2621|    918|                return RNP_ERROR_BAD_FORMAT;
 2622|    918|            }
 2623|   168k|        }
 2624|       |
 2625|   167k|        if (ret) {
  ------------------
  |  Branch (2625:13): [True: 46.6k, False: 120k]
  ------------------
 2626|  46.6k|            RNP_LOG("failed to process packet");
  ------------------
  |  |   76|  46.6k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  46.6k|    do {                                                                                 \
  |  |  |  |   69|  46.6k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 46.6k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  46.6k|            break;                                                                       \
  |  |  |  |   71|  46.6k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2627|  46.6k|            if (++failures > MAXIMUM_ERROR_PKTS) {
  ------------------
  |  |   62|  46.6k|#define MAXIMUM_ERROR_PKTS 64
  ------------------
  |  Branch (2627:17): [True: 1.85k, False: 44.7k]
  ------------------
 2628|  1.85k|                RNP_LOG("too many packet dump errors.");
  ------------------
  |  |   76|  1.85k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.85k|    do {                                                                                 \
  |  |  |  |   69|  1.85k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.85k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.85k|            break;                                                                       \
  |  |  |  |   71|  1.85k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2629|  1.85k|                return ret;
 2630|  1.85k|            }
 2631|  46.6k|        }
 2632|       |
 2633|   165k|        if (json_object_array_add(pkts, pkt)) {
  ------------------
  |  Branch (2633:13): [True: 0, False: 165k]
  ------------------
 2634|      0|            return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 2635|      0|        }
 2636|   165k|        pktwrap.release();
 2637|   165k|        if (stream_pkts > MAXIMUM_STREAM_PKTS) {
  ------------------
  |  |   61|   165k|#define MAXIMUM_STREAM_PKTS 16
  ------------------
  |  Branch (2637:13): [True: 1.08k, False: 164k]
  ------------------
 2638|  1.08k|            RNP_LOG("Too many OpenPGP stream packets during the dump.");
  ------------------
  |  |   76|  1.08k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.08k|    do {                                                                                 \
  |  |  |  |   69|  1.08k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.08k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.08k|            break;                                                                       \
  |  |  |  |   71|  1.08k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2639|  1.08k|            break;
 2640|  1.08k|        }
 2641|   165k|    }
 2642|       |
 2643|  10.4k|    *json = pktswrap.release();
 2644|  10.4k|    return RNP_SUCCESS;
 2645|  17.0k|}
_ZN3rnp15DumpContextJson4dumpEb:
 2649|  18.0k|{
 2650|       |    /* check whether source is cleartext - then skip till the signature */
 2651|  18.0k|    if (!raw_only && src.is_cleartext()) {
  ------------------
  |  Branch (2651:9): [True: 7.83k, False: 10.2k]
  |  Branch (2651:22): [True: 18, False: 7.81k]
  ------------------
 2652|     18|        if (!skip_cleartext()) {
  ------------------
  |  Branch (2652:13): [True: 14, False: 4]
  ------------------
 2653|     14|            RNP_LOG("malformed cleartext signed data");
  ------------------
  |  |   76|     14|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     14|    do {                                                                                 \
  |  |  |  |   69|     14|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 14, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     14|            break;                                                                       \
  |  |  |  |   71|     14|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2654|     14|            return RNP_ERROR_BAD_FORMAT;
 2655|     14|        }
 2656|     18|    }
 2657|       |    /* check whether source is armored */
 2658|  18.0k|    if (!raw_only && src.is_armored()) {
  ------------------
  |  Branch (2658:9): [True: 7.82k, False: 10.2k]
  |  Branch (2658:22): [True: 911, False: 6.90k]
  ------------------
 2659|    911|        std::unique_ptr<Source> armor(new Source());
 2660|    911|        rnp_result_t            ret = init_armored_src(&armor->src(), &src);
 2661|    911|        if (ret) {
  ------------------
  |  Branch (2661:13): [True: 506, False: 405]
  ------------------
 2662|    506|            RNP_LOG("failed to parse armored data");
  ------------------
  |  |   76|    506|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    506|    do {                                                                                 \
  |  |  |  |   69|    506|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 506, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    506|            break;                                                                       \
  |  |  |  |   71|    506|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2663|    506|            return ret;
 2664|    506|        }
 2665|    405|        DumpContextJson ctx(armor->src(), json);
 2666|    405|        ctx.copy_params(*this);
 2667|    405|        return ctx.dump(true);
 2668|    911|    }
 2669|       |
 2670|  17.1k|    if (src.eof()) {
  ------------------
  |  Branch (2670:9): [True: 113, False: 17.0k]
  ------------------
 2671|    113|        return RNP_ERROR_NOT_ENOUGH_DATA;
 2672|    113|    }
 2673|  17.0k|    return dump_raw_packets();
 2674|  17.1k|}
stream-dump.cpp:_ZL16init_indent_destR10pgp_dest_tPS_:
  275|  18.4k|{
  276|  18.4k|    pgp_dest_indent_param_t *param;
  277|       |
  278|  18.4k|    if (!init_dst_common(&dst, sizeof(*param))) {
  ------------------
  |  Branch (278:9): [True: 0, False: 18.4k]
  ------------------
  279|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
  280|      0|    }
  281|       |
  282|  18.4k|    dst.write = indent_dst_write;
  283|  18.4k|    dst.close = indent_dst_close;
  284|  18.4k|    dst.finish = NULL;
  285|  18.4k|    dst.no_cache = true;
  286|  18.4k|    param = (pgp_dest_indent_param_t *) dst.param;
  287|  18.4k|    param->writedst = origdst;
  288|  18.4k|    param->lstart = true;
  289|  18.4k|    param->level = 0;
  290|       |
  291|  18.4k|    return RNP_SUCCESS;
  292|  18.4k|}
stream-dump.cpp:_ZL16indent_dst_writeP10pgp_dest_tPKvm:
  236|   111M|{
  237|   111M|    pgp_dest_indent_param_t *param = (pgp_dest_indent_param_t *) dst->param;
  238|   111M|    const char *             line = (const char *) buf;
  239|   111M|    char                     indent[4] = {' ', ' ', ' ', ' '};
  240|       |
  241|   111M|    if (!len) {
  ------------------
  |  Branch (241:9): [True: 0, False: 111M]
  ------------------
  242|      0|        return RNP_SUCCESS;
  243|      0|    }
  244|       |
  245|   111M|    do {
  246|   111M|        if (param->lstart) {
  ------------------
  |  Branch (246:13): [True: 8.18M, False: 103M]
  ------------------
  247|  15.8M|            for (int i = 0; i < param->level; i++) {
  ------------------
  |  Branch (247:29): [True: 7.70M, False: 8.18M]
  ------------------
  248|  7.70M|                dst_write(param->writedst, indent, sizeof(indent));
  249|  7.70M|            }
  250|  8.18M|            param->lstart = false;
  251|  8.18M|        }
  252|       |
  253|   582M|        for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (253:28): [True: 582M, False: 0]
  ------------------
  254|   582M|            if ((line[i] == '\n') || (i == len - 1)) {
  ------------------
  |  Branch (254:17): [True: 8.18M, False: 574M]
  |  Branch (254:38): [True: 103M, False: 470M]
  ------------------
  255|   111M|                dst_write(param->writedst, line, i + 1);
  256|   111M|                param->lstart = line[i] == '\n';
  257|   111M|                line += i + 1;
  258|   111M|                len -= i + 1;
  259|   111M|                break;
  260|   111M|            }
  261|   582M|        }
  262|   111M|    } while (len > 0);
  ------------------
  |  Branch (262:14): [True: 76.4k, False: 111M]
  ------------------
  263|       |
  264|   111M|    return RNP_SUCCESS;
  265|   111M|}
stream-dump.cpp:_ZL16indent_dst_closeP10pgp_dest_tb:
  269|  18.4k|{
  270|  18.4k|    free(dst->param);
  271|  18.4k|}
stream-dump.cpp:_ZL14dst_print_timeR10pgp_dest_tPKcj:
  506|  21.8k|{
  507|  21.8k|    auto str = rnp_ctime(time).substr(0, 24);
  508|  21.8k|    dst_printf(dst,
  509|  21.8k|               "%s: %zu (%s%s)\n",
  510|  21.8k|               name,
  511|  21.8k|               (size_t) time,
  512|  21.8k|               rnp_y2k38_warning(time) ? ">=" : "",
  ------------------
  |  Branch (512:16): [True: 0, False: 21.8k]
  ------------------
  513|  21.8k|               str.c_str());
  514|  21.8k|}
stream-dump.cpp:_ZL20dst_print_expirationR10pgp_dest_tPKcj:
  518|  2.87k|{
  519|  2.87k|    if (seconds) {
  ------------------
  |  Branch (519:9): [True: 2.46k, False: 405]
  ------------------
  520|  2.46k|        int days = seconds / (24 * 60 * 60);
  521|  2.46k|        dst_printf(dst, "%s: %" PRIu32 " seconds (%d days)\n", name, seconds, days);
  522|  2.46k|    } else {
  523|    405|        dst_printf(dst, "%s: 0 (never)\n", name);
  524|    405|    }
  525|  2.87k|}
stream-dump.cpp:_ZL13dst_print_strR10pgp_dest_tPKcRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  409|  4.70k|{
  410|  4.70k|    dst_printf(dst, "%s: ", name);
  411|  4.70k|    dst_write(&dst, str.data(), str.size());
  412|  4.70k|    dst_printf(dst, "\n");
  413|  4.70k|}
stream-dump.cpp:_ZL14dst_print_algsR10pgp_dest_tRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_6vectorIhNS5_IhEEEEPK11id_str_pair:
  420|  2.93k|{
  421|  2.93k|    dst_printf(dst, "%s: ", name.c_str());
  422|  21.5k|    for (size_t i = 0; i < algs.size(); i++) {
  ------------------
  |  Branch (422:24): [True: 18.6k, False: 2.93k]
  ------------------
  423|  18.6k|        auto comma = i + 1 < algs.size() ? ", " : "";
  ------------------
  |  Branch (423:22): [True: 16.0k, False: 2.65k]
  ------------------
  424|  18.6k|        dst_printf(dst, "%s%s", id_str_pair::lookup(map, algs[i], "Unknown"), comma);
  425|  18.6k|    }
  426|  2.93k|    dst_printf(dst, " (");
  427|  21.5k|    for (size_t i = 0; i < algs.size(); i++) {
  ------------------
  |  Branch (427:24): [True: 18.6k, False: 2.93k]
  ------------------
  428|  18.6k|        auto comma = i + 1 < algs.size() ? ", " : "";
  ------------------
  |  Branch (428:22): [True: 16.0k, False: 2.65k]
  ------------------
  429|  18.6k|        dst_printf(dst, "%" PRIu8 "%s", algs[i], comma);
  430|  18.6k|    }
  431|  2.93k|    dst_printf(dst, ")\n");
  432|  2.93k|}
stream-dump.cpp:_ZL14dst_print_palgR10pgp_dest_tPKc16pgp_pubkey_alg_t:
  354|  34.3k|{
  355|  34.3k|    const char *palg_name = id_str_pair::lookup(pubkey_alg_map, palg, "Unknown");
  356|  34.3k|    if (!name) {
  ------------------
  |  Branch (356:9): [True: 34.3k, False: 0]
  ------------------
  357|  34.3k|        name = "public key algorithm";
  358|  34.3k|    }
  359|       |
  360|  34.3k|    dst_printf(dst, "%s: %d (%s)\n", name, (int) palg, palg_name);
  361|  34.3k|}
stream-dump.cpp:_ZL12dst_print_fpR10pgp_dest_tRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKN3pgp11FingerprintEb:
  468|  3.49k|{
  469|  3.49k|    dst_print_hex(dst, name, fp.data(), fp.size(), size);
  470|  3.49k|}
stream-dump.cpp:_ZL15dst_print_keyidR10pgp_dest_tRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_5arrayIhLm8EEE:
  459|  23.7k|{
  460|  23.7k|    dst_print_hex(dst, name, keyid.data(), keyid.size(), false);
  461|  23.7k|}
stream-dump.cpp:_ZL11vsnprinthexPcmPKhm:
  311|   225k|{
  312|   225k|    static const char *hexes = "0123456789abcdef";
  313|   225k|    size_t             idx = 0;
  314|       |
  315|  1.04M|    for (size_t i = 0; (i < buflen) && (i < (slen - 1) / 2); i++) {
  ------------------
  |  Branch (315:24): [True: 819k, False: 225k]
  |  Branch (315:40): [True: 819k, False: 30]
  ------------------
  316|   819k|        str[idx++] = hexes[buf[i] >> 4];
  317|   819k|        str[idx++] = hexes[buf[i] & 0xf];
  318|   819k|    }
  319|   225k|    str[idx] = '\0';
  320|   225k|    return buflen * 2;
  321|   225k|}
stream-dump.cpp:_ZL20indent_dest_increaseR10pgp_dest_t:
  296|   338k|{
  297|   338k|    ((pgp_dest_indent_param_t *) dst.param)->level++;
  298|   338k|}
stream-dump.cpp:_ZL11dst_hexdumpR10pgp_dest_tRKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  558|  25.7k|{
  559|  25.7k|    dst_hexdump(dst, data.data(), data.size());
  560|  25.7k|}
stream-dump.cpp:_ZL20indent_dest_decreaseR10pgp_dest_t:
  302|   338k|{
  303|   338k|    pgp_dest_indent_param_t *param = (pgp_dest_indent_param_t *) dst.param;
  304|   338k|    if (param->level > 0) {
  ------------------
  |  Branch (304:9): [True: 338k, False: 0]
  ------------------
  305|   338k|        param->level--;
  306|   338k|    }
  307|   338k|}
stream-dump.cpp:_ZL18dst_print_sig_typeR10pgp_dest_tPKc14pgp_sig_type_t:
  436|  9.84k|{
  437|  9.84k|    const char *sig_name = id_str_pair::lookup(sig_type_map, sigtype, "Unknown");
  438|  9.84k|    if (!name) {
  ------------------
  |  Branch (438:9): [True: 404, False: 9.44k]
  ------------------
  439|    404|        name = "signature type";
  440|    404|    }
  441|  9.84k|    dst_printf(dst, "%s: %d (%s)\n", name, (int) sigtype, sig_name);
  442|  9.84k|}
stream-dump.cpp:_ZL14dst_print_halgR10pgp_dest_tPKc14pgp_hash_alg_t:
  365|  20.8k|{
  366|  20.8k|    const char *halg_name = id_str_pair::lookup(hash_alg_map, halg, "Unknown");
  367|  20.8k|    if (!name) {
  ------------------
  |  Branch (367:9): [True: 9.84k, False: 10.9k]
  ------------------
  368|  9.84k|        name = "hash algorithm";
  369|  9.84k|    }
  370|       |
  371|  20.8k|    dst_printf(dst, "%s: %d (%s)\n", name, (int) halg, halg_name);
  372|  20.8k|}
stream-dump.cpp:_ZL13dst_print_hexR10pgp_dest_tRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKhmb:
  447|  52.9k|{
  448|  52.9k|    char hex[512];
  449|  52.9k|    vsnprinthex(hex, sizeof(hex), data, len);
  450|  52.9k|    if (bytes) {
  ------------------
  |  Branch (450:9): [True: 19.1k, False: 33.8k]
  ------------------
  451|  19.1k|        dst_printf(dst, "%s: 0x%s (%d bytes)\n", name.c_str(), hex, (int) len);
  452|  33.8k|    } else {
  453|  33.8k|        dst_printf(dst, "%s: 0x%s\n", name.c_str(), hex);
  454|  33.8k|    }
  455|  52.9k|}
stream-dump.cpp:_ZL13dst_print_mpiR10pgp_dest_tPKcRKN3pgp3mpiEb:
  325|  41.6k|{
  326|  41.6k|    if (!dumpbin) {
  ------------------
  |  Branch (326:9): [True: 41.6k, False: 0]
  ------------------
  327|  41.6k|        dst_printf(dst, "%s: %zu bits\n", name, mpi.bits());
  328|  41.6k|    } else {
  329|      0|        char hex[5000];
  330|      0|        vsnprinthex(hex, sizeof(hex), mpi.data(), mpi.size());
  331|      0|        dst_printf(dst, "%s: %zu bits, %s\n", name, mpi.bits(), hex);
  332|      0|    }
  333|  41.6k|}
stream-dump.cpp:_ZL13dst_print_vecR10pgp_dest_tPKcRKNSt3__16vectorIhNS3_9allocatorIhEEEEb:
  341|  8.05k|{
  342|  8.05k|    if (!dumpbin) {
  ------------------
  |  Branch (342:9): [True: 8.05k, False: 0]
  ------------------
  343|  8.05k|        dst_printf(dst, "%s\n", name);
  344|  8.05k|    } else {
  345|      0|        std::vector<char> hex(2 * data.size());
  346|      0|        vsnprinthex(hex.data(), hex.size(), data.data(), data.size());
  347|      0|        dst_printf(dst, "%s, %s\n", name, hex.data());
  348|      0|    }
  349|  8.05k|}
stream-dump.cpp:_ZL14dst_print_salgR10pgp_dest_tPKc14pgp_symm_alg_t:
  376|  13.1k|{
  377|  13.1k|    const char *salg_name = id_str_pair::lookup(symm_alg_map, salg, "Unknown");
  378|  13.1k|    if (!name) {
  ------------------
  |  Branch (378:9): [True: 13.1k, False: 0]
  ------------------
  379|  13.1k|        name = "symmetric algorithm";
  380|  13.1k|    }
  381|       |
  382|  13.1k|    dst_printf(dst, "%s: %d (%s)\n", name, (int) salg, salg_name);
  383|  13.1k|}
stream-dump.cpp:_ZL13dst_print_s2kR10pgp_dest_tR9pgp_s2k_t:
  474|  13.0k|{
  475|  13.0k|    dst_printf(dst, "s2k specifier: %d\n", (int) s2k.specifier);
  476|  13.0k|    if ((s2k.specifier == PGP_S2KS_EXPERIMENTAL) && s2k.gpg_ext_num) {
  ------------------
  |  Branch (476:9): [True: 2.54k, False: 10.5k]
  |  Branch (476:53): [True: 1.17k, False: 1.37k]
  ------------------
  477|  1.17k|        dst_printf(dst, "GPG extension num: %d\n", (int) s2k.gpg_ext_num);
  478|  1.17k|        if (s2k.gpg_ext_num == PGP_S2K_GPG_SMARTCARD) {
  ------------------
  |  Branch (478:13): [True: 899, False: 274]
  ------------------
  479|    899|            static_assert(sizeof(s2k.gpg_serial) == 16, "invalid s2k->gpg_serial size");
  480|    899|            size_t slen = s2k.gpg_serial_len > 16 ? 16 : s2k.gpg_serial_len;
  ------------------
  |  Branch (480:27): [True: 221, False: 678]
  ------------------
  481|    899|            dst_print_hex(dst, "card serial number", s2k.gpg_serial, slen, true);
  482|    899|        }
  483|  1.17k|        return;
  484|  1.17k|    }
  485|  11.9k|    if (s2k.specifier == PGP_S2KS_EXPERIMENTAL) {
  ------------------
  |  Branch (485:9): [True: 1.37k, False: 10.5k]
  ------------------
  486|  1.37k|        dst_print_hex(dst,
  487|  1.37k|                      "Unknown experimental s2k",
  488|  1.37k|                      s2k.experimental.data(),
  489|  1.37k|                      s2k.experimental.size(),
  490|  1.37k|                      true);
  491|  1.37k|        return;
  492|  1.37k|    }
  493|  10.5k|    dst_print_halg(dst, "s2k hash algorithm", s2k.hash_alg);
  494|  10.5k|    if ((s2k.specifier == PGP_S2KS_SALTED) ||
  ------------------
  |  Branch (494:9): [True: 328, False: 10.2k]
  ------------------
  495|  10.2k|        (s2k.specifier == PGP_S2KS_ITERATED_AND_SALTED)) {
  ------------------
  |  Branch (495:9): [True: 288, False: 9.91k]
  ------------------
  496|    616|        dst_print_hex(dst, "s2k salt", s2k.salt, PGP_SALT_SIZE, false);
  ------------------
  |  |   92|    616|#define PGP_SALT_SIZE 8
  ------------------
  497|    616|    }
  498|  10.5k|    if (s2k.specifier == PGP_S2KS_ITERATED_AND_SALTED) {
  ------------------
  |  Branch (498:9): [True: 288, False: 10.2k]
  ------------------
  499|    288|        size_t real_iter = pgp_s2k_decode_iterations(s2k.iterations);
  500|    288|        dst_printf(dst, "s2k iterations: %zu (encoded as %u)\n", real_iter, s2k.iterations);
  501|    288|    }
  502|  10.5k|}
stream-dump.cpp:_ZL14dst_print_aalgR10pgp_dest_tPKc14pgp_aead_alg_t:
  387|    561|{
  388|    561|    const char *aalg_name = id_str_pair::lookup(aead_alg_map, aalg, "Unknown");
  389|    561|    if (!name) {
  ------------------
  |  Branch (389:9): [True: 561, False: 0]
  ------------------
  390|    561|        name = "aead algorithm";
  391|    561|    }
  392|       |
  393|    561|    dst_printf(dst, "%s: %d (%s)\n", name, (int) aalg, aalg_name);
  394|    561|}
stream-dump.cpp:_ZL14dst_print_zalgR10pgp_dest_tPKc22pgp_compression_type_t:
  398|  10.1k|{
  399|  10.1k|    const char *zalg_name = id_str_pair::lookup(z_alg_map, zalg, "Unknown");
  400|  10.1k|    if (!name) {
  ------------------
  |  Branch (400:9): [True: 10.1k, False: 0]
  ------------------
  401|  10.1k|        name = "compression algorithm";
  402|  10.1k|    }
  403|       |
  404|  10.1k|    dst_printf(dst, "%s: %d (%s)\n", name, (int) zalg, zalg_name);
  405|  10.1k|}
stream-dump.cpp:_ZL11dst_hexdumpR10pgp_dest_tPKhm:
  531|   197k|{
  532|   197k|    size_t i;
  533|   197k|    char   line[LINELEN + 1];
  534|       |
  535|  33.8M|    for (i = 0; i < length; i++) {
  ------------------
  |  Branch (535:17): [True: 33.6M, False: 197k]
  ------------------
  536|  33.6M|        if (i % LINELEN == 0) {
  ------------------
  |  |  527|  33.6M|#define LINELEN 16
  ------------------
  |  Branch (536:13): [True: 2.19M, False: 31.4M]
  ------------------
  537|  2.19M|            dst_printf(dst, "%.5zu | ", i);
  538|  2.19M|        }
  539|  33.6M|        dst_printf(dst, "%.02x ", (uint8_t) src[i]);
  540|  33.6M|        line[i % LINELEN] = (isprint(src[i])) ? src[i] : '.';
  ------------------
  |  |  527|  33.6M|#define LINELEN 16
  ------------------
  |  Branch (540:29): [True: 5.64M, False: 28.0M]
  ------------------
  541|  33.6M|        if (i % LINELEN == LINELEN - 1) {
  ------------------
  |  |  527|  33.6M|#define LINELEN 16
  ------------------
                      if (i % LINELEN == LINELEN - 1) {
  ------------------
  |  |  527|  33.6M|#define LINELEN 16
  ------------------
  |  Branch (541:13): [True: 2.03M, False: 31.6M]
  ------------------
  542|  2.03M|            line[LINELEN] = 0x0;
  ------------------
  |  |  527|  2.03M|#define LINELEN 16
  ------------------
  543|  2.03M|            dst_printf(dst, " | %s\n", line);
  544|  2.03M|        }
  545|  33.6M|    }
  546|   197k|    if (i % LINELEN != 0) {
  ------------------
  |  |  527|   197k|#define LINELEN 16
  ------------------
  |  Branch (546:9): [True: 161k, False: 35.0k]
  ------------------
  547|  1.61M|        for (; i % LINELEN != 0; i++) {
  ------------------
  |  |  527|  1.61M|#define LINELEN 16
  ------------------
  |  Branch (547:16): [True: 1.45M, False: 161k]
  ------------------
  548|  1.45M|            dst_printf(dst, "   ");
  549|  1.45M|            line[i % LINELEN] = ' ';
  ------------------
  |  |  527|  1.45M|#define LINELEN 16
  ------------------
  550|  1.45M|        }
  551|   161k|        line[LINELEN] = 0x0;
  ------------------
  |  |  527|   161k|#define LINELEN 16
  ------------------
  552|   161k|        dst_printf(dst, " | %s\n", line);
  553|   161k|    }
  554|   197k|}
stream-dump.cpp:_ZN3rnpL22subpacket_obj_add_algsEP11json_objectPKcRKNSt3__16vectorIhNS4_9allocatorIhEEEEPK11id_str_pair:
 1647|  2.93k|{
 1648|  2.93k|    json_object *jso_algs = json_object_new_array();
 1649|  2.93k|    if (!jso_algs || !json_add(obj, name, jso_algs)) {
  ------------------
  |  Branch (1649:9): [True: 0, False: 2.93k]
  |  Branch (1649:22): [True: 0, False: 2.93k]
  ------------------
 1650|      0|        return false; // LCOV_EXCL_LINE
 1651|      0|    }
 1652|  18.6k|    for (auto &alg : algs) {
  ------------------
  |  Branch (1652:20): [True: 18.6k, False: 2.93k]
  ------------------
 1653|  18.6k|        if (!json_array_add(jso_algs, json_object_new_int(alg))) {
  ------------------
  |  Branch (1653:13): [True: 0, False: 18.6k]
  ------------------
 1654|      0|            return false; // LCOV_EXCL_LINE
 1655|      0|        }
 1656|  18.6k|    }
 1657|  2.93k|    if (!map) {
  ------------------
  |  Branch (1657:9): [True: 0, False: 2.93k]
  ------------------
 1658|      0|        return true;
 1659|      0|    }
 1660|       |
 1661|  2.93k|    char strname[64] = {0};
 1662|  2.93k|    snprintf(strname, sizeof(strname), "%s.str", name);
 1663|       |
 1664|  2.93k|    jso_algs = json_object_new_array();
 1665|  2.93k|    if (!jso_algs || !json_add(obj, strname, jso_algs)) {
  ------------------
  |  Branch (1665:9): [True: 0, False: 2.93k]
  |  Branch (1665:22): [True: 0, False: 2.93k]
  ------------------
 1666|      0|        return false; // LCOV_EXCL_LINE
 1667|      0|    }
 1668|  18.6k|    for (auto &alg : algs) {
  ------------------
  |  Branch (1668:20): [True: 18.6k, False: 2.93k]
  ------------------
 1669|  18.6k|        if (!json_array_add(jso_algs, id_str_pair::lookup(map, alg, "Unknown"))) {
  ------------------
  |  Branch (1669:13): [True: 0, False: 18.6k]
  ------------------
 1670|      0|            return false; // LCOV_EXCL_LINE
 1671|      0|        }
 1672|  18.6k|    }
 1673|  2.93k|    return true;
 1674|  2.93k|}
stream-dump.cpp:_ZN3rnpL19obj_add_intstr_jsonEP11json_objectPKciPK11id_str_pair:
 1614|   286k|{
 1615|   286k|    if (!json_add(obj, name, val)) {
  ------------------
  |  Branch (1615:9): [True: 0, False: 286k]
  ------------------
 1616|      0|        return false; // LCOV_EXCL_LINE
 1617|      0|    }
 1618|   286k|    if (!map) {
  ------------------
  |  Branch (1618:9): [True: 0, False: 286k]
  ------------------
 1619|      0|        return true;
 1620|      0|    }
 1621|   286k|    char        namestr[64] = {0};
 1622|   286k|    const char *str = id_str_pair::lookup(map, val, "Unknown");
 1623|   286k|    snprintf(namestr, sizeof(namestr), "%s.str", name);
 1624|   286k|    return json_add(obj, namestr, str);
 1625|   286k|}
stream-dump.cpp:_ZN3rnpL16obj_add_mpi_jsonEP11json_objectPKcRKN3pgp3mpiEb:
 1629|  40.8k|{
 1630|  40.8k|    char strname[64] = {0};
 1631|  40.8k|    snprintf(strname, sizeof(strname), "%s.bits", name);
 1632|  40.8k|    if (!json_add(obj, strname, (int) mpi.bits())) {
  ------------------
  |  Branch (1632:9): [True: 0, False: 40.8k]
  ------------------
 1633|      0|        return false; // LCOV_EXCL_LINE
 1634|      0|    }
 1635|  40.8k|    if (!contents) {
  ------------------
  |  Branch (1635:9): [True: 40.8k, False: 0]
  ------------------
 1636|  40.8k|        return true;
 1637|  40.8k|    }
 1638|      0|    snprintf(strname, sizeof(strname), "%s.raw", name);
 1639|      0|    return json_add_hex(obj, strname, mpi.data(), mpi.size());
 1640|  40.8k|}
stream-dump.cpp:_ZN3rnpL16obj_add_s2k_jsonEP11json_objectP9pgp_s2k_t:
 1678|  16.8k|{
 1679|  16.8k|    json_object *s2k_obj = json_object_new_object();
 1680|  16.8k|    if (!json_add(obj, "s2k", s2k_obj)) {
  ------------------
  |  Branch (1680:9): [True: 0, False: 16.8k]
  ------------------
 1681|      0|        return false; // LCOV_EXCL_LINE
 1682|      0|    }
 1683|  16.8k|    if (!json_add(s2k_obj, "specifier", (int) s2k->specifier)) {
  ------------------
  |  Branch (1683:9): [True: 0, False: 16.8k]
  ------------------
 1684|      0|        return false; // LCOV_EXCL_LINE
 1685|      0|    }
 1686|  16.8k|    if ((s2k->specifier == PGP_S2KS_EXPERIMENTAL) && s2k->gpg_ext_num) {
  ------------------
  |  Branch (1686:9): [True: 2.52k, False: 14.3k]
  |  Branch (1686:54): [True: 1.16k, False: 1.35k]
  ------------------
 1687|  1.16k|        if (!json_add(s2k_obj, "gpg extension", (int) s2k->gpg_ext_num)) {
  ------------------
  |  Branch (1687:13): [True: 0, False: 1.16k]
  ------------------
 1688|      0|            return false; // LCOV_EXCL_LINE
 1689|      0|        }
 1690|  1.16k|        if (s2k->gpg_ext_num == PGP_S2K_GPG_SMARTCARD) {
  ------------------
  |  Branch (1690:13): [True: 897, False: 272]
  ------------------
 1691|    897|            size_t slen = s2k->gpg_serial_len > 16 ? 16 : s2k->gpg_serial_len;
  ------------------
  |  Branch (1691:27): [True: 221, False: 676]
  ------------------
 1692|    897|            if (!json_add_hex(s2k_obj, "card serial number", s2k->gpg_serial, slen)) {
  ------------------
  |  Branch (1692:17): [True: 0, False: 897]
  ------------------
 1693|      0|                return false; // LCOV_EXCL_LINE
 1694|      0|            }
 1695|    897|        }
 1696|  1.16k|    }
 1697|  16.8k|    if (s2k->specifier == PGP_S2KS_EXPERIMENTAL) {
  ------------------
  |  Branch (1697:9): [True: 2.52k, False: 14.3k]
  ------------------
 1698|  2.52k|        return json_add_hex(s2k_obj, "unknown experimental", s2k->experimental);
 1699|  2.52k|    }
 1700|  14.3k|    if (!obj_add_intstr_json(s2k_obj, "hash algorithm", s2k->hash_alg, hash_alg_map)) {
  ------------------
  |  Branch (1700:9): [True: 0, False: 14.3k]
  ------------------
 1701|      0|        return false; // LCOV_EXCL_LINE
 1702|      0|    }
 1703|  14.3k|    if (((s2k->specifier == PGP_S2KS_SALTED) ||
  ------------------
  |  Branch (1703:10): [True: 321, False: 14.0k]
  ------------------
 1704|  14.0k|         (s2k->specifier == PGP_S2KS_ITERATED_AND_SALTED)) &&
  ------------------
  |  Branch (1704:10): [True: 284, False: 13.7k]
  ------------------
 1705|    605|        !json_add_hex(s2k_obj, "salt", s2k->salt, PGP_SALT_SIZE)) {
  ------------------
  |  |   92|    605|#define PGP_SALT_SIZE 8
  ------------------
  |  Branch (1705:9): [True: 0, False: 605]
  ------------------
 1706|      0|        return false; // LCOV_EXCL_LINE
 1707|      0|    }
 1708|  14.3k|    if (s2k->specifier == PGP_S2KS_ITERATED_AND_SALTED) {
  ------------------
  |  Branch (1708:9): [True: 284, False: 14.0k]
  ------------------
 1709|    284|        size_t real_iter = pgp_s2k_decode_iterations(s2k->iterations);
 1710|    284|        if (!json_add(s2k_obj, "iterations", (uint64_t) real_iter)) {
  ------------------
  |  Branch (1710:13): [True: 0, False: 284]
  ------------------
 1711|      0|            return false; // LCOV_EXCL_LINE
 1712|      0|        }
 1713|    284|    }
 1714|  14.3k|    return true;
 1715|  14.3k|}

_ZN3rnp11DumpContextC2ER12pgp_source_t:
   58|  36.5k|    DumpContext(pgp_source_t &asrc) : src(asrc){};
_ZN3rnp11DumpContextD2Ev:
   59|  36.5k|    virtual ~DumpContext(){};
_ZN3rnp15DumpContextJsonC2ER12pgp_source_tPP11json_object:
  131|  18.0k|        : DumpContext(asrc), json(ajson){};
_ZN3rnp11DumpContext14set_dump_gripsEb:
   63|  15.6k|    {
   64|  15.6k|        dump_grips = value;
   65|  15.6k|    }
_ZN3rnp11DumpContext12set_dump_mpiEb:
   69|  15.6k|    {
   70|  15.6k|        dump_mpi = value;
   71|  15.6k|    }
_ZN3rnp11DumpContext16set_dump_packetsEb:
   75|  15.6k|    {
   76|  15.6k|        dump_packets = value;
   77|  15.6k|    }

_ZN16pgp_userid_pkt_t5parseER12pgp_source_t:
  673|  27.3k|{
  674|       |    /* check the tag */
  675|  27.3k|    int stag = stream_pkt_type(src);
  676|  27.3k|    if ((stag != PGP_PKT_USER_ID) && (stag != PGP_PKT_USER_ATTR)) {
  ------------------
  |  Branch (676:9): [True: 5.29k, False: 22.0k]
  |  Branch (676:38): [True: 13, False: 5.28k]
  ------------------
  677|     13|        RNP_LOG("wrong userid tag: %d", stag);
  ------------------
  |  |   76|     13|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     13|    do {                                                                                 \
  |  |  |  |   69|     13|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 13, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     13|            break;                                                                       \
  |  |  |  |   71|     13|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  678|     13|        return RNP_ERROR_BAD_FORMAT;
  679|     13|    }
  680|       |
  681|  27.3k|    pgp_packet_body_t pkt(PGP_PKT_RESERVED);
  682|  27.3k|    rnp_result_t      res = pkt.read(src);
  683|  27.3k|    if (res) {
  ------------------
  |  Branch (683:9): [True: 1.03k, False: 26.2k]
  ------------------
  684|  1.03k|        return res;
  685|  1.03k|    }
  686|       |
  687|       |    /* userid type, i.e. tag */
  688|  26.2k|    tag = (pgp_pkt_type_t) stag;
  689|  26.2k|    uid.resize(pkt.size());
  690|  26.2k|    if (pkt.size()) {
  ------------------
  |  Branch (690:9): [True: 21.1k, False: 5.07k]
  ------------------
  691|  21.1k|        std::memcpy(uid.data(), pkt.data(), pkt.size());
  692|  21.1k|    }
  693|  26.2k|    return RNP_SUCCESS;
  694|  27.3k|}
_ZN13pgp_key_pkt_tD2Ev:
  781|  67.1k|{
  782|  67.1k|    secure_clear(sec_data.data(), sec_data.size());
  783|  67.1k|}
_ZN13pgp_key_pkt_t5parseER12pgp_source_t:
  886|  67.1k|{
  887|       |    /* check the key tag */
  888|  67.1k|    int atag = stream_pkt_type(src);
  889|  67.1k|    if (!is_key_pkt(atag)) {
  ------------------
  |  Branch (889:9): [True: 83, False: 67.0k]
  ------------------
  890|     83|        RNP_LOG("wrong key packet tag: %d", atag);
  ------------------
  |  |   76|     83|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     83|    do {                                                                                 \
  |  |  |  |   69|     83|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 83, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     83|            break;                                                                       \
  |  |  |  |   71|     83|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  891|     83|        return RNP_ERROR_BAD_FORMAT;
  892|     83|    }
  893|       |
  894|  67.0k|#if defined(ENABLE_CRYPTO_REFRESH) || defined(ENABLE_PQC)
  895|  67.0k|    std::vector<uint8_t> tmpbuf;
  896|  67.0k|#endif
  897|       |
  898|  67.0k|    pgp_packet_body_t pkt((pgp_pkt_type_t) atag);
  899|       |    /* Read the packet into memory */
  900|  67.0k|    rnp_result_t res = pkt.read(src);
  901|  67.0k|    if (res) {
  ------------------
  |  Branch (901:9): [True: 4.52k, False: 62.4k]
  ------------------
  902|  4.52k|        return res;
  903|  4.52k|    }
  904|       |    /* key type, i.e. tag */
  905|  62.4k|    tag = (pgp_pkt_type_t) atag;
  906|       |    /* version */
  907|  62.4k|    uint8_t ver = 0;
  908|  62.4k|    if (!pkt.get(ver)) {
  ------------------
  |  Branch (908:9): [True: 455, False: 62.0k]
  ------------------
  909|    455|        RNP_LOG("unable to retrieve key packet version");
  ------------------
  |  |   76|    455|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    455|    do {                                                                                 \
  |  |  |  |   69|    455|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 455, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    455|            break;                                                                       \
  |  |  |  |   71|    455|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  910|    455|        return RNP_ERROR_BAD_FORMAT;
  911|    455|    }
  912|  62.0k|    switch (ver) {
  913|  1.91k|    case PGP_V2:
  ------------------
  |  Branch (913:5): [True: 1.91k, False: 60.1k]
  ------------------
  914|  1.91k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.91k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  915|  4.74k|    case PGP_V3:
  ------------------
  |  Branch (915:5): [True: 2.83k, False: 59.2k]
  ------------------
  916|  4.74k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.74k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  917|  47.0k|    case PGP_V4:
  ------------------
  |  Branch (917:5): [True: 42.2k, False: 19.7k]
  ------------------
  918|  47.0k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  47.0k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  919|  49.9k|    case PGP_V5:
  ------------------
  |  Branch (919:5): [True: 2.89k, False: 59.1k]
  ------------------
  920|  49.9k|        break;
  921|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  922|  10.5k|    case PGP_V6:
  ------------------
  |  Branch (922:5): [True: 10.5k, False: 51.4k]
  ------------------
  923|  10.5k|        break;
  924|      0|#endif
  925|  1.56k|    default:
  ------------------
  |  Branch (925:5): [True: 1.56k, False: 60.4k]
  ------------------
  926|  1.56k|        RNP_LOG("wrong key packet version");
  ------------------
  |  |   76|  1.56k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.56k|    do {                                                                                 \
  |  |  |  |   69|  1.56k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.56k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.56k|            break;                                                                       \
  |  |  |  |   71|  1.56k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  927|  1.56k|        return RNP_ERROR_BAD_FORMAT;
  928|  62.0k|    }
  929|  60.4k|    version = (pgp_version_t) ver;
  930|       |    /* creation time */
  931|  60.4k|    if (!pkt.get(creation_time)) {
  ------------------
  |  Branch (931:9): [True: 306, False: 60.1k]
  ------------------
  932|    306|        return RNP_ERROR_BAD_FORMAT;
  933|    306|    }
  934|       |    /* v3: validity days */
  935|  60.1k|    if ((version < PGP_V4) && !pkt.get(v3_days)) {
  ------------------
  |  Branch (935:9): [True: 4.60k, False: 55.5k]
  |  Branch (935:31): [True: 220, False: 4.38k]
  ------------------
  936|    220|        return RNP_ERROR_BAD_FORMAT;
  937|    220|    }
  938|       |    /* key algorithm */
  939|  59.9k|    uint8_t analg = 0;
  940|  59.9k|    if (!pkt.get(analg)) {
  ------------------
  |  Branch (940:9): [True: 234, False: 59.7k]
  ------------------
  941|    234|        return RNP_ERROR_BAD_FORMAT;
  942|    234|    }
  943|  59.7k|    alg = (pgp_pubkey_alg_t) analg;
  944|  59.7k|    material = pgp::KeyMaterial::create(alg);
  945|  59.7k|    if (!material) {
  ------------------
  |  Branch (945:9): [True: 528, False: 59.1k]
  ------------------
  946|    528|        RNP_LOG("unknown key algorithm: %d", (int) alg);
  ------------------
  |  |   76|    528|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    528|    do {                                                                                 \
  |  |  |  |   69|    528|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 528, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    528|            break;                                                                       \
  |  |  |  |   71|    528|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  947|    528|        return RNP_ERROR_BAD_FORMAT;
  948|    528|    }
  949|  59.1k|    switch (version) {
  950|  1.72k|    case PGP_V2:
  ------------------
  |  Branch (950:5): [True: 1.72k, False: 57.4k]
  ------------------
  951|  4.09k|    case PGP_V3:
  ------------------
  |  Branch (951:5): [True: 2.37k, False: 56.8k]
  ------------------
  952|       |        /* v3 keys must be RSA-only */
  953|  4.09k|        if (!is_rsa_key_alg(alg)) {
  ------------------
  |  Branch (953:13): [True: 440, False: 3.65k]
  ------------------
  954|    440|            RNP_LOG("wrong v3 pk algorithm");
  ------------------
  |  |   76|    440|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    440|    do {                                                                                 \
  |  |  |  |   69|    440|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 440, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    440|            break;                                                                       \
  |  |  |  |   71|    440|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  955|    440|            return RNP_ERROR_BAD_FORMAT;
  956|    440|        }
  957|  3.65k|        break;
  958|  3.65k|    case PGP_V5:
  ------------------
  |  Branch (958:5): [True: 2.80k, False: 56.3k]
  ------------------
  959|  2.80k|#if defined(ENABLE_CRYPTO_REFRESH)
  960|  13.1k|    case PGP_V6:
  ------------------
  |  Branch (960:5): [True: 10.3k, False: 48.8k]
  ------------------
  961|  13.1k|#endif
  962|       |        /* v5-v6 public key material length  */
  963|  13.1k|        if (!pkt.get(v5_pub_len)) {
  ------------------
  |  Branch (963:13): [True: 1.35k, False: 11.7k]
  ------------------
  964|  1.35k|            RNP_LOG("failed to get v5 octet count field");
  ------------------
  |  |   76|  1.35k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.35k|    do {                                                                                 \
  |  |  |  |   69|  1.35k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.35k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.35k|            break;                                                                       \
  |  |  |  |   71|  1.35k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  965|  1.35k|            return RNP_ERROR_BAD_FORMAT;
  966|  1.35k|        }
  967|  11.7k|        if (is_public_key_pkt(atag) && (v5_pub_len != pkt.left())) {
  ------------------
  |  Branch (967:13): [True: 791, False: 10.9k]
  |  Branch (967:40): [True: 579, False: 212]
  ------------------
  968|    579|            RNP_LOG("v5 octet count mismatch");
  ------------------
  |  |   76|    579|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    579|    do {                                                                                 \
  |  |  |  |   69|    579|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 579, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    579|            break;                                                                       \
  |  |  |  |   71|    579|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  969|    579|            return RNP_ERROR_BAD_FORMAT;
  970|    579|        }
  971|  11.2k|        break;
  972|  41.9k|    default:;
  ------------------
  |  Branch (972:5): [True: 41.9k, False: 17.2k]
  ------------------
  973|  59.1k|    }
  974|       |
  975|       |    /* algorithm specific fields */
  976|  56.8k|    if (!material->parse(pkt)) {
  ------------------
  |  Branch (976:9): [True: 12.1k, False: 44.6k]
  ------------------
  977|  12.1k|        return RNP_ERROR_BAD_FORMAT;
  978|  12.1k|    }
  979|       |
  980|       |    /* fill hashed data used for signatures */
  981|  44.6k|    pub_data.assign(pkt.data(), pkt.data() + pkt.size() - pkt.left());
  982|       |
  983|       |    /* secret key fields if any */
  984|  44.6k|    if (is_secret_key_pkt(tag)) {
  ------------------
  |  Branch (984:9): [True: 30.7k, False: 13.8k]
  ------------------
  985|  30.7k|        uint8_t usage = 0;
  986|  30.7k|        if (!pkt.get(usage)) {
  ------------------
  |  Branch (986:13): [True: 214, False: 30.5k]
  ------------------
  987|    214|            RNP_LOG("failed to read key protection");
  ------------------
  |  |   76|    214|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    214|    do {                                                                                 \
  |  |  |  |   69|    214|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 214, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    214|            break;                                                                       \
  |  |  |  |   71|    214|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  988|    214|            return RNP_ERROR_BAD_FORMAT;
  989|    214|        }
  990|  30.5k|#if defined(ENABLE_CRYPTO_REFRESH)
  991|  30.5k|        if (version == PGP_V6 && usage == 255) {
  ------------------
  |  Branch (991:13): [True: 8.01k, False: 22.5k]
  |  Branch (991:34): [True: 200, False: 7.81k]
  ------------------
  992|    200|            RNP_LOG(
  ------------------
  |  |   76|    200|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    200|    do {                                                                                 \
  |  |  |  |   69|    200|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 200, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    200|            break;                                                                       \
  |  |  |  |   71|    200|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  993|    200|              "Error when parsing S2K usage: A version 6 packet MUST NOT use the value 255.");
  994|    200|            return RNP_ERROR_BAD_FORMAT;
  995|    200|        }
  996|  30.3k|#endif
  997|  30.3k|        sec_protection.s2k.usage = (pgp_s2k_usage_t) usage;
  998|  30.3k|        sec_protection.cipher_mode = PGP_CIPHER_MODE_CFB;
  999|       |
 1000|       |        /* v5 s2k length, ignored for now */
 1001|  30.3k|        if (version == PGP_V5) {
  ------------------
  |  Branch (1001:13): [True: 1.47k, False: 28.8k]
  ------------------
 1002|  1.47k|            if (!pkt.get(v5_s2k_len)) {
  ------------------
  |  Branch (1002:17): [True: 206, False: 1.27k]
  ------------------
 1003|    206|                RNP_LOG("failed to read v5 s2k len");
  ------------------
  |  |   76|    206|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    206|    do {                                                                                 \
  |  |  |  |   69|    206|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 206, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    206|            break;                                                                       \
  |  |  |  |   71|    206|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1004|    206|                return RNP_ERROR_BAD_FORMAT;
 1005|    206|            }
 1006|  1.47k|        }
 1007|  30.1k|#if defined(ENABLE_CRYPTO_REFRESH)
 1008|  30.1k|        if (version == PGP_V6 && sec_protection.s2k.usage != PGP_S2KU_NONE) {
  ------------------
  |  Branch (1008:13): [True: 7.81k, False: 22.3k]
  |  Branch (1008:34): [True: 7.47k, False: 338]
  ------------------
 1009|       |            // V6 packages contain the count of the optional 1-byte parameters
 1010|  7.47k|            if (!pkt.get(v5_s2k_len)) {
  ------------------
  |  Branch (1010:17): [True: 208, False: 7.26k]
  ------------------
 1011|    208|                RNP_LOG("failed to read key protection");
  ------------------
  |  |   76|    208|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    208|    do {                                                                                 \
  |  |  |  |   69|    208|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 208, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    208|            break;                                                                       \
  |  |  |  |   71|    208|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1012|    208|                return RNP_ERROR_BAD_FORMAT;
 1013|    208|            }
 1014|  7.47k|        }
 1015|  29.9k|#endif
 1016|       |
 1017|  29.9k|        switch (sec_protection.s2k.usage) {
 1018|  8.45k|        case PGP_S2KU_NONE:
  ------------------
  |  Branch (1018:9): [True: 8.45k, False: 21.4k]
  ------------------
 1019|  8.45k|            break;
 1020|    464|        case PGP_S2KU_ENCRYPTED:
  ------------------
  |  Branch (1020:9): [True: 464, False: 29.4k]
  ------------------
 1021|  1.95k|        case PGP_S2KU_ENCRYPTED_AND_HASHED: {
  ------------------
  |  Branch (1021:9): [True: 1.48k, False: 28.4k]
  ------------------
 1022|       |            /* we have s2k */
 1023|  1.95k|            uint8_t salg = 0;
 1024|  1.95k|            if (!pkt.get(salg)) {
  ------------------
  |  Branch (1024:17): [True: 203, False: 1.75k]
  ------------------
 1025|    203|                RNP_LOG("failed to read key protection (symmetric alg)");
  ------------------
  |  |   76|    203|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    203|    do {                                                                                 \
  |  |  |  |   69|    203|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 203, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    203|            break;                                                                       \
  |  |  |  |   71|    203|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1026|    203|                return RNP_ERROR_BAD_FORMAT;
 1027|    203|            }
 1028|  1.75k|#if defined(ENABLE_CRYPTO_REFRESH)
 1029|  1.75k|            if (version == PGP_V6) {
  ------------------
  |  Branch (1029:17): [True: 378, False: 1.37k]
  ------------------
 1030|       |                // V6 packages contain the length of the following field
 1031|    378|                uint8_t s2k_specifier_len;
 1032|    378|                if (!pkt.get(s2k_specifier_len)) {
  ------------------
  |  Branch (1032:21): [True: 196, False: 182]
  ------------------
 1033|    196|                    RNP_LOG("failed to read key protection (s2k specifier length)");
  ------------------
  |  |   76|    196|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    196|    do {                                                                                 \
  |  |  |  |   69|    196|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 196, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    196|            break;                                                                       \
  |  |  |  |   71|    196|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1034|    196|                }
 1035|    378|            }
 1036|  1.75k|#endif
 1037|  1.75k|            if (!pkt.get(sec_protection.s2k)) {
  ------------------
  |  Branch (1037:17): [True: 549, False: 1.20k]
  ------------------
 1038|    549|                RNP_LOG("failed to read key protection (s2k)");
  ------------------
  |  |   76|    549|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    549|    do {                                                                                 \
  |  |  |  |   69|    549|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 549, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    549|            break;                                                                       \
  |  |  |  |   71|    549|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1039|    549|                return RNP_ERROR_BAD_FORMAT;
 1040|    549|            }
 1041|  1.20k|            sec_protection.symm_alg = (pgp_symm_alg_t) salg;
 1042|  1.20k|            break;
 1043|  1.75k|        }
 1044|  19.5k|        default:
  ------------------
  |  Branch (1044:9): [True: 19.5k, False: 10.4k]
  ------------------
 1045|       |            /* old-style: usage is symmetric algorithm identifier */
 1046|  19.5k|            sec_protection.symm_alg = (pgp_symm_alg_t) usage;
 1047|  19.5k|            sec_protection.s2k.usage = PGP_S2KU_ENCRYPTED;
 1048|  19.5k|            sec_protection.s2k.specifier = PGP_S2KS_SIMPLE;
 1049|  19.5k|            sec_protection.s2k.hash_alg = PGP_HASH_MD5;
 1050|  19.5k|            break;
 1051|  29.9k|        }
 1052|       |
 1053|       |        /* iv */
 1054|  29.1k|        if (sec_protection.s2k.usage &&
  ------------------
  |  Branch (1054:13): [True: 20.7k, False: 8.45k]
  ------------------
 1055|  20.7k|            (sec_protection.s2k.specifier != PGP_S2KS_EXPERIMENTAL)) {
  ------------------
  |  Branch (1055:13): [True: 20.2k, False: 532]
  ------------------
 1056|  20.2k|            size_t bl_size = pgp_block_size(sec_protection.symm_alg);
 1057|  20.2k|            if (!bl_size || !pkt.get(sec_protection.iv, bl_size)) {
  ------------------
  |  Branch (1057:17): [True: 966, False: 19.2k]
  |  Branch (1057:29): [True: 804, False: 18.4k]
  ------------------
 1058|  1.77k|                RNP_LOG("failed to read iv");
  ------------------
  |  |   76|  1.77k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.77k|    do {                                                                                 \
  |  |  |  |   69|  1.77k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.77k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.77k|            break;                                                                       \
  |  |  |  |   71|  1.77k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1059|  1.77k|                return RNP_ERROR_BAD_FORMAT;
 1060|  1.77k|            }
 1061|  20.2k|        }
 1062|       |
 1063|       |        /* v5 secret key fields length */
 1064|  27.4k|        if (version == PGP_V5) {
  ------------------
  |  Branch (1064:13): [True: 1.18k, False: 26.2k]
  ------------------
 1065|  1.18k|            if (!pkt.get(v5_sec_len)) {
  ------------------
  |  Branch (1065:17): [True: 241, False: 944]
  ------------------
 1066|    241|                RNP_LOG("failed to read v5 secret fields length");
  ------------------
  |  |   76|    241|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    241|    do {                                                                                 \
  |  |  |  |   69|    241|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 241, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    241|            break;                                                                       \
  |  |  |  |   71|    241|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1067|    241|                return RNP_ERROR_BAD_FORMAT;
 1068|    241|            }
 1069|    944|            if (v5_sec_len != pkt.left()) {
  ------------------
  |  Branch (1069:17): [True: 284, False: 660]
  ------------------
 1070|    284|                RNP_LOG("v5 secret fields length mismatch");
  ------------------
  |  |   76|    284|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    284|    do {                                                                                 \
  |  |  |  |   69|    284|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 284, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    284|            break;                                                                       \
  |  |  |  |   71|    284|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1071|    284|                return RNP_ERROR_BAD_FORMAT;
 1072|    284|            }
 1073|    944|        }
 1074|       |
 1075|       |        /* encrypted/cleartext secret MPIs are left */
 1076|  26.9k|        size_t sec_len = pkt.left();
 1077|  26.9k|        sec_data.resize(sec_len);
 1078|  26.9k|        if (sec_len && !pkt.get(sec_data.data(), sec_len)) {
  ------------------
  |  Branch (1078:13): [True: 24.6k, False: 2.29k]
  |  Branch (1078:24): [True: 0, False: 24.6k]
  ------------------
 1079|      0|            return RNP_ERROR_BAD_STATE;
 1080|      0|        }
 1081|  26.9k|    }
 1082|       |
 1083|  40.7k|    if (pkt.left()) {
  ------------------
  |  Branch (1083:9): [True: 246, False: 40.5k]
  ------------------
 1084|    246|        RNP_LOG("extra %zu bytes in key packet", pkt.left());
  ------------------
  |  |   76|    246|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    246|    do {                                                                                 \
  |  |  |  |   69|    246|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 246, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    246|            break;                                                                       \
  |  |  |  |   71|    246|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1085|    246|        return RNP_ERROR_BAD_FORMAT;
 1086|    246|    }
 1087|  40.5k|    return RNP_SUCCESS;
 1088|  40.7k|}

_ZN13pgp_key_pkt_tC2Ev:
   59|  67.1k|        : tag(PGP_PKT_RESERVED), version(PGP_VUNKNOWN), creation_time(0), alg(PGP_PKA_NOTHING),
   60|  67.1k|          v3_days(0), v5_pub_len(0), material(nullptr), sec_protection({}), v5_s2k_len(0),
   61|  67.1k|          v5_sec_len(0){};

_Z15get_packet_typeh:
   67|   770k|{
   68|   770k|    if (!(ptag & PGP_PTAG_ALWAYS_SET)) {
  ------------------
  |  |   47|   770k|#define PGP_PTAG_ALWAYS_SET 0x80
  ------------------
  |  Branch (68:9): [True: 0, False: 770k]
  ------------------
   69|      0|        return -1;
   70|      0|    }
   71|       |
   72|   770k|    if (ptag & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|   770k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (72:9): [True: 511k, False: 258k]
  ------------------
   73|   511k|        return (int) (ptag & PGP_PTAG_NF_CONTENT_TAG_MASK);
  ------------------
  |  |  137|   511k|#define PGP_PTAG_NF_CONTENT_TAG_MASK 0x3f
  ------------------
   74|   511k|    } else {
   75|   258k|        return (int) ((ptag & PGP_PTAG_OF_CONTENT_TAG_MASK) >> PGP_PTAG_OF_CONTENT_TAG_SHIFT);
  ------------------
  |  |   66|   258k|#define PGP_PTAG_OF_CONTENT_TAG_MASK 0x3c
  ------------------
                      return (int) ((ptag & PGP_PTAG_OF_CONTENT_TAG_MASK) >> PGP_PTAG_OF_CONTENT_TAG_SHIFT);
  ------------------
  |  |   74|   258k|#define PGP_PTAG_OF_CONTENT_TAG_SHIFT 2
  ------------------
   76|   258k|    }
   77|   770k|}
_Z15stream_pkt_typeR12pgp_source_t:
   81|  94.4k|{
   82|  94.4k|    if (src.eof()) {
  ------------------
  |  Branch (82:9): [True: 0, False: 94.4k]
  ------------------
   83|      0|        return 0;
   84|      0|    }
   85|  94.4k|    size_t hdrneed = 0;
   86|  94.4k|    if (!stream_pkt_hdr_len(src, hdrneed)) {
  ------------------
  |  Branch (86:9): [True: 96, False: 94.3k]
  ------------------
   87|     96|        return -1;
   88|     96|    }
   89|  94.3k|    uint8_t hdr[PGP_MAX_HEADER_SIZE];
   90|  94.3k|    if (!src.peek_eq(hdr, hdrneed)) {
  ------------------
  |  Branch (90:9): [True: 0, False: 94.3k]
  ------------------
   91|      0|        return -1;
   92|      0|    }
   93|  94.3k|    return get_packet_type(hdr[0]);
   94|  94.3k|}
_Z18stream_pkt_hdr_lenR12pgp_source_tRm:
   98|  1.09M|{
   99|  1.09M|    uint8_t buf[2];
  100|       |
  101|  1.09M|    if (!src.peek_eq(buf, 2) || !(buf[0] & PGP_PTAG_ALWAYS_SET)) {
  ------------------
  |  |   47|  1.08M|#define PGP_PTAG_ALWAYS_SET 0x80
  ------------------
  |  Branch (101:9): [True: 3.32k, False: 1.08M]
  |  Branch (101:33): [True: 3.10k, False: 1.08M]
  ------------------
  102|  6.42k|        return false;
  103|  6.42k|    }
  104|       |
  105|  1.08M|    if (buf[0] & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|  1.08M|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (105:9): [True: 728k, False: 355k]
  ------------------
  106|   728k|        if (buf[1] < 192) {
  ------------------
  |  Branch (106:13): [True: 662k, False: 65.8k]
  ------------------
  107|   662k|            hdrlen = 2;
  108|   662k|        } else if (buf[1] < 224) {
  ------------------
  |  Branch (108:20): [True: 40.8k, False: 24.9k]
  ------------------
  109|  40.8k|            hdrlen = 3;
  110|  40.8k|        } else if (buf[1] < 255) {
  ------------------
  |  Branch (110:20): [True: 23.1k, False: 1.78k]
  ------------------
  111|  23.1k|            hdrlen = 2;
  112|  23.1k|        } else {
  113|  1.78k|            hdrlen = 6;
  114|  1.78k|        }
  115|   728k|        return true;
  116|   728k|    }
  117|       |
  118|   355k|    switch (buf[0] & PGP_PTAG_OF_LENGTH_TYPE_MASK) {
  ------------------
  |  |   83|   355k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  119|   205k|    case PGP_PTAG_OLD_LEN_1:
  ------------------
  |  Branch (119:5): [True: 205k, False: 149k]
  ------------------
  120|   205k|        hdrlen = 2;
  121|   205k|        return true;
  122|  68.0k|    case PGP_PTAG_OLD_LEN_2:
  ------------------
  |  Branch (122:5): [True: 68.0k, False: 286k]
  ------------------
  123|  68.0k|        hdrlen = 3;
  124|  68.0k|        return true;
  125|  11.2k|    case PGP_PTAG_OLD_LEN_4:
  ------------------
  |  Branch (125:5): [True: 11.2k, False: 343k]
  ------------------
  126|  11.2k|        hdrlen = 5;
  127|  11.2k|        return true;
  128|  69.8k|    case PGP_PTAG_OLD_LEN_INDETERMINATE:
  ------------------
  |  Branch (128:5): [True: 69.8k, False: 285k]
  ------------------
  129|  69.8k|        hdrlen = 1;
  130|  69.8k|        return true;
  131|      0|    default:
  ------------------
  |  Branch (131:5): [True: 0, False: 355k]
  ------------------
  132|      0|        return false;
  133|   355k|    }
  134|   355k|}
_Z19stream_read_pkt_lenR12pgp_source_tPm:
  176|   312k|{
  177|   312k|    uint8_t buf[6] = {};
  178|   312k|    size_t  read = 0;
  179|       |
  180|   312k|    if (!stream_pkt_hdr_len(src, read)) {
  ------------------
  |  Branch (180:9): [True: 0, False: 312k]
  ------------------
  181|      0|        return false;
  182|      0|    }
  183|       |
  184|   312k|    if (!src.read_eq(buf, read)) {
  ------------------
  |  Branch (184:9): [True: 0, False: 312k]
  ------------------
  185|      0|        return false;
  186|      0|    }
  187|       |
  188|   312k|    return get_pkt_len(buf, pktlen);
  189|   312k|}
_Z29stream_read_partial_chunk_lenP12pgp_source_tPmPb:
  193|  23.3M|{
  194|  23.3M|    uint8_t hdr[5] = {};
  195|  23.3M|    size_t  read = 0;
  196|       |
  197|  23.3M|    if (!src->read(hdr, 1, &read)) {
  ------------------
  |  Branch (197:9): [True: 19, False: 23.3M]
  ------------------
  198|     19|        RNP_LOG("failed to read header");
  ------------------
  |  |   76|     19|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     19|    do {                                                                                 \
  |  |  |  |   69|     19|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 19, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     19|            break;                                                                       \
  |  |  |  |   71|     19|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  199|     19|        return false;
  200|     19|    }
  201|  23.3M|    if (read < 1) {
  ------------------
  |  Branch (201:9): [True: 143, False: 23.3M]
  ------------------
  202|    143|        RNP_LOG("wrong eof");
  ------------------
  |  |   76|    143|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    143|    do {                                                                                 \
  |  |  |  |   69|    143|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 143, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    143|            break;                                                                       \
  |  |  |  |   71|    143|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  203|    143|        return false;
  204|    143|    }
  205|       |
  206|  23.3M|    *last = true;
  207|       |    // partial length
  208|  23.3M|    if ((hdr[0] >= 224) && (hdr[0] < 255)) {
  ------------------
  |  Branch (208:9): [True: 23.3M, False: 8.50k]
  |  Branch (208:28): [True: 23.3M, False: 658]
  ------------------
  209|  23.3M|        *last = false;
  210|  23.3M|        *clen = get_partial_pkt_len(hdr[0]);
  211|  23.3M|        return true;
  212|  23.3M|    }
  213|       |    // 1-byte length
  214|  9.16k|    if (hdr[0] < 192) {
  ------------------
  |  Branch (214:9): [True: 7.45k, False: 1.70k]
  ------------------
  215|  7.45k|        *clen = hdr[0];
  216|  7.45k|        return true;
  217|  7.45k|    }
  218|       |    // 2-byte length
  219|  1.70k|    if (hdr[0] < 224) {
  ------------------
  |  Branch (219:9): [True: 1.05k, False: 658]
  ------------------
  220|  1.05k|        if (!src->read_eq(&hdr[1], 1)) {
  ------------------
  |  Branch (220:13): [True: 80, False: 971]
  ------------------
  221|     80|            RNP_LOG("wrong 2-byte length");
  ------------------
  |  |   76|     80|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     80|    do {                                                                                 \
  |  |  |  |   69|     80|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 80, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     80|            break;                                                                       \
  |  |  |  |   71|     80|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  222|     80|            return false;
  223|     80|        }
  224|    971|        *clen = ((size_t)(hdr[0] - 192) << 8) + (size_t) hdr[1] + 192;
  225|    971|        return true;
  226|  1.05k|    }
  227|       |    // 4-byte length
  228|    658|    if (!src->read_eq(&hdr[1], 4)) {
  ------------------
  |  Branch (228:9): [True: 79, False: 579]
  ------------------
  229|     79|        RNP_LOG("wrong 4-byte length");
  ------------------
  |  |   76|     79|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     79|    do {                                                                                 \
  |  |  |  |   69|     79|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 79, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     79|            break;                                                                       \
  |  |  |  |   71|     79|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  230|     79|        return false;
  231|     79|    }
  232|    579|    *clen = ((size_t) hdr[1] << 24) | ((size_t) hdr[2] << 16) | ((size_t) hdr[3] << 8) |
  233|    579|            (size_t) hdr[4];
  234|    579|    return true;
  235|    658|}
_Z32stream_old_indeterminate_pkt_lenP12pgp_source_t:
  239|   479k|{
  240|   479k|    uint8_t ptag = 0;
  241|   479k|    if (!src->peek_eq(&ptag, 1)) {
  ------------------
  |  Branch (241:9): [True: 43, False: 479k]
  ------------------
  242|     43|        return false;
  243|     43|    }
  244|   479k|    return !(ptag & PGP_PTAG_NEW_FORMAT) &&
  ------------------
  |  |   56|   479k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (244:12): [True: 133k, False: 345k]
  ------------------
  245|   133k|           ((ptag & PGP_PTAG_OF_LENGTH_TYPE_MASK) == PGP_PTAG_OLD_LEN_INDETERMINATE);
  ------------------
  |  |   83|   133k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  |  Branch (245:12): [True: 35.1k, False: 98.3k]
  ------------------
  246|   479k|}
_Z22stream_partial_pkt_lenP12pgp_source_t:
  250|   501k|{
  251|   501k|    uint8_t hdr[2] = {};
  252|   501k|    if (!src->peek_eq(hdr, 2)) {
  ------------------
  |  Branch (252:9): [True: 43, False: 501k]
  ------------------
  253|     43|        return false;
  254|     43|    }
  255|   501k|    return (hdr[0] & PGP_PTAG_NEW_FORMAT) && (hdr[1] >= 224) && (hdr[1] < 255);
  ------------------
  |  |   56|   501k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (255:12): [True: 368k, False: 133k]
  |  Branch (255:46): [True: 27.1k, False: 340k]
  |  Branch (255:65): [True: 26.2k, False: 847]
  ------------------
  256|   501k|}
_Z19get_partial_pkt_lenh:
  260|  23.3M|{
  261|  23.3M|    return 1 << (blen & 0x1f);
  262|  23.3M|}
_Z22stream_peek_packet_hdrP12pgp_source_tP16pgp_packet_hdr_t:
  266|   369k|{
  267|   369k|    size_t hlen = 0;
  268|   369k|    memset(hdr, 0, sizeof(*hdr));
  269|   369k|    if (!stream_pkt_hdr_len(*src, hlen)) {
  ------------------
  |  Branch (269:9): [True: 6.32k, False: 363k]
  ------------------
  270|  6.32k|        uint8_t hdr2[2] = {0};
  271|  6.32k|        if (!src->peek_eq(hdr2, 2)) {
  ------------------
  |  Branch (271:13): [True: 3.22k, False: 3.10k]
  ------------------
  272|  3.22k|            RNP_LOG("pkt header read failed");
  ------------------
  |  |   76|  3.22k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.22k|    do {                                                                                 \
  |  |  |  |   69|  3.22k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.22k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.22k|            break;                                                                       \
  |  |  |  |   71|  3.22k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|  3.22k|            return RNP_ERROR_READ;
  274|  3.22k|        }
  275|       |
  276|  3.10k|        RNP_LOG("bad packet header: 0x%02x%02x", hdr2[0], hdr2[1]);
  ------------------
  |  |   76|  3.10k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.10k|    do {                                                                                 \
  |  |  |  |   69|  3.10k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.10k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.10k|            break;                                                                       \
  |  |  |  |   71|  3.10k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  277|  3.10k|        return RNP_ERROR_BAD_FORMAT;
  278|  6.32k|    }
  279|       |
  280|   363k|    if (!src->peek_eq(hdr->hdr, hlen)) {
  ------------------
  |  Branch (280:9): [True: 154, False: 363k]
  ------------------
  281|    154|        RNP_LOG("failed to read pkt header");
  ------------------
  |  |   76|    154|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    154|    do {                                                                                 \
  |  |  |  |   69|    154|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 154, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    154|            break;                                                                       \
  |  |  |  |   71|    154|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  282|    154|        return RNP_ERROR_READ;
  283|    154|    }
  284|       |
  285|   363k|    hdr->hdr_len = hlen;
  286|   363k|    hdr->tag = (pgp_pkt_type_t) get_packet_type(hdr->hdr[0]);
  287|       |
  288|   363k|    if (stream_partial_pkt_len(src)) {
  ------------------
  |  Branch (288:9): [True: 22.1k, False: 341k]
  ------------------
  289|  22.1k|        hdr->partial = true;
  290|   341k|    } else if (stream_old_indeterminate_pkt_len(src)) {
  ------------------
  |  Branch (290:16): [True: 34.9k, False: 306k]
  ------------------
  291|  34.9k|        hdr->indeterminate = true;
  292|   306k|    } else {
  293|   306k|        (void) get_pkt_len(hdr->hdr, &hdr->pkt_len);
  294|   306k|    }
  295|       |
  296|   363k|    return RNP_SUCCESS;
  297|   363k|}
_Z18stream_read_packetP12pgp_source_tP10pgp_dest_t:
  345|   138k|{
  346|   138k|    if (stream_old_indeterminate_pkt_len(src)) {
  ------------------
  |  Branch (346:9): [True: 205, False: 138k]
  ------------------
  347|    205|        return dst_write_src(src, dst, PGP_MAX_OLD_LEN_INDETERMINATE_PKT_SIZE);
  ------------------
  |  |   42|    205|#define PGP_MAX_OLD_LEN_INDETERMINATE_PKT_SIZE 0x40000000
  ------------------
  348|    205|    }
  349|       |
  350|   138k|    if (stream_partial_pkt_len(src)) {
  ------------------
  |  Branch (350:9): [True: 4.13k, False: 133k]
  ------------------
  351|  4.13k|        return stream_read_packet_partial(src, dst);
  352|  4.13k|    }
  353|       |
  354|   133k|    try {
  355|   133k|        pgp_packet_body_t body(PGP_PKT_RESERVED);
  356|   133k|        rnp_result_t      ret = body.read(*src);
  357|   133k|        if (dst) {
  ------------------
  |  Branch (357:13): [True: 816, False: 133k]
  ------------------
  358|    816|            body.write(*dst, false);
  359|    816|        }
  360|   133k|        return ret;
  361|   133k|    } catch (const std::exception &e) {
  362|      0|        RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  363|      0|        return RNP_ERROR_GENERIC;
  364|      0|    }
  365|   133k|}
_Z18stream_skip_packetP12pgp_source_t:
  369|   137k|{
  370|       |    return stream_read_packet(src, NULL);
  371|   137k|}
_Z19stream_parse_markerR12pgp_source_t:
  375|  3.26k|{
  376|  3.26k|    try {
  377|  3.26k|        pgp_packet_body_t pkt(PGP_PKT_MARKER);
  378|  3.26k|        rnp_result_t      res = pkt.read(src);
  379|  3.26k|        if (res) {
  ------------------
  |  Branch (379:13): [True: 1.08k, False: 2.18k]
  ------------------
  380|  1.08k|            return res;
  381|  1.08k|        }
  382|  2.18k|        if ((pkt.size() != PGP_MARKER_LEN) ||
  ------------------
  |  |  104|  2.18k|#define PGP_MARKER_LEN 3
  ------------------
  |  Branch (382:13): [True: 1.50k, False: 671]
  ------------------
  383|  1.86k|            memcmp(pkt.data(), PGP_MARKER_CONTENTS, PGP_MARKER_LEN)) {
  ------------------
  |  |  103|    671|#define PGP_MARKER_CONTENTS "PGP"
  ------------------
                          memcmp(pkt.data(), PGP_MARKER_CONTENTS, PGP_MARKER_LEN)) {
  ------------------
  |  |  104|    671|#define PGP_MARKER_LEN 3
  ------------------
  |  Branch (383:13): [True: 351, False: 320]
  ------------------
  384|  1.86k|            return RNP_ERROR_BAD_FORMAT;
  385|  1.86k|        }
  386|    320|        return RNP_SUCCESS;
  387|  2.18k|    } catch (const std::exception &e) {
  388|      0|        RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  389|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  390|      0|    }
  391|  3.26k|}
_Z10is_key_pkti:
  395|  67.1k|{
  396|  67.1k|    switch (tag) {
  397|  10.5k|    case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (397:5): [True: 10.5k, False: 56.5k]
  ------------------
  398|  23.6k|    case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (398:5): [True: 13.1k, False: 53.9k]
  ------------------
  399|  47.7k|    case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (399:5): [True: 24.1k, False: 42.9k]
  ------------------
  400|  67.0k|    case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (400:5): [True: 19.2k, False: 47.8k]
  ------------------
  401|  67.0k|        return true;
  402|     83|    default:
  ------------------
  |  Branch (402:5): [True: 83, False: 67.0k]
  ------------------
  403|     83|        return false;
  404|  67.1k|    }
  405|  67.1k|}
_Z17is_public_key_pkti:
  421|  11.7k|{
  422|  11.7k|    switch (tag) {
  423|    656|    case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (423:5): [True: 656, False: 11.1k]
  ------------------
  424|    791|    case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (424:5): [True: 135, False: 11.6k]
  ------------------
  425|    791|        return true;
  426|  10.9k|    default:
  ------------------
  |  Branch (426:5): [True: 10.9k, False: 791]
  ------------------
  427|  10.9k|        return false;
  428|  11.7k|    }
  429|  11.7k|}
_Z17is_secret_key_pkti:
  433|   398k|{
  434|   398k|    switch (tag) {
  435|  62.3k|    case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (435:5): [True: 62.3k, False: 335k]
  ------------------
  436|   101k|    case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (436:5): [True: 38.6k, False: 359k]
  ------------------
  437|   101k|        return true;
  438|   297k|    default:
  ------------------
  |  Branch (438:5): [True: 297k, False: 101k]
  ------------------
  439|   297k|        return false;
  440|   398k|    }
  441|   398k|}
_Z14is_rsa_key_alg16pgp_pubkey_alg_t:
  445|  7.22k|{
  446|  7.22k|    switch (alg) {
  447|  3.55k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (447:5): [True: 3.55k, False: 3.66k]
  ------------------
  448|  5.46k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (448:5): [True: 1.90k, False: 5.31k]
  ------------------
  449|  6.78k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (449:5): [True: 1.32k, False: 5.90k]
  ------------------
  450|  6.78k|        return true;
  451|    440|    default:
  ------------------
  |  Branch (451:5): [True: 440, False: 6.78k]
  ------------------
  452|    440|        return false;
  453|  7.22k|    }
  454|  7.22k|}
_ZN17pgp_packet_body_tC2E14pgp_pkt_type_t:
  457|   312k|{
  458|   312k|    data_.reserve(16);
  459|   312k|    tag_ = tag;
  460|   312k|    secure_ = is_secret_key_pkt(tag);
  461|   312k|}
_ZN17pgp_packet_body_tC2EPKhm:
  464|  68.0k|{
  465|  68.0k|    data_.assign(data, data + len);
  466|  68.0k|    tag_ = PGP_PKT_RESERVED;
  467|  68.0k|    secure_ = false;
  468|  68.0k|}
_ZN17pgp_packet_body_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  471|  64.0k|    : pgp_packet_body_t(data.data(), data.size())
  472|  64.0k|{
  473|  64.0k|}
_ZN17pgp_packet_body_tD2Ev:
  476|   381k|{
  477|   381k|    if (secure_) {
  ------------------
  |  Branch (477:9): [True: 43.3k, False: 337k]
  ------------------
  478|  43.3k|        secure_clear(data_.data(), data_.size());
  479|  43.3k|    }
  480|   381k|}
_ZN17pgp_packet_body_t4dataEv:
  484|   111k|{
  485|   111k|    return data_.data();
  486|   111k|}
_ZN17pgp_packet_body_t3curEv:
  490|  89.5k|{
  491|  89.5k|    return data_.data() + pos_;
  492|  89.5k|}
_ZNK17pgp_packet_body_t4sizeEv:
  496|   122k|{
  497|   122k|    return data_.size();
  498|   122k|}
_ZNK17pgp_packet_body_t4leftEv:
  502|   290k|{
  503|   290k|    return data_.size() - pos_;
  504|   290k|}
_ZN17pgp_packet_body_t4skipEm:
  508|  25.6k|{
  509|  25.6k|    pos_ += bt;
  510|  25.6k|}
_ZN17pgp_packet_body_t9skip_backEm:
  514|  30.8k|{
  515|  30.8k|    pos_ = bt > pos_ ? 0 : pos_ - bt;
  ------------------
  |  Branch (515:12): [True: 0, False: 30.8k]
  ------------------
  516|  30.8k|}
_ZN17pgp_packet_body_t3getERh:
  520|   327k|{
  521|   327k|    if (pos_ >= data_.size()) {
  ------------------
  |  Branch (521:9): [True: 7.96k, False: 319k]
  ------------------
  522|  7.96k|        return false;
  523|  7.96k|    }
  524|   319k|    val = data_[pos_++];
  525|   319k|    return true;
  526|   327k|}
_ZN17pgp_packet_body_t3getERt:
  530|   193k|{
  531|   193k|    if (pos_ + 2 > data_.size()) {
  ------------------
  |  Branch (531:9): [True: 3.37k, False: 190k]
  ------------------
  532|  3.37k|        return false;
  533|  3.37k|    }
  534|   190k|    val = read_uint16(data_.data() + pos_);
  535|   190k|    pos_ += 2;
  536|   190k|    return true;
  537|   193k|}
_ZN17pgp_packet_body_t3getERj:
  541|  80.9k|{
  542|  80.9k|    if (pos_ + 4 > data_.size()) {
  ------------------
  |  Branch (542:9): [True: 2.15k, False: 78.8k]
  ------------------
  543|  2.15k|        return false;
  544|  2.15k|    }
  545|  78.8k|    val = read_uint32(data_.data() + pos_);
  546|  78.8k|    pos_ += 4;
  547|  78.8k|    return true;
  548|  80.9k|}
_ZN17pgp_packet_body_t3getEPhm:
  552|   344k|{
  553|   344k|    if (pos_ + len > data_.size()) {
  ------------------
  |  Branch (553:9): [True: 12.5k, False: 331k]
  ------------------
  554|  12.5k|        return false;
  555|  12.5k|    }
  556|   331k|    memcpy(val, data_.data() + pos_, len);
  557|   331k|    pos_ += len;
  558|   331k|    return true;
  559|   344k|}
_ZN17pgp_packet_body_t3getERNSt3__16vectorIhNS0_9allocatorIhEEEEm:
  563|  39.0k|{
  564|  39.0k|    if (pos_ + len > data_.size()) {
  ------------------
  |  Branch (564:9): [True: 2.81k, False: 36.2k]
  ------------------
  565|  2.81k|        return false;
  566|  2.81k|    }
  567|  36.2k|    val.assign(data_.data() + pos_, data_.data() + pos_ + len);
  568|  36.2k|    pos_ += len;
  569|  36.2k|    return true;
  570|  39.0k|}
_ZN17pgp_packet_body_t3getERNSt3__15arrayIhLm8EEE:
  574|  9.52k|{
  575|  9.52k|    static_assert(std::tuple_size<pgp::KeyID>::value == PGP_KEY_ID_SIZE,
  576|  9.52k|                  "pgp::KeyID size mismatch");
  577|  9.52k|    return get(val.data(), val.size());
  578|  9.52k|}
_ZN17pgp_packet_body_t3getERN3pgp3mpiE:
  582|   136k|{
  583|   136k|    uint16_t bits = 0;
  584|   136k|    if (!get(bits)) {
  ------------------
  |  Branch (584:9): [True: 2.76k, False: 133k]
  ------------------
  585|  2.76k|        return false;
  586|  2.76k|    }
  587|   133k|    size_t len = (bits + 7) >> 3;
  588|   133k|    if (len > PGP_MPINT_SIZE) {
  ------------------
  |  |   36|   133k|#define PGP_MPINT_SIZE (PGP_MPINT_BITS >> 3)
  |  |  ------------------
  |  |  |  |   35|   133k|#define PGP_MPINT_BITS (16384)
  |  |  ------------------
  ------------------
  |  Branch (588:9): [True: 1.83k, False: 131k]
  ------------------
  589|  1.83k|        RNP_LOG("too large mpi");
  ------------------
  |  |   76|  1.83k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.83k|    do {                                                                                 \
  |  |  |  |   69|  1.83k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.83k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.83k|            break;                                                                       \
  |  |  |  |   71|  1.83k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  590|  1.83k|        return false;
  591|  1.83k|    }
  592|   131k|    if (!len) {
  ------------------
  |  Branch (592:9): [True: 474, False: 130k]
  ------------------
  593|    474|        RNP_LOG("0 mpi");
  ------------------
  |  |   76|    474|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    474|    do {                                                                                 \
  |  |  |  |   69|    474|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 474, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    474|            break;                                                                       \
  |  |  |  |   71|    474|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  594|    474|        return false;
  595|    474|    }
  596|   130k|    val.resize(len);
  597|   130k|    if (!get(val.data(), len)) {
  ------------------
  |  Branch (597:9): [True: 3.13k, False: 127k]
  ------------------
  598|  3.13k|        RNP_LOG("failed to read mpi body");
  ------------------
  |  |   76|  3.13k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.13k|    do {                                                                                 \
  |  |  |  |   69|  3.13k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.13k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.13k|            break;                                                                       \
  |  |  |  |   71|  3.13k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  599|  3.13k|        return false;
  600|  3.13k|    }
  601|       |    /* check the mpi bit count */
  602|   127k|    size_t mbits = val.bits();
  603|   127k|    if (mbits != bits) {
  ------------------
  |  Branch (603:9): [True: 90.3k, False: 37.4k]
  ------------------
  604|  90.3k|        RNP_LOG(
  ------------------
  |  |   76|  90.3k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  90.3k|    do {                                                                                 \
  |  |  |  |   69|  90.3k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 90.3k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  90.3k|            break;                                                                       \
  |  |  |  |   71|  90.3k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  605|  90.3k|          "Warning! Wrong mpi bit count: got %" PRIu16 ", but actual is %zu", bits, mbits);
  606|  90.3k|    }
  607|   127k|    return true;
  608|   130k|}
_ZN17pgp_packet_body_t3getER11pgp_curve_t:
  612|  9.35k|{
  613|  9.35k|    uint8_t oidlen = 0;
  614|  9.35k|    if (!get(oidlen)) {
  ------------------
  |  Branch (614:9): [True: 425, False: 8.93k]
  ------------------
  615|    425|        return false;
  616|    425|    }
  617|  8.93k|    if (!oidlen || (oidlen == 0xff)) {
  ------------------
  |  Branch (617:9): [True: 279, False: 8.65k]
  |  Branch (617:20): [True: 210, False: 8.44k]
  ------------------
  618|    489|        RNP_LOG("unsupported curve oid len: %" PRIu8, oidlen);
  ------------------
  |  |   76|    489|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    489|    do {                                                                                 \
  |  |  |  |   69|    489|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 489, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    489|            break;                                                                       \
  |  |  |  |   71|    489|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  619|    489|        return false;
  620|    489|    }
  621|  8.44k|    std::vector<uint8_t> oid(oidlen, 0);
  622|  8.44k|    if (!get(oid, oidlen)) {
  ------------------
  |  Branch (622:9): [True: 879, False: 7.56k]
  ------------------
  623|    879|        return false;
  624|    879|    }
  625|  7.56k|    pgp_curve_t res = pgp::ec::Curve::by_OID(oid);
  626|  7.56k|    if (res == PGP_CURVE_MAX) {
  ------------------
  |  Branch (626:9): [True: 1.56k, False: 5.99k]
  ------------------
  627|  1.56k|        RNP_LOG("unsupported curve");
  ------------------
  |  |   76|  1.56k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.56k|    do {                                                                                 \
  |  |  |  |   69|  1.56k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.56k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.56k|            break;                                                                       \
  |  |  |  |   71|  1.56k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  628|  1.56k|        return false;
  629|  1.56k|    }
  630|  5.99k|    val = res;
  631|  5.99k|    return true;
  632|  7.56k|}
_ZN17pgp_packet_body_t3getER9pgp_s2k_t:
  636|  12.0k|{
  637|  12.0k|    uint8_t spec = 0, halg = 0;
  638|  12.0k|    if (!get(spec) || !get(halg)) {
  ------------------
  |  Branch (638:9): [True: 676, False: 11.3k]
  |  Branch (638:23): [True: 276, False: 11.0k]
  ------------------
  639|    952|        return false;
  640|    952|    }
  641|  11.0k|    s2k.specifier = (pgp_s2k_specifier_t) spec;
  642|  11.0k|    s2k.hash_alg = (pgp_hash_alg_t) halg;
  643|       |
  644|  11.0k|    switch (s2k.specifier) {
  645|  2.76k|    case PGP_S2KS_SIMPLE:
  ------------------
  |  Branch (645:5): [True: 2.76k, False: 8.30k]
  ------------------
  646|  2.76k|        return true;
  647|  1.11k|    case PGP_S2KS_SALTED:
  ------------------
  |  Branch (647:5): [True: 1.11k, False: 9.95k]
  ------------------
  648|  1.11k|        return get(s2k.salt, PGP_SALT_SIZE);
  ------------------
  |  |   92|  1.11k|#define PGP_SALT_SIZE 8
  ------------------
  649|  1.09k|    case PGP_S2KS_ITERATED_AND_SALTED: {
  ------------------
  |  Branch (649:5): [True: 1.09k, False: 9.97k]
  ------------------
  650|  1.09k|        uint8_t iter = 0;
  651|  1.09k|        if (!get(s2k.salt, PGP_SALT_SIZE) || !get(iter)) {
  ------------------
  |  |   92|  1.09k|#define PGP_SALT_SIZE 8
  ------------------
  |  Branch (651:13): [True: 266, False: 833]
  |  Branch (651:46): [True: 201, False: 632]
  ------------------
  652|    467|            return false;
  653|    467|        }
  654|    632|        s2k.iterations = iter;
  655|    632|        return true;
  656|  1.09k|    }
  657|  5.52k|    case PGP_S2KS_EXPERIMENTAL: {
  ------------------
  |  Branch (657:5): [True: 5.52k, False: 5.54k]
  ------------------
  658|  5.52k|        try {
  659|  5.52k|            s2k.experimental = {data_.begin() + pos_, data_.end()};
  660|  5.52k|        } catch (const std::exception &e) {
  661|      0|            RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  662|      0|            return false;
  663|      0|        }
  664|  5.52k|        uint8_t gnu[3] = {0};
  665|  5.52k|        if (!get(gnu, 3) || memcmp(gnu, "GNU", 3)) {
  ------------------
  |  Branch (665:13): [True: 1.25k, False: 4.27k]
  |  Branch (665:29): [True: 1.23k, False: 3.04k]
  ------------------
  666|  2.48k|            RNP_LOG("Unknown experimental s2k. Skipping.");
  ------------------
  |  |   76|  2.48k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.48k|    do {                                                                                 \
  |  |  |  |   69|  2.48k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.48k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.48k|            break;                                                                       \
  |  |  |  |   71|  2.48k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  667|  2.48k|            pos_ = data_.size();
  668|  2.48k|            s2k.gpg_ext_num = PGP_S2K_GPG_NONE;
  669|  2.48k|            return true;
  670|  2.48k|        }
  671|  3.04k|        uint8_t ext_num = 0;
  672|  3.04k|        if (!get(ext_num)) {
  ------------------
  |  Branch (672:13): [True: 88, False: 2.95k]
  ------------------
  673|     88|            return false;
  674|     88|        }
  675|  2.95k|        if ((ext_num != PGP_S2K_GPG_NO_SECRET) && (ext_num != PGP_S2K_GPG_SMARTCARD)) {
  ------------------
  |  Branch (675:13): [True: 2.41k, False: 546]
  |  Branch (675:51): [True: 253, False: 2.16k]
  ------------------
  676|    253|            RNP_LOG("Unsupported gpg extension num: %" PRIu8 ", skipping", ext_num);
  ------------------
  |  |   76|    253|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    253|    do {                                                                                 \
  |  |  |  |   69|    253|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 253, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    253|            break;                                                                       \
  |  |  |  |   71|    253|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  677|    253|            pos_ = data_.size();
  678|    253|            s2k.gpg_ext_num = PGP_S2K_GPG_NONE;
  679|    253|            return true;
  680|    253|        }
  681|  2.70k|        s2k.gpg_ext_num = (pgp_s2k_gpg_extension_t) ext_num;
  682|  2.70k|        if (s2k.gpg_ext_num == PGP_S2K_GPG_NO_SECRET) {
  ------------------
  |  Branch (682:13): [True: 546, False: 2.16k]
  ------------------
  683|    546|            return true;
  684|    546|        }
  685|  2.16k|        if (!get(s2k.gpg_serial_len)) {
  ------------------
  |  Branch (685:13): [True: 94, False: 2.06k]
  ------------------
  686|     94|            RNP_LOG("Failed to get GPG serial len");
  ------------------
  |  |   76|     94|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     94|    do {                                                                                 \
  |  |  |  |   69|     94|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 94, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     94|            break;                                                                       \
  |  |  |  |   71|     94|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  687|     94|            return false;
  688|     94|        }
  689|  2.06k|        size_t len = s2k.gpg_serial_len;
  690|  2.06k|        if (s2k.gpg_serial_len > 16) {
  ------------------
  |  Branch (690:13): [True: 700, False: 1.36k]
  ------------------
  691|    700|            RNP_LOG("Warning: gpg_serial_len is %d", (int) len);
  ------------------
  |  |   76|    700|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    700|    do {                                                                                 \
  |  |  |  |   69|    700|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 700, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    700|            break;                                                                       \
  |  |  |  |   71|    700|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  692|    700|            len = 16;
  693|    700|        }
  694|  2.06k|        if (!get(s2k.gpg_serial, len)) {
  ------------------
  |  Branch (694:13): [True: 236, False: 1.83k]
  ------------------
  695|    236|            RNP_LOG("Failed to get GPG serial");
  ------------------
  |  |   76|    236|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    236|    do {                                                                                 \
  |  |  |  |   69|    236|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 236, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    236|            break;                                                                       \
  |  |  |  |   71|    236|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  696|    236|            return false;
  697|    236|        }
  698|  1.83k|        return true;
  699|  2.06k|    }
  700|    564|    default:
  ------------------
  |  Branch (700:5): [True: 564, False: 10.5k]
  ------------------
  701|    564|        RNP_LOG("unknown s2k specifier: %d", (int) s2k.specifier);
  ------------------
  |  |   76|    564|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    564|    do {                                                                                 \
  |  |  |  |   69|    564|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 564, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    564|            break;                                                                       \
  |  |  |  |   71|    564|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  702|    564|        return false;
  703|  11.0k|    }
  704|  11.0k|}
_ZN17pgp_packet_body_t4readER12pgp_source_t:
  864|   312k|{
  865|       |    /* Make sure we have enough data for packet header */
  866|   312k|    if (!src.peek_eq(hdr_, 2)) {
  ------------------
  |  Branch (866:9): [True: 52, False: 312k]
  ------------------
  867|     52|        return RNP_ERROR_READ;
  868|     52|    }
  869|       |
  870|       |    /* Read the packet header and length */
  871|   312k|    size_t len = 0;
  872|   312k|    if (!stream_pkt_hdr_len(src, len)) {
  ------------------
  |  Branch (872:9): [True: 0, False: 312k]
  ------------------
  873|      0|        return RNP_ERROR_BAD_FORMAT;
  874|      0|    }
  875|   312k|    if (!src.peek_eq(hdr_, len)) {
  ------------------
  |  Branch (875:9): [True: 0, False: 312k]
  ------------------
  876|      0|        return RNP_ERROR_READ;
  877|      0|    }
  878|   312k|    hdr_len_ = len;
  879|       |
  880|   312k|    int ptag = get_packet_type(hdr_[0]);
  881|   312k|    if ((ptag < 0) || ((tag_ != PGP_PKT_RESERVED) && (tag_ != ptag))) {
  ------------------
  |  Branch (881:9): [True: 0, False: 312k]
  |  Branch (881:24): [True: 151k, False: 161k]
  |  Branch (881:54): [True: 0, False: 151k]
  ------------------
  882|      0|        RNP_LOG("tag mismatch: %d vs %d", (int) tag_, ptag);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  883|      0|        return RNP_ERROR_BAD_FORMAT;
  884|      0|    }
  885|   312k|    tag_ = (pgp_pkt_type_t) ptag;
  886|       |
  887|   312k|    if (!stream_read_pkt_len(src, &len)) {
  ------------------
  |  Branch (887:9): [True: 16.6k, False: 296k]
  ------------------
  888|  16.6k|        return RNP_ERROR_READ;
  889|  16.6k|    }
  890|       |
  891|       |    /* early exit for the empty packet */
  892|   296k|    if (!len) {
  ------------------
  |  Branch (892:9): [True: 113k, False: 182k]
  ------------------
  893|   113k|        return RNP_SUCCESS;
  894|   113k|    }
  895|       |
  896|   182k|    if (len > PGP_MAX_PKT_SIZE) {
  ------------------
  |  |   39|   182k|#define PGP_MAX_PKT_SIZE 0x100000
  ------------------
  |  Branch (896:9): [True: 3.15k, False: 179k]
  ------------------
  897|  3.15k|        RNP_LOG("too large packet");
  ------------------
  |  |   76|  3.15k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.15k|    do {                                                                                 \
  |  |  |  |   69|  3.15k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.15k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.15k|            break;                                                                       \
  |  |  |  |   71|  3.15k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  898|  3.15k|        return RNP_ERROR_BAD_FORMAT;
  899|  3.15k|    }
  900|       |
  901|       |    /* Read the packet contents */
  902|   179k|    try {
  903|   179k|        data_.resize(len);
  904|   179k|    } catch (const std::exception &e) {
  905|      0|        RNP_LOG("malloc of %d bytes failed, %s", (int) len, e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  906|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  907|      0|    }
  908|       |
  909|   179k|    size_t read = 0;
  910|   179k|    if (!src.read(data_.data(), len, &read) || (read != len)) {
  ------------------
  |  Branch (910:9): [True: 204, False: 179k]
  |  Branch (910:48): [True: 4.17k, False: 175k]
  ------------------
  911|  4.37k|        RNP_LOG("read %d instead of %d", (int) read, (int) len);
  ------------------
  |  |   76|  4.37k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  4.37k|    do {                                                                                 \
  |  |  |  |   69|  4.37k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 4.37k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  4.37k|            break;                                                                       \
  |  |  |  |   71|  4.37k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  912|  4.37k|        return RNP_ERROR_READ;
  913|  4.37k|    }
  914|   175k|    pos_ = 0;
  915|   175k|    return RNP_SUCCESS;
  916|   179k|}
_ZN17pgp_packet_body_t5writeER10pgp_dest_tb:
  920|    816|{
  921|    816|    if (hdr) {
  ------------------
  |  Branch (921:9): [True: 0, False: 816]
  ------------------
  922|      0|        uint8_t hdrbt[6] = {
  923|      0|          (uint8_t)(tag_ | PGP_PTAG_ALWAYS_SET | PGP_PTAG_NEW_FORMAT), 0, 0, 0, 0, 0};
  ------------------
  |  |   47|      0|#define PGP_PTAG_ALWAYS_SET 0x80
  ------------------
                        (uint8_t)(tag_ | PGP_PTAG_ALWAYS_SET | PGP_PTAG_NEW_FORMAT), 0, 0, 0, 0, 0};
  ------------------
  |  |   56|      0|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  924|      0|        size_t hlen = 1 + write_packet_len(&hdrbt[1], data_.size());
  925|      0|        dst_write(&dst, hdrbt, hlen);
  926|      0|    }
  927|    816|    dst_write(&dst, data_.data(), data_.size());
  928|    816|}
_ZN16pgp_sk_sesskey_t5parseER12pgp_source_t:
  978|  14.6k|{
  979|  14.6k|    pgp_packet_body_t pkt(PGP_PKT_SK_SESSION_KEY);
  980|  14.6k|    rnp_result_t      res = pkt.read(src);
  981|  14.6k|    if (res) {
  ------------------
  |  Branch (981:9): [True: 2.44k, False: 12.2k]
  ------------------
  982|  2.44k|        return res;
  983|  2.44k|    }
  984|       |
  985|       |    /* version */
  986|  12.2k|    uint8_t bt;
  987|  12.2k|    if (!pkt.get(bt) || ((bt != PGP_SKSK_V4) && (bt != PGP_SKSK_V5))) {
  ------------------
  |  Branch (987:9): [True: 350, False: 11.8k]
  |  Branch (987:26): [True: 3.39k, False: 8.46k]
  |  Branch (987:49): [True: 692, False: 2.69k]
  ------------------
  988|  1.04k|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|  1.04k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.04k|    do {                                                                                 \
  |  |  |  |   69|  1.04k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.04k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.04k|            break;                                                                       \
  |  |  |  |   71|  1.04k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  989|  1.04k|        return RNP_ERROR_BAD_FORMAT;
  990|  1.04k|    }
  991|  11.1k|    version = bt;
  992|       |    /* symmetric algorithm */
  993|  11.1k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (993:9): [True: 397, False: 10.7k]
  ------------------
  994|    397|        RNP_LOG("failed to get symm alg");
  ------------------
  |  |   76|    397|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    397|    do {                                                                                 \
  |  |  |  |   69|    397|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 397, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    397|            break;                                                                       \
  |  |  |  |   71|    397|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  995|    397|        return RNP_ERROR_BAD_FORMAT;
  996|    397|    }
  997|  10.7k|    alg = (pgp_symm_alg_t) bt;
  998|       |
  999|  10.7k|    if (version == PGP_SKSK_V5) {
  ------------------
  |  Branch (999:9): [True: 2.44k, False: 8.31k]
  ------------------
 1000|       |        /* aead algorithm */
 1001|  2.44k|        if (!pkt.get(bt)) {
  ------------------
  |  Branch (1001:13): [True: 208, False: 2.23k]
  ------------------
 1002|    208|            RNP_LOG("failed to get aead alg");
  ------------------
  |  |   76|    208|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    208|    do {                                                                                 \
  |  |  |  |   69|    208|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 208, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    208|            break;                                                                       \
  |  |  |  |   71|    208|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1003|    208|            return RNP_ERROR_BAD_FORMAT;
 1004|    208|        }
 1005|  2.23k|        aalg = (pgp_aead_alg_t) bt;
 1006|  2.23k|        if ((aalg != PGP_AEAD_EAX) && (aalg != PGP_AEAD_OCB)) {
  ------------------
  |  Branch (1006:13): [True: 1.28k, False: 956]
  |  Branch (1006:39): [True: 282, False: 1.00k]
  ------------------
 1007|    282|            RNP_LOG("unsupported AEAD algorithm : %d", (int) aalg);
  ------------------
  |  |   76|    282|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    282|    do {                                                                                 \
  |  |  |  |   69|    282|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 282, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    282|            break;                                                                       \
  |  |  |  |   71|    282|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1008|    282|            return RNP_ERROR_BAD_PARAMETERS;
 1009|    282|        }
 1010|  2.23k|    }
 1011|       |
 1012|       |    /* s2k */
 1013|  10.2k|    if (!pkt.get(s2k)) {
  ------------------
  |  Branch (1013:9): [True: 2.20k, False: 8.06k]
  ------------------
 1014|  2.20k|        RNP_LOG("failed to parse s2k");
  ------------------
  |  |   76|  2.20k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.20k|    do {                                                                                 \
  |  |  |  |   69|  2.20k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.20k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.20k|            break;                                                                       \
  |  |  |  |   71|  2.20k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1015|  2.20k|        return RNP_ERROR_BAD_FORMAT;
 1016|  2.20k|    }
 1017|       |
 1018|       |    /* v4 key */
 1019|  8.06k|    if (version == PGP_SKSK_V4) {
  ------------------
  |  Branch (1019:9): [True: 6.54k, False: 1.52k]
  ------------------
 1020|       |        /* encrypted session key if present */
 1021|  6.54k|        size_t keylen = pkt.left();
 1022|  6.54k|        if (keylen) {
  ------------------
  |  Branch (1022:13): [True: 3.76k, False: 2.77k]
  ------------------
 1023|  3.76k|            if (keylen > PGP_MAX_KEY_SIZE + 1) {
  ------------------
  |  |   89|  3.76k|#define PGP_MAX_KEY_SIZE 32
  ------------------
  |  Branch (1023:17): [True: 292, False: 3.47k]
  ------------------
 1024|    292|                RNP_LOG("too long esk");
  ------------------
  |  |   76|    292|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    292|    do {                                                                                 \
  |  |  |  |   69|    292|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 292, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    292|            break;                                                                       \
  |  |  |  |   71|    292|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1025|    292|                return RNP_ERROR_BAD_FORMAT;
 1026|    292|            }
 1027|  3.47k|            if (!pkt.get(enckey, keylen)) {
  ------------------
  |  Branch (1027:17): [True: 0, False: 3.47k]
  ------------------
 1028|      0|                RNP_LOG("failed to get key");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1029|      0|                return RNP_ERROR_BAD_FORMAT;
 1030|      0|            }
 1031|  3.47k|        }
 1032|  6.24k|        enckeylen = keylen;
 1033|  6.24k|        return RNP_SUCCESS;
 1034|  6.54k|    }
 1035|       |
 1036|       |    /* v5: iv + esk + tag. For both EAX and OCB ivlen and taglen are 16 octets */
 1037|  1.52k|    size_t noncelen = pgp_cipher_aead_nonce_len(aalg);
 1038|  1.52k|    size_t taglen = pgp_cipher_aead_tag_len(aalg);
 1039|  1.52k|    size_t keylen = 0;
 1040|       |
 1041|  1.52k|    if (pkt.left() > noncelen + taglen + PGP_MAX_KEY_SIZE) {
  ------------------
  |  |   89|  1.52k|#define PGP_MAX_KEY_SIZE 32
  ------------------
  |  Branch (1041:9): [True: 257, False: 1.27k]
  ------------------
 1042|    257|        RNP_LOG("too long esk");
  ------------------
  |  |   76|    257|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    257|    do {                                                                                 \
  |  |  |  |   69|    257|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 257, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    257|            break;                                                                       \
  |  |  |  |   71|    257|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1043|    257|        return RNP_ERROR_BAD_FORMAT;
 1044|    257|    }
 1045|  1.27k|    if (pkt.left() < noncelen + taglen + 8) {
  ------------------
  |  Branch (1045:9): [True: 304, False: 966]
  ------------------
 1046|    304|        RNP_LOG("too short esk");
  ------------------
  |  |   76|    304|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    304|    do {                                                                                 \
  |  |  |  |   69|    304|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 304, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    304|            break;                                                                       \
  |  |  |  |   71|    304|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1047|    304|        return RNP_ERROR_BAD_FORMAT;
 1048|    304|    }
 1049|       |    /* iv */
 1050|    966|    if (!pkt.get(iv, noncelen)) {
  ------------------
  |  Branch (1050:9): [True: 0, False: 966]
  ------------------
 1051|      0|        RNP_LOG("failed to get iv");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1052|      0|        return RNP_ERROR_BAD_FORMAT;
 1053|      0|    }
 1054|    966|    ivlen = noncelen;
 1055|       |
 1056|       |    /* key */
 1057|    966|    keylen = pkt.left();
 1058|    966|    if (!pkt.get(enckey, keylen)) {
  ------------------
  |  Branch (1058:9): [True: 0, False: 966]
  ------------------
 1059|      0|        RNP_LOG("failed to get key");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1060|      0|        return RNP_ERROR_BAD_FORMAT;
 1061|      0|    }
 1062|    966|    enckeylen = keylen;
 1063|    966|    return RNP_SUCCESS;
 1064|    966|}
_ZN16pgp_pk_sesskey_t5parseER12pgp_source_t:
 1089|  16.9k|{
 1090|  16.9k|    pgp_packet_body_t pkt(PGP_PKT_PK_SESSION_KEY);
 1091|  16.9k|    rnp_result_t      res = pkt.read(src);
 1092|  16.9k|    if (res) {
  ------------------
  |  Branch (1092:9): [True: 1.47k, False: 15.4k]
  ------------------
 1093|  1.47k|        return res;
 1094|  1.47k|    }
 1095|       |    /* version */
 1096|  15.4k|    uint8_t bt = 0;
 1097|  15.4k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (1097:9): [True: 368, False: 15.0k]
  ------------------
 1098|    368|        RNP_LOG("Error when reading packet version");
  ------------------
  |  |   76|    368|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    368|    do {                                                                                 \
  |  |  |  |   69|    368|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 368, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    368|            break;                                                                       \
  |  |  |  |   71|    368|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1099|    368|        return RNP_ERROR_BAD_FORMAT;
 1100|    368|    }
 1101|  15.0k|#if defined(ENABLE_CRYPTO_REFRESH)
 1102|  15.0k|    if ((bt != PGP_PKSK_V3) && (bt != PGP_PKSK_V6)) {
  ------------------
  |  Branch (1102:9): [True: 5.56k, False: 9.52k]
  |  Branch (1102:32): [True: 534, False: 5.03k]
  ------------------
 1103|       |#else
 1104|       |    if ((bt != PGP_PKSK_V3)) {
 1105|       |#endif
 1106|    534|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|    534|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    534|    do {                                                                                 \
  |  |  |  |   69|    534|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 534, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    534|            break;                                                                       \
  |  |  |  |   71|    534|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1107|    534|        return RNP_ERROR_BAD_FORMAT;
 1108|    534|    }
 1109|  14.5k|    version = (pgp_pkesk_version_t) bt;
 1110|       |
 1111|  14.5k|#if defined(ENABLE_CRYPTO_REFRESH)
 1112|  14.5k|    if (version == PGP_PKSK_V3)
  ------------------
  |  Branch (1112:9): [True: 9.52k, False: 5.03k]
  ------------------
 1113|  9.52k|#endif
 1114|  9.52k|    {
 1115|       |        /* key id */
 1116|  9.52k|        if (!pkt.get(key_id)) {
  ------------------
  |  Branch (1116:13): [True: 228, False: 9.29k]
  ------------------
 1117|    228|            RNP_LOG("failed to get key id");
  ------------------
  |  |   76|    228|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    228|    do {                                                                                 \
  |  |  |  |   69|    228|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 228, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    228|            break;                                                                       \
  |  |  |  |   71|    228|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1118|    228|            return RNP_ERROR_BAD_FORMAT;
 1119|    228|        }
 1120|  9.52k|    }
 1121|  5.03k|#if defined(ENABLE_CRYPTO_REFRESH)
 1122|  5.03k|    else {                          // PGP_PKSK_V6
 1123|  5.03k|        uint8_t fp_and_key_ver_len; // A one-octet size of the following two fields.
 1124|  5.03k|        if (!pkt.get(fp_and_key_ver_len)) {
  ------------------
  |  Branch (1124:13): [True: 214, False: 4.81k]
  ------------------
 1125|    214|            RNP_LOG("Error when reading length of next two fields");
  ------------------
  |  |   76|    214|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    214|    do {                                                                                 \
  |  |  |  |   69|    214|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 214, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    214|            break;                                                                       \
  |  |  |  |   71|    214|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1126|    214|            return RNP_ERROR_BAD_FORMAT;
 1127|    214|        }
 1128|  4.81k|        if ((fp_and_key_ver_len != 1 + PGP_FINGERPRINT_V4_SIZE) &&
  ------------------
  |  |   43|  4.81k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
  |  Branch (1128:13): [True: 3.75k, False: 1.06k]
  ------------------
 1129|  3.75k|            (fp_and_key_ver_len != 1 + PGP_FINGERPRINT_V6_SIZE)) {
  ------------------
  |  |   51|  3.75k|#define PGP_FINGERPRINT_V6_SIZE 32
  ------------------
  |  Branch (1129:13): [True: 232, False: 3.51k]
  ------------------
 1130|    232|            RNP_LOG("Invalid size for key version + length field");
  ------------------
  |  |   76|    232|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    232|    do {                                                                                 \
  |  |  |  |   69|    232|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 232, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    232|            break;                                                                       \
  |  |  |  |   71|    232|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1131|    232|            return RNP_ERROR_BAD_FORMAT;
 1132|    232|        }
 1133|       |
 1134|  4.58k|        size_t  fp_len;
 1135|  4.58k|        uint8_t fp_key_version;
 1136|  4.58k|        if (!pkt.get(fp_key_version)) {
  ------------------
  |  Branch (1136:13): [True: 340, False: 4.24k]
  ------------------
 1137|    340|            RNP_LOG("Error when reading key version");
  ------------------
  |  |   76|    340|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    340|    do {                                                                                 \
  |  |  |  |   69|    340|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 340, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    340|            break;                                                                       \
  |  |  |  |   71|    340|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1138|    340|            return RNP_ERROR_BAD_FORMAT;
 1139|    340|        }
 1140|  4.24k|        switch (fp_key_version) {
 1141|    869|        case 0: // anonymous
  ------------------
  |  Branch (1141:9): [True: 869, False: 3.37k]
  ------------------
 1142|    869|            fp_len = 0;
 1143|    869|            break;
 1144|    811|        case PGP_V4:
  ------------------
  |  Branch (1144:9): [True: 811, False: 3.43k]
  ------------------
 1145|    811|            fp_len = PGP_FINGERPRINT_V4_SIZE;
  ------------------
  |  |   43|    811|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
 1146|    811|            break;
 1147|  2.29k|        case PGP_V6:
  ------------------
  |  Branch (1147:9): [True: 2.29k, False: 1.94k]
  ------------------
 1148|  2.29k|            fp_len = PGP_FINGERPRINT_V6_SIZE;
  ------------------
  |  |   51|  2.29k|#define PGP_FINGERPRINT_V6_SIZE 32
  ------------------
 1149|  2.29k|            break;
 1150|    269|        default:
  ------------------
  |  Branch (1150:9): [True: 269, False: 3.97k]
  ------------------
 1151|    269|            RNP_LOG("wrong key version used with PKESK v6");
  ------------------
  |  |   76|    269|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    269|    do {                                                                                 \
  |  |  |  |   69|    269|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 269, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    269|            break;                                                                       \
  |  |  |  |   71|    269|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1152|    269|            return RNP_ERROR_BAD_FORMAT;
 1153|  4.24k|        }
 1154|  3.97k|        if (fp_len && (fp_len + 1 != fp_and_key_ver_len)) {
  ------------------
  |  Branch (1154:13): [True: 3.10k, False: 869]
  |  Branch (1154:23): [True: 263, False: 2.84k]
  ------------------
 1155|    263|            RNP_LOG("size mismatch (fingerprint size and fp+key version length field)");
  ------------------
  |  |   76|    263|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    263|    do {                                                                                 \
  |  |  |  |   69|    263|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 263, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    263|            break;                                                                       \
  |  |  |  |   71|    263|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1156|    263|            return RNP_ERROR_BAD_FORMAT;
 1157|    263|        }
 1158|  3.71k|        std::vector<uint8_t> vec(fp_len, 0);
 1159|  3.71k|        if (!pkt.get(vec.data(), vec.size())) {
  ------------------
  |  Branch (1159:13): [True: 283, False: 3.43k]
  ------------------
 1160|    283|            RNP_LOG("Error when reading fingerprint");
  ------------------
  |  |   76|    283|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    283|    do {                                                                                 \
  |  |  |  |   69|    283|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 283, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    283|            break;                                                                       \
  |  |  |  |   71|    283|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1161|    283|            return RNP_ERROR_BAD_FORMAT;
 1162|    283|        }
 1163|  3.43k|        fp = pgp::Fingerprint(vec.data(), vec.size());
 1164|  3.43k|    }
 1165|  12.7k|#endif
 1166|       |
 1167|       |    /* public key algorithm */
 1168|  12.7k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (1168:9): [True: 225, False: 12.5k]
  ------------------
 1169|    225|        RNP_LOG("failed to get palg");
  ------------------
  |  |   76|    225|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    225|    do {                                                                                 \
  |  |  |  |   69|    225|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 225, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    225|            break;                                                                       \
  |  |  |  |   71|    225|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1170|    225|        return RNP_ERROR_BAD_FORMAT;
 1171|    225|    }
 1172|  12.5k|    alg = (pgp_pubkey_alg_t) bt;
 1173|       |
 1174|       |    /* symmetric algorithm */
 1175|  12.5k|    salg = PGP_SA_UNKNOWN;
 1176|       |
 1177|       |    /* raw encrypted material */
 1178|  12.5k|    if (!pkt.left()) {
  ------------------
  |  Branch (1178:9): [True: 296, False: 12.2k]
  ------------------
 1179|    296|        RNP_LOG("No encrypted material");
  ------------------
  |  |   76|    296|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    296|    do {                                                                                 \
  |  |  |  |   69|    296|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 296, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    296|            break;                                                                       \
  |  |  |  |   71|    296|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1180|    296|        return RNP_ERROR_BAD_FORMAT;
 1181|    296|    }
 1182|  12.2k|    try {
 1183|  12.2k|        material_buf.resize(pkt.left());
 1184|  12.2k|    } catch (const std::exception &e) {
 1185|      0|        RNP_LOG("%s", e.what());
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1186|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1187|      0|    }
 1188|       |    /* we cannot fail here */
 1189|  12.2k|    pkt.get(material_buf.data(), material_buf.size());
 1190|       |    /* check whether it can be parsed */
 1191|  12.2k|    if (!parse_material()) {
  ------------------
  |  Branch (1191:9): [True: 6.03k, False: 6.16k]
  ------------------
 1192|  6.03k|        return RNP_ERROR_BAD_FORMAT;
 1193|  6.03k|    }
 1194|  6.16k|    return RNP_SUCCESS;
 1195|  12.2k|}
_ZNK16pgp_pk_sesskey_t14parse_materialEv:
 1199|  18.3k|{
 1200|  18.3k|    auto enc = pgp::EncMaterial::create(alg);
 1201|  18.3k|    if (!enc) {
  ------------------
  |  Branch (1201:9): [True: 490, False: 17.8k]
  ------------------
 1202|    490|        return nullptr;
 1203|    490|    }
 1204|  17.8k|#if defined(ENABLE_CRYPTO_REFRESH)
 1205|  17.8k|    enc->version = version;
 1206|  17.8k|#endif
 1207|  17.8k|    pgp_packet_body_t pkt(material_buf);
 1208|  17.8k|    if (!enc->parse(pkt)) {
  ------------------
  |  Branch (1208:9): [True: 4.03k, False: 13.8k]
  ------------------
 1209|  4.03k|        return nullptr;
 1210|  4.03k|    }
 1211|  13.8k|    if (pkt.left()) {
  ------------------
  |  Branch (1211:9): [True: 1.51k, False: 12.3k]
  ------------------
 1212|  1.51k|        RNP_LOG("extra %zu bytes in pk packet", pkt.left());
  ------------------
  |  |   76|  1.51k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.51k|    do {                                                                                 \
  |  |  |  |   69|  1.51k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.51k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.51k|            break;                                                                       \
  |  |  |  |   71|  1.51k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1213|  1.51k|        return nullptr;
 1214|  1.51k|    }
 1215|  12.3k|    return enc;
 1216|  13.8k|}
_ZN18pgp_one_pass_sig_t5parseER12pgp_source_t:
 1241|  2.53k|{
 1242|  2.53k|    pgp_packet_body_t pkt(PGP_PKT_ONE_PASS_SIG);
 1243|       |    /* Read the packet into memory */
 1244|  2.53k|    rnp_result_t res = pkt.read(src);
 1245|  2.53k|    if (res) {
  ------------------
  |  Branch (1245:9): [True: 910, False: 1.62k]
  ------------------
 1246|    910|        return res;
 1247|    910|    }
 1248|       |
 1249|  1.62k|    uint8_t buf[13] = {0};
 1250|  1.62k|    if ((pkt.size() != 13) || !pkt.get(buf, 13)) {
  ------------------
  |  Branch (1250:9): [True: 483, False: 1.13k]
  |  Branch (1250:31): [True: 0, False: 1.13k]
  ------------------
 1251|    483|        return RNP_ERROR_BAD_FORMAT;
 1252|    483|    }
 1253|       |    /* version */
 1254|  1.13k|    if (buf[0] != 3) {
  ------------------
  |  Branch (1254:9): [True: 344, False: 795]
  ------------------
 1255|    344|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|    344|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    344|    do {                                                                                 \
  |  |  |  |   69|    344|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 344, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    344|            break;                                                                       \
  |  |  |  |   71|    344|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1256|    344|        return RNP_ERROR_BAD_FORMAT;
 1257|    344|    }
 1258|    795|    version = buf[0];
 1259|       |    /* signature type */
 1260|    795|    type = (pgp_sig_type_t) buf[1];
 1261|       |    /* hash algorithm */
 1262|    795|    halg = (pgp_hash_alg_t) buf[2];
 1263|       |    /* pk algorithm */
 1264|    795|    palg = (pgp_pubkey_alg_t) buf[3];
 1265|       |    /* key id */
 1266|    795|    static_assert(std::tuple_size<decltype(keyid)>::value == PGP_KEY_ID_SIZE,
 1267|    795|                  "pgp_one_pass_sig_t.keyid size mismatch");
 1268|    795|    memcpy(keyid.data(), &buf[4], PGP_KEY_ID_SIZE);
  ------------------
  |  |   39|    795|#define PGP_KEY_ID_SIZE 8
  ------------------
 1269|       |    /* nested flag */
 1270|    795|    nested = buf[12];
 1271|    795|    return RNP_SUCCESS;
 1272|  1.13k|}
stream-packet.cpp:_ZL11get_pkt_lenPhPm:
  138|   619k|{
  139|   619k|    if (hdr[0] & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|   619k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (139:9): [True: 440k, False: 178k]
  ------------------
  140|       |        // 1-byte length
  141|   440k|        if (hdr[1] < 192) {
  ------------------
  |  Branch (141:13): [True: 413k, False: 26.3k]
  ------------------
  142|   413k|            *pktlen = hdr[1];
  143|   413k|            return true;
  144|   413k|        }
  145|       |        // 2-byte length
  146|  26.3k|        if (hdr[1] < 224) {
  ------------------
  |  Branch (146:13): [True: 24.9k, False: 1.39k]
  ------------------
  147|  24.9k|            *pktlen = ((size_t)(hdr[1] - 192) << 8) + (size_t) hdr[2] + 192;
  148|  24.9k|            return true;
  149|  24.9k|        }
  150|       |        // partial length - we do not allow it here
  151|  1.39k|        if (hdr[1] < 255) {
  ------------------
  |  Branch (151:13): [True: 345, False: 1.05k]
  ------------------
  152|    345|            return false;
  153|    345|        }
  154|       |        // 4-byte length
  155|  1.05k|        *pktlen = read_uint32(&hdr[2]);
  156|  1.05k|        return true;
  157|  1.39k|    }
  158|       |
  159|   178k|    switch (hdr[0] & PGP_PTAG_OF_LENGTH_TYPE_MASK) {
  ------------------
  |  |   83|   178k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  160|   119k|    case PGP_PTAG_OLD_LEN_1:
  ------------------
  |  Branch (160:5): [True: 119k, False: 59.7k]
  ------------------
  161|   119k|        *pktlen = hdr[1];
  162|   119k|        return true;
  163|  36.3k|    case PGP_PTAG_OLD_LEN_2:
  ------------------
  |  Branch (163:5): [True: 36.3k, False: 142k]
  ------------------
  164|  36.3k|        *pktlen = read_uint16(&hdr[1]);
  165|  36.3k|        return true;
  166|  7.04k|    case PGP_PTAG_OLD_LEN_4:
  ------------------
  |  Branch (166:5): [True: 7.04k, False: 171k]
  ------------------
  167|  7.04k|        *pktlen = read_uint32(&hdr[1]);
  168|  7.04k|        return true;
  169|  16.3k|    default:
  ------------------
  |  Branch (169:5): [True: 16.3k, False: 162k]
  ------------------
  170|  16.3k|        return false;
  171|   178k|    }
  172|   178k|}
stream-packet.cpp:_ZL26stream_read_packet_partialP12pgp_source_tP10pgp_dest_t:
  301|  4.13k|{
  302|  4.13k|    uint8_t hdr = 0;
  303|  4.13k|    if (!src->read_eq(&hdr, 1)) {
  ------------------
  |  Branch (303:9): [True: 0, False: 4.13k]
  ------------------
  304|      0|        return RNP_ERROR_READ;
  305|      0|    }
  306|       |
  307|  4.13k|    bool   last = false;
  308|  4.13k|    size_t partlen = 0;
  309|  4.13k|    if (!stream_read_partial_chunk_len(src, &partlen, &last)) {
  ------------------
  |  Branch (309:9): [True: 0, False: 4.13k]
  ------------------
  310|      0|        return RNP_ERROR_BAD_FORMAT;
  311|      0|    }
  312|       |
  313|  4.13k|    uint8_t *buf = (uint8_t *) malloc(PGP_INPUT_CACHE_SIZE);
  ------------------
  |  |   35|  4.13k|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  314|  4.13k|    if (!buf) {
  ------------------
  |  Branch (314:9): [True: 0, False: 4.13k]
  ------------------
  315|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  316|      0|    }
  317|       |
  318|  22.9M|    while (partlen > 0) {
  ------------------
  |  Branch (318:12): [True: 22.9M, False: 389]
  ------------------
  319|  22.9M|        size_t read = std::min(partlen, (size_t) PGP_INPUT_CACHE_SIZE);
  ------------------
  |  |   35|  22.9M|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  320|  22.9M|        if (!src->read_eq(buf, read)) {
  ------------------
  |  Branch (320:13): [True: 721, False: 22.9M]
  ------------------
  321|    721|            free(buf);
  322|    721|            return RNP_ERROR_READ;
  323|    721|        }
  324|  22.9M|        if (dst) {
  ------------------
  |  Branch (324:13): [True: 17.2M, False: 5.65M]
  ------------------
  325|  17.2M|            dst_write(dst, buf, read);
  326|  17.2M|        }
  327|  22.9M|        partlen -= read;
  328|  22.9M|        if (partlen > 0) {
  ------------------
  |  Branch (328:13): [True: 2.79k, False: 22.9M]
  ------------------
  329|  2.79k|            continue;
  330|  2.79k|        }
  331|  22.9M|        if (last) {
  ------------------
  |  Branch (331:13): [True: 2.82k, False: 22.9M]
  ------------------
  332|  2.82k|            break;
  333|  2.82k|        }
  334|  22.9M|        if (!stream_read_partial_chunk_len(src, &partlen, &last)) {
  ------------------
  |  Branch (334:13): [True: 201, False: 22.9M]
  ------------------
  335|    201|            free(buf);
  336|    201|            return RNP_ERROR_BAD_FORMAT;
  337|    201|        }
  338|  22.9M|    }
  339|  3.21k|    free(buf);
  340|  3.21k|    return RNP_SUCCESS;
  341|  4.13k|}

_ZN16pgp_userid_pkt_tC2Ev:
  239|  27.3k|    pgp_userid_pkt_t() : tag(PGP_PKT_RESERVED){};

_Z16init_literal_srcP12pgp_source_tS0_:
 1810|  1.62k|{
 1811|  1.62k|    rnp_result_t                ret = RNP_ERROR_GENERIC;
 1812|  1.62k|    pgp_source_literal_param_t *param;
 1813|  1.62k|    uint8_t                     format = 0;
 1814|  1.62k|    uint8_t                     nlen = 0;
 1815|  1.62k|    uint8_t                     timestamp[4];
 1816|       |
 1817|  1.62k|    if (!init_src_common(src, sizeof(*param))) {
  ------------------
  |  Branch (1817:9): [True: 0, False: 1.62k]
  ------------------
 1818|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1819|      0|    }
 1820|       |
 1821|  1.62k|    param = (pgp_source_literal_param_t *) src->param;
 1822|  1.62k|    param->pkt.readsrc = readsrc;
 1823|  1.62k|    src->raw_read = literal_src_read;
 1824|  1.62k|    src->raw_close = literal_src_close;
 1825|  1.62k|    src->type = PGP_STREAM_LITERAL;
 1826|       |
 1827|       |    /* Reading packet length/checking whether it is partial */
 1828|  1.62k|    if ((ret = init_packet_params(param->pkt))) {
  ------------------
  |  Branch (1828:9): [True: 13, False: 1.61k]
  ------------------
 1829|     13|        goto finish;
 1830|     13|    }
 1831|       |
 1832|       |    /* data format */
 1833|  1.61k|    if (!param->pkt.readsrc->read_eq(&format, 1)) {
  ------------------
  |  Branch (1833:9): [True: 98, False: 1.51k]
  ------------------
 1834|     98|        RNP_LOG("failed to read data format");
  ------------------
  |  |   76|     98|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     98|    do {                                                                                 \
  |  |  |  |   69|     98|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 98, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     98|            break;                                                                       \
  |  |  |  |   71|     98|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1835|     98|        ret = RNP_ERROR_READ;
 1836|     98|        goto finish;
 1837|     98|    }
 1838|       |
 1839|  1.51k|    switch (format) {
 1840|    121|    case 'b':
  ------------------
  |  Branch (1840:5): [True: 121, False: 1.39k]
  ------------------
 1841|    217|    case 't':
  ------------------
  |  Branch (1841:5): [True: 96, False: 1.42k]
  ------------------
 1842|    294|    case 'u':
  ------------------
  |  Branch (1842:5): [True: 77, False: 1.44k]
  ------------------
 1843|    390|    case 'l':
  ------------------
  |  Branch (1843:5): [True: 96, False: 1.42k]
  ------------------
 1844|    470|    case '1':
  ------------------
  |  Branch (1844:5): [True: 80, False: 1.43k]
  ------------------
 1845|    560|    case 'm':
  ------------------
  |  Branch (1845:5): [True: 90, False: 1.42k]
  ------------------
 1846|    560|        break;
 1847|    957|    default:
  ------------------
  |  Branch (1847:5): [True: 957, False: 560]
  ------------------
 1848|    957|        RNP_LOG("Warning: unknown data format %" PRIu8 ", ignoring.", format);
  ------------------
  |  |   76|    957|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    957|    do {                                                                                 \
  |  |  |  |   69|    957|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 957, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    957|            break;                                                                       \
  |  |  |  |   71|    957|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1849|    957|        break;
 1850|  1.51k|    }
 1851|  1.51k|    param->hdr.format = format;
 1852|       |    /* file name */
 1853|  1.51k|    if (!param->pkt.readsrc->read_eq(&nlen, 1)) {
  ------------------
  |  Branch (1853:9): [True: 168, False: 1.34k]
  ------------------
 1854|    168|        RNP_LOG("failed to read file name length");
  ------------------
  |  |   76|    168|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    168|    do {                                                                                 \
  |  |  |  |   69|    168|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 168, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    168|            break;                                                                       \
  |  |  |  |   71|    168|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1855|    168|        ret = RNP_ERROR_READ;
 1856|    168|        goto finish;
 1857|    168|    }
 1858|  1.34k|    if (nlen && !param->pkt.readsrc->read_eq(param->hdr.fname, nlen)) {
  ------------------
  |  Branch (1858:9): [True: 997, False: 352]
  |  Branch (1858:17): [True: 134, False: 863]
  ------------------
 1859|    134|        RNP_LOG("failed to read file name");
  ------------------
  |  |   76|    134|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    134|    do {                                                                                 \
  |  |  |  |   69|    134|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 134, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    134|            break;                                                                       \
  |  |  |  |   71|    134|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1860|    134|        ret = RNP_ERROR_READ;
 1861|    134|        goto finish;
 1862|    134|    }
 1863|  1.21k|    param->hdr.fname[nlen] = 0;
 1864|  1.21k|    param->hdr.fname_len = nlen;
 1865|       |    /* timestamp */
 1866|  1.21k|    if (!param->pkt.readsrc->read_eq(timestamp, 4)) {
  ------------------
  |  Branch (1866:9): [True: 85, False: 1.13k]
  ------------------
 1867|     85|        RNP_LOG("failed to read file timestamp");
  ------------------
  |  |   76|     85|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     85|    do {                                                                                 \
  |  |  |  |   69|     85|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 85, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     85|            break;                                                                       \
  |  |  |  |   71|     85|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1868|     85|        ret = RNP_ERROR_READ;
 1869|     85|        goto finish;
 1870|     85|    }
 1871|  1.13k|    param->hdr.timestamp = read_uint32(timestamp);
 1872|       |
 1873|  1.13k|    if (!param->pkt.hdr.indeterminate && !param->pkt.hdr.partial) {
  ------------------
  |  Branch (1873:9): [True: 1.05k, False: 73]
  |  Branch (1873:42): [True: 932, False: 125]
  ------------------
 1874|       |        /* format filename-length filename timestamp */
 1875|    932|        const uint16_t nbytes = 1 + 1 + nlen + 4;
 1876|    932|        if (param->pkt.hdr.pkt_len < nbytes) {
  ------------------
  |  Branch (1876:13): [True: 476, False: 456]
  ------------------
 1877|    476|            ret = RNP_ERROR_BAD_FORMAT;
 1878|    476|            goto finish;
 1879|    476|        }
 1880|    456|        src->size = param->pkt.hdr.pkt_len - nbytes;
 1881|    456|        src->knownsize = 1;
 1882|    456|    }
 1883|    654|    ret = RNP_SUCCESS;
 1884|  1.62k|finish:
 1885|  1.62k|    if (ret) {
  ------------------
  |  Branch (1885:9): [True: 974, False: 654]
  ------------------
 1886|    974|        src->close();
 1887|    974|    }
 1888|  1.62k|    return ret;
 1889|    654|}
_Z19get_literal_src_hdrR12pgp_source_t:
 1893|    654|{
 1894|    654|    return (static_cast<pgp_source_literal_param_t *>(src.param))->hdr;
 1895|    654|}
_Z19init_compressed_srcP12pgp_source_tS0_:
 1899|  21.1k|{
 1900|  21.1k|    rnp_result_t                   errcode = RNP_ERROR_GENERIC;
 1901|  21.1k|    pgp_source_compressed_param_t *param;
 1902|  21.1k|    uint8_t                        alg;
 1903|  21.1k|    int                            zret;
 1904|       |
 1905|  21.1k|    if (!init_src_common(src, sizeof(*param))) {
  ------------------
  |  Branch (1905:9): [True: 0, False: 21.1k]
  ------------------
 1906|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1907|      0|    }
 1908|       |
 1909|  21.1k|    param = (pgp_source_compressed_param_t *) src->param;
 1910|  21.1k|    param->pkt.readsrc = readsrc;
 1911|  21.1k|    src->raw_read = compressed_src_read;
 1912|  21.1k|    src->raw_close = compressed_src_close;
 1913|  21.1k|    src->type = PGP_STREAM_COMPRESSED;
 1914|       |
 1915|       |    /* Reading packet length/checking whether it is partial */
 1916|  21.1k|    errcode = init_packet_params(param->pkt);
 1917|  21.1k|    if (errcode != RNP_SUCCESS) {
  ------------------
  |  Branch (1917:9): [True: 14, False: 21.1k]
  ------------------
 1918|     14|        goto finish;
 1919|     14|    }
 1920|       |
 1921|       |    /* Reading compression algorithm */
 1922|  21.1k|    if (!param->pkt.readsrc->read_eq(&alg, 1)) {
  ------------------
  |  Branch (1922:9): [True: 234, False: 20.9k]
  ------------------
 1923|    234|        RNP_LOG("failed to read compression algorithm");
  ------------------
  |  |   76|    234|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    234|    do {                                                                                 \
  |  |  |  |   69|    234|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 234, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    234|            break;                                                                       \
  |  |  |  |   71|    234|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1924|    234|        errcode = RNP_ERROR_READ;
 1925|    234|        goto finish;
 1926|    234|    }
 1927|       |
 1928|       |    /* Initializing decompression */
 1929|  20.9k|    switch (alg) {
 1930|  6.79k|    case PGP_C_NONE:
  ------------------
  |  Branch (1930:5): [True: 6.79k, False: 14.1k]
  ------------------
 1931|  6.79k|        break;
 1932|  12.7k|    case PGP_C_ZIP:
  ------------------
  |  Branch (1932:5): [True: 12.7k, False: 8.16k]
  ------------------
 1933|  12.8k|    case PGP_C_ZLIB:
  ------------------
  |  Branch (1933:5): [True: 146, False: 20.7k]
  ------------------
 1934|  12.8k|        (void) memset(&param->z, 0x0, sizeof(param->z));
 1935|  12.8k|        zret =
 1936|  12.8k|          alg == PGP_C_ZIP ? (int) inflateInit2(&param->z, -15) : (int) inflateInit(&param->z);
  ------------------
  |  Branch (1936:11): [True: 12.7k, False: 146]
  ------------------
 1937|  12.8k|        if (zret != Z_OK) {
  ------------------
  |  Branch (1937:13): [True: 0, False: 12.8k]
  ------------------
 1938|      0|            RNP_LOG("failed to init zlib, error %d", zret);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1939|      0|            errcode = RNP_ERROR_READ;
 1940|      0|            goto finish;
 1941|      0|        }
 1942|  12.8k|        break;
 1943|  12.8k|#ifdef HAVE_BZLIB_H
 1944|  12.8k|    case PGP_C_BZIP2:
  ------------------
  |  Branch (1944:5): [True: 340, False: 20.5k]
  ------------------
 1945|    340|        (void) memset(&param->bz, 0x0, sizeof(param->bz));
 1946|    340|        zret = BZ2_bzDecompressInit(&param->bz, 0, 0);
 1947|    340|        if (zret != BZ_OK) {
  ------------------
  |  Branch (1947:13): [True: 0, False: 340]
  ------------------
 1948|      0|            RNP_LOG("failed to init bz, error %d", zret);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1949|      0|            errcode = RNP_ERROR_READ;
 1950|      0|            goto finish;
 1951|      0|        }
 1952|    340|        break;
 1953|    340|#endif
 1954|    885|    default:
  ------------------
  |  Branch (1954:5): [True: 885, False: 20.0k]
  ------------------
 1955|    885|        RNP_LOG("unknown compression algorithm: %d", (int) alg);
  ------------------
  |  |   76|    885|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    885|    do {                                                                                 \
  |  |  |  |   69|    885|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 885, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    885|            break;                                                                       \
  |  |  |  |   71|    885|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1956|    885|        errcode = RNP_ERROR_BAD_FORMAT;
 1957|    885|        goto finish;
 1958|  20.9k|    }
 1959|  20.0k|    param->alg = (pgp_compression_type_t) alg;
 1960|  20.0k|    param->inlen = 0;
 1961|  20.0k|    param->inpos = 0;
 1962|       |
 1963|  20.0k|    errcode = RNP_SUCCESS;
 1964|  21.1k|finish:
 1965|  21.1k|    if (errcode != RNP_SUCCESS) {
  ------------------
  |  Branch (1965:9): [True: 1.13k, False: 20.0k]
  ------------------
 1966|  1.13k|        src->close();
 1967|  1.13k|    }
 1968|  21.1k|    return errcode;
 1969|  20.0k|}
_Z22get_compressed_src_algP12pgp_source_tPh:
 1973|  20.0k|{
 1974|  20.0k|    pgp_source_compressed_param_t *param;
 1975|       |
 1976|  20.0k|    if (src->type != PGP_STREAM_COMPRESSED) {
  ------------------
  |  Branch (1976:9): [True: 0, False: 20.0k]
  ------------------
 1977|      0|        RNP_LOG("wrong stream");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1978|      0|        return false;
 1979|      0|    }
 1980|       |
 1981|  20.0k|    param = (pgp_source_compressed_param_t *) src->param;
 1982|  20.0k|    *alg = param->alg;
 1983|  20.0k|    return true;
 1984|  20.0k|}
_Z16get_aead_src_hdrP12pgp_source_tP14pgp_aead_hdr_t:
 2021|    776|{
 2022|    776|    uint8_t hdrbt[4] = {0};
 2023|       |
 2024|    776|    if (!src->read_eq(hdrbt, 4)) {
  ------------------
  |  Branch (2024:9): [True: 186, False: 590]
  ------------------
 2025|    186|        return false;
 2026|    186|    }
 2027|       |
 2028|    590|    hdr->version = hdrbt[0];
 2029|    590|    hdr->ealg = (pgp_symm_alg_t) hdrbt[1];
 2030|    590|    hdr->aalg = (pgp_aead_alg_t) hdrbt[2];
 2031|    590|    hdr->csize = hdrbt[3];
 2032|       |
 2033|    590|    if (!(hdr->ivlen = pgp_cipher_aead_nonce_len(hdr->aalg))) {
  ------------------
  |  Branch (2033:9): [True: 436, False: 154]
  ------------------
 2034|    436|        RNP_LOG("wrong aead nonce length: alg %d", (int) hdr->aalg);
  ------------------
  |  |   76|    436|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    436|    do {                                                                                 \
  |  |  |  |   69|    436|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 436, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    436|            break;                                                                       \
  |  |  |  |   71|    436|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2035|    436|        return false;
 2036|    436|    }
 2037|       |
 2038|    154|    return src->read_eq(hdr->iv, hdr->ivlen);
 2039|    590|}
stream-parse.cpp:_ZL16literal_src_readP12pgp_source_tPvmPm:
  327|   600k|{
  328|   600k|    pgp_source_literal_param_t *param = (pgp_source_literal_param_t *) src->param;
  329|   600k|    if (!param) {
  ------------------
  |  Branch (329:9): [True: 0, False: 600k]
  ------------------
  330|      0|        return false;
  331|      0|    }
  332|   600k|    return param->pkt.readsrc->read(buf, len, read);
  333|   600k|}
stream-parse.cpp:_ZL17literal_src_closeP12pgp_source_t:
  337|  2.60k|{
  338|  2.60k|    pgp_source_literal_param_t *param = (pgp_source_literal_param_t *) src->param;
  339|  2.60k|    if (param) {
  ------------------
  |  Branch (339:9): [True: 1.62k, False: 974]
  ------------------
  340|  1.62k|        if (param->pkt.hdr.partial) {
  ------------------
  |  Branch (340:13): [True: 465, False: 1.16k]
  ------------------
  341|    465|            param->pkt.readsrc->close();
  342|    465|            free(param->pkt.readsrc);
  343|    465|            param->pkt.readsrc = NULL;
  344|    465|        }
  345|       |
  346|  1.62k|        free(src->param);
  347|       |        src->param = NULL;
  348|  1.62k|    }
  349|  2.60k|}
stream-parse.cpp:_ZL18init_packet_paramsR25pgp_source_packet_param_t:
 1780|  22.7k|{
 1781|  22.7k|    param.origsrc = NULL;
 1782|       |
 1783|       |    /* save packet header */
 1784|  22.7k|    rnp_result_t ret = stream_peek_packet_hdr(param.readsrc, &param.hdr);
 1785|  22.7k|    if (ret) {
  ------------------
  |  Branch (1785:9): [True: 27, False: 22.7k]
  ------------------
 1786|     27|        return ret;
 1787|     27|    }
 1788|  22.7k|    param.readsrc->skip(param.hdr.hdr_len);
 1789|  22.7k|    if (!param.hdr.partial) {
  ------------------
  |  Branch (1789:9): [True: 13.9k, False: 8.82k]
  ------------------
 1790|  13.9k|        return RNP_SUCCESS;
 1791|  13.9k|    }
 1792|       |
 1793|       |    /* initialize partial reader if needed */
 1794|  8.82k|    pgp_source_t *partsrc = (pgp_source_t *) calloc(1, sizeof(*partsrc));
 1795|  8.82k|    if (!partsrc) {
  ------------------
  |  Branch (1795:9): [True: 0, False: 8.82k]
  ------------------
 1796|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1797|      0|    }
 1798|  8.82k|    rnp_result_t errcode = init_partial_pkt_src(partsrc, param.readsrc, param.hdr);
 1799|  8.82k|    if (errcode) {
  ------------------
  |  Branch (1799:9): [True: 0, False: 8.82k]
  ------------------
 1800|      0|        free(partsrc);
 1801|      0|        return errcode;
 1802|      0|    }
 1803|  8.82k|    param.origsrc = param.readsrc;
 1804|  8.82k|    param.readsrc = partsrc;
 1805|  8.82k|    return RNP_SUCCESS;
 1806|  8.82k|}
stream-parse.cpp:_ZL20init_partial_pkt_srcP12pgp_source_tS0_R16pgp_packet_hdr_t:
  297|  8.82k|{
  298|  8.82k|    pgp_source_partial_param_t *param;
  299|  8.82k|    if (!init_src_common(src, sizeof(*param))) {
  ------------------
  |  Branch (299:9): [True: 0, False: 8.82k]
  ------------------
  300|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
  301|      0|    }
  302|       |
  303|  8.82k|    assert(hdr.partial);
  304|       |    /* we are sure that header is indeterminate */
  305|  8.82k|    param = (pgp_source_partial_param_t *) src->param;
  306|  8.82k|    param->type = hdr.tag;
  307|  8.82k|    param->psize = get_partial_pkt_len(hdr.hdr[1]);
  308|  8.82k|    param->pleft = param->psize;
  309|  8.82k|    param->last = false;
  310|  8.82k|    param->readsrc = readsrc;
  311|       |
  312|  8.82k|    src->raw_read = partial_pkt_src_read;
  313|  8.82k|    src->raw_close = partial_pkt_src_close;
  314|  8.82k|    src->type = PGP_STREAM_PARLEN_PACKET;
  315|       |
  316|  8.82k|    if (param->psize < PGP_PARTIAL_PKT_FIRST_PART_MIN_SIZE) {
  ------------------
  |  |   38|  8.82k|#define PGP_PARTIAL_PKT_FIRST_PART_MIN_SIZE 512
  ------------------
  |  Branch (316:9): [True: 7.11k, False: 1.71k]
  ------------------
  317|  7.11k|        RNP_LOG("first part of partial length packet sequence has size %d and that's less "
  ------------------
  |  |   76|  7.11k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  7.11k|    do {                                                                                 \
  |  |  |  |   69|  7.11k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 7.11k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  7.11k|            break;                                                                       \
  |  |  |  |   71|  7.11k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  318|  7.11k|                "than allowed by the protocol",
  319|  7.11k|                (int) param->psize);
  320|  7.11k|    }
  321|       |
  322|  8.82k|    return RNP_SUCCESS;
  323|  8.82k|}
stream-parse.cpp:_ZL20partial_pkt_src_readP12pgp_source_tPvmPm:
  232|   622k|{
  233|   622k|    if (src->eof_) {
  ------------------
  |  Branch (233:9): [True: 0, False: 622k]
  ------------------
  234|      0|        *readres = 0;
  235|      0|        return true;
  236|      0|    }
  237|       |
  238|   622k|    pgp_source_partial_param_t *param = (pgp_source_partial_param_t *) src->param;
  239|   622k|    if (!param) {
  ------------------
  |  Branch (239:9): [True: 0, False: 622k]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|       |
  243|   622k|    size_t read;
  244|   622k|    size_t write = 0;
  245|  1.68M|    while (len > 0) {
  ------------------
  |  Branch (245:12): [True: 1.07M, False: 605k]
  ------------------
  246|  1.07M|        if (!param->pleft && param->last) {
  ------------------
  |  Branch (246:13): [True: 455k, False: 620k]
  |  Branch (246:30): [True: 6.30k, False: 448k]
  ------------------
  247|       |            // we have the last chunk
  248|  6.30k|            *readres = write;
  249|  6.30k|            return true;
  250|  6.30k|        }
  251|  1.06M|        if (!param->pleft) {
  ------------------
  |  Branch (251:13): [True: 448k, False: 620k]
  ------------------
  252|       |            // reading next chunk
  253|   448k|            if (!stream_read_partial_chunk_len(param->readsrc, &read, &param->last)) {
  ------------------
  |  Branch (253:17): [True: 120, False: 448k]
  ------------------
  254|    120|                return false;
  255|    120|            }
  256|   448k|            param->psize = read;
  257|   448k|            param->pleft = read;
  258|   448k|        }
  259|       |
  260|  1.06M|        if (!param->pleft) {
  ------------------
  |  Branch (260:13): [True: 3.30k, False: 1.06M]
  ------------------
  261|  3.30k|            *readres = write;
  262|  3.30k|            return true;
  263|  3.30k|        }
  264|       |
  265|  1.06M|        read = param->pleft > len ? len : param->pleft;
  ------------------
  |  Branch (265:16): [True: 609k, False: 456k]
  ------------------
  266|  1.06M|        if (!param->readsrc->read(buf, read, &read)) {
  ------------------
  |  Branch (266:13): [True: 171, False: 1.06M]
  ------------------
  267|    171|            RNP_LOG("failed to read data chunk");
  ------------------
  |  |   76|    171|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    171|    do {                                                                                 \
  |  |  |  |   69|    171|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 171, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    171|            break;                                                                       \
  |  |  |  |   71|    171|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  268|    171|            return false;
  269|    171|        }
  270|  1.06M|        if (!read) {
  ------------------
  |  Branch (270:13): [True: 7.04k, False: 1.05M]
  ------------------
  271|  7.04k|            RNP_LOG("unexpected eof");
  ------------------
  |  |   76|  7.04k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  7.04k|    do {                                                                                 \
  |  |  |  |   69|  7.04k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 7.04k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  7.04k|            break;                                                                       \
  |  |  |  |   71|  7.04k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  272|  7.04k|            *readres = write;
  273|  7.04k|            return true;
  274|  7.04k|        }
  275|  1.05M|        write += read;
  276|  1.05M|        len -= read;
  277|  1.05M|        buf = (uint8_t *) buf + read;
  278|  1.05M|        param->pleft -= read;
  279|  1.05M|    }
  280|       |
  281|   605k|    *readres = write;
  282|   605k|    return true;
  283|   622k|}
stream-parse.cpp:_ZL21partial_pkt_src_closeP12pgp_source_t:
  287|  8.82k|{
  288|  8.82k|    pgp_source_partial_param_t *param = (pgp_source_partial_param_t *) src->param;
  289|  8.82k|    if (param) {
  ------------------
  |  Branch (289:9): [True: 8.82k, False: 0]
  ------------------
  290|  8.82k|        free(src->param);
  291|       |        src->param = NULL;
  292|  8.82k|    }
  293|  8.82k|}
stream-parse.cpp:_ZL19compressed_src_readP12pgp_source_tPvmPm:
  353|   985k|{
  354|   985k|    pgp_source_compressed_param_t *param = (pgp_source_compressed_param_t *) src->param;
  355|   985k|    if (!param) {
  ------------------
  |  Branch (355:9): [True: 0, False: 985k]
  ------------------
  356|      0|        return false; // LCOV_EXCL_LINE
  357|      0|    }
  358|       |
  359|   985k|    if (src->eof_ || param->zend) {
  ------------------
  |  Branch (359:9): [True: 0, False: 985k]
  |  Branch (359:22): [True: 103k, False: 882k]
  ------------------
  360|   103k|        *readres = 0;
  361|   103k|        return true;
  362|   103k|    }
  363|       |
  364|   882k|    if (param->alg == PGP_C_NONE) {
  ------------------
  |  Branch (364:9): [True: 59.8k, False: 822k]
  ------------------
  365|  59.8k|        if (!param->pkt.readsrc->read(buf, len, readres)) {
  ------------------
  |  Branch (365:13): [True: 338, False: 59.4k]
  ------------------
  366|    338|            RNP_LOG("failed to read uncompressed data");
  ------------------
  |  |   76|    338|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    338|    do {                                                                                 \
  |  |  |  |   69|    338|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 338, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    338|            break;                                                                       \
  |  |  |  |   71|    338|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  367|    338|            return false;
  368|    338|        }
  369|  59.4k|        return true;
  370|  59.8k|    }
  371|   822k|    if ((param->alg == PGP_C_ZIP) || (param->alg == PGP_C_ZLIB)) {
  ------------------
  |  Branch (371:9): [True: 204k, False: 617k]
  |  Branch (371:38): [True: 1.31k, False: 616k]
  ------------------
  372|   206k|        param->z.next_out = (Bytef *) buf;
  373|   206k|        param->z.avail_out = len;
  374|   206k|        param->z.next_in = param->in + param->inpos;
  375|   206k|        param->z.avail_in = param->inlen - param->inpos;
  376|       |
  377|   439k|        while ((param->z.avail_out > 0) && (!param->zend)) {
  ------------------
  |  Branch (377:16): [True: 246k, False: 193k]
  |  Branch (377:44): [True: 246k, False: 0]
  ------------------
  378|   246k|            if (param->z.avail_in == 0) {
  ------------------
  |  Branch (378:17): [True: 52.7k, False: 193k]
  ------------------
  379|  52.7k|                size_t read = 0;
  380|  52.7k|                if (!param->pkt.readsrc->read(param->in, sizeof(param->in), &read)) {
  ------------------
  |  Branch (380:21): [True: 90, False: 52.6k]
  ------------------
  381|     90|                    RNP_LOG("failed to read data");
  ------------------
  |  |   76|     90|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     90|    do {                                                                                 \
  |  |  |  |   69|     90|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 90, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     90|            break;                                                                       \
  |  |  |  |   71|     90|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  382|     90|                    return false;
  383|     90|                }
  384|  52.6k|                param->z.next_in = param->in;
  385|  52.6k|                param->z.avail_in = read;
  386|  52.6k|                param->inlen = read;
  387|  52.6k|                param->inpos = 0;
  388|  52.6k|            }
  389|   246k|            int ret = inflate(&param->z, Z_SYNC_FLUSH);
  390|   246k|            if (ret == Z_STREAM_END) {
  ------------------
  |  Branch (390:17): [True: 10.9k, False: 235k]
  ------------------
  391|  10.9k|                param->zend = true;
  392|  10.9k|                if (param->z.avail_in > 0) {
  ------------------
  |  Branch (392:21): [True: 885, False: 10.0k]
  ------------------
  393|    885|                    RNP_LOG("data beyond the end of z stream");
  ------------------
  |  |   76|    885|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    885|    do {                                                                                 \
  |  |  |  |   69|    885|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 885, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    885|            break;                                                                       \
  |  |  |  |   71|    885|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  394|    885|                }
  395|  10.9k|                break;
  396|  10.9k|            }
  397|   235k|            if (ret != Z_OK) {
  ------------------
  |  Branch (397:17): [True: 261, False: 234k]
  ------------------
  398|    261|                RNP_LOG("inflate error %d", ret);
  ------------------
  |  |   76|    261|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    261|    do {                                                                                 \
  |  |  |  |   69|    261|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 261, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    261|            break;                                                                       \
  |  |  |  |   71|    261|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  399|    261|                return false;
  400|    261|            }
  401|   234k|            if (!param->z.avail_in && param->pkt.readsrc->eof()) {
  ------------------
  |  Branch (401:17): [True: 40.9k, False: 193k]
  |  Branch (401:39): [True: 1.07k, False: 39.8k]
  ------------------
  402|  1.07k|                RNP_LOG("unexpected end of zlib stream");
  ------------------
  |  |   76|  1.07k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.07k|    do {                                                                                 \
  |  |  |  |   69|  1.07k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.07k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.07k|            break;                                                                       \
  |  |  |  |   71|  1.07k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  403|  1.07k|                return false;
  404|  1.07k|            }
  405|   234k|        }
  406|   204k|        param->inpos = param->z.next_in - param->in;
  407|   204k|        *readres = len - param->z.avail_out;
  408|   204k|        return true;
  409|   206k|    }
  410|   616k|#ifdef HAVE_BZLIB_H
  411|   616k|    if (param->alg == PGP_C_BZIP2) {
  ------------------
  |  Branch (411:9): [True: 616k, False: 0]
  ------------------
  412|   616k|        param->bz.next_out = (char *) buf;
  413|   616k|        param->bz.avail_out = len;
  414|   616k|        param->bz.next_in = (char *) (param->in + param->inpos);
  415|   616k|        param->bz.avail_in = param->inlen - param->inpos;
  416|       |
  417|  1.23M|        while ((param->bz.avail_out > 0) && (!param->zend)) {
  ------------------
  |  Branch (417:16): [True: 616k, False: 616k]
  |  Branch (417:45): [True: 616k, False: 0]
  ------------------
  418|   616k|            if (param->bz.avail_in == 0) {
  ------------------
  |  Branch (418:17): [True: 406, False: 616k]
  ------------------
  419|    406|                size_t read = 0;
  420|    406|                if (!param->pkt.readsrc->read(param->in, sizeof(param->in), &read)) {
  ------------------
  |  Branch (420:21): [True: 15, False: 391]
  ------------------
  421|     15|                    RNP_LOG("failed to read data");
  ------------------
  |  |   76|     15|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     15|    do {                                                                                 \
  |  |  |  |   69|     15|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 15, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     15|            break;                                                                       \
  |  |  |  |   71|     15|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  422|     15|                    return false;
  423|     15|                }
  424|    391|                param->bz.next_in = (char *) param->in;
  425|    391|                param->bz.avail_in = read;
  426|    391|                param->inlen = read;
  427|    391|                param->inpos = 0;
  428|    391|            }
  429|   616k|            int ret = BZ2_bzDecompress(&param->bz);
  430|   616k|            if (ret == BZ_STREAM_END) {
  ------------------
  |  Branch (430:17): [True: 39, False: 616k]
  ------------------
  431|     39|                param->zend = true;
  432|     39|                if (param->bz.avail_in > 0) {
  ------------------
  |  Branch (432:21): [True: 16, False: 23]
  ------------------
  433|     16|                    RNP_LOG("data beyond the end of z stream");
  ------------------
  |  |   76|     16|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     16|    do {                                                                                 \
  |  |  |  |   69|     16|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 16, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     16|            break;                                                                       \
  |  |  |  |   71|     16|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  434|     16|                }
  435|     39|                break;
  436|     39|            }
  437|   616k|            if (ret != BZ_OK) {
  ------------------
  |  Branch (437:17): [True: 182, False: 616k]
  ------------------
  438|    182|                RNP_LOG("bzdecompress error %d", ret);
  ------------------
  |  |   76|    182|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    182|    do {                                                                                 \
  |  |  |  |   69|    182|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 182, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    182|            break;                                                                       \
  |  |  |  |   71|    182|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  439|    182|                return false;
  440|    182|            }
  441|   616k|            if (!param->bz.avail_in && param->pkt.readsrc->eof()) {
  ------------------
  |  Branch (441:17): [True: 162, False: 616k]
  |  Branch (441:40): [True: 96, False: 66]
  ------------------
  442|     96|                RNP_LOG("unexpected end of bzip stream");
  ------------------
  |  |   76|     96|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     96|    do {                                                                                 \
  |  |  |  |   69|     96|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 96, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     96|            break;                                                                       \
  |  |  |  |   71|     96|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  443|     96|                return false;
  444|     96|            }
  445|   616k|        }
  446|       |
  447|   616k|        param->inpos = (uint8_t *) param->bz.next_in - param->in;
  448|   616k|        *readres = len - param->bz.avail_out;
  449|   616k|        return true;
  450|   616k|    }
  451|      0|#endif
  452|      0|    return false;
  453|   616k|}
stream-parse.cpp:_ZL20compressed_src_closeP12pgp_source_t:
  457|  22.2k|{
  458|  22.2k|    pgp_source_compressed_param_t *param = (pgp_source_compressed_param_t *) src->param;
  459|  22.2k|    if (!param) {
  ------------------
  |  Branch (459:9): [True: 1.13k, False: 21.1k]
  ------------------
  460|  1.13k|        return; // LCOV_EXCL_LINE
  461|  1.13k|    }
  462|       |
  463|  21.1k|    if (param->pkt.hdr.partial) {
  ------------------
  |  Branch (463:9): [True: 8.36k, False: 12.8k]
  ------------------
  464|  8.36k|        param->pkt.readsrc->close();
  465|  8.36k|        free(param->pkt.readsrc);
  466|  8.36k|        param->pkt.readsrc = NULL;
  467|  8.36k|    }
  468|       |
  469|  21.1k|#ifdef HAVE_BZLIB_H
  470|  21.1k|    if (param->alg == PGP_C_BZIP2) {
  ------------------
  |  Branch (470:9): [True: 340, False: 20.8k]
  ------------------
  471|    340|        BZ2_bzDecompressEnd(&param->bz);
  472|    340|    }
  473|  21.1k|#endif
  474|  21.1k|    if ((param->alg == PGP_C_ZIP) || (param->alg == PGP_C_ZLIB)) {
  ------------------
  |  Branch (474:9): [True: 12.7k, False: 8.41k]
  |  Branch (474:38): [True: 146, False: 8.27k]
  ------------------
  475|  12.8k|        inflateEnd(&param->z);
  476|  12.8k|    }
  477|       |
  478|  21.1k|    free(src->param);
  479|       |    src->param = NULL;
  480|  21.1k|}

_Z18signature_hash_keyRK13pgp_key_pkt_tRN3rnp4HashE13pgp_version_t:
   53|  37.4k|{
   54|  37.4k|    if (key.pub_data.empty()) {
  ------------------
  |  Branch (54:9): [True: 0, False: 37.4k]
  ------------------
   55|       |        /* call self recursively if hashed data is not filled, to overcome const restriction */
   56|      0|        pgp_key_pkt_t keycp(key, true);
   57|      0|        keycp.fill_hashed_data();
   58|      0|        signature_hash_key(keycp, hash, pgpver);
   59|      0|        return;
   60|      0|    }
   61|       |
   62|  37.4k|    switch (pgpver) {
   63|      0|    case PGP_V2:
  ------------------
  |  Branch (63:5): [True: 0, False: 37.4k]
  ------------------
   64|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   65|      0|    case PGP_V3:
  ------------------
  |  Branch (65:5): [True: 0, False: 37.4k]
  ------------------
   66|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   67|  29.8k|    case PGP_V4: {
  ------------------
  |  Branch (67:5): [True: 29.8k, False: 7.59k]
  ------------------
   68|  29.8k|        assert(key.pub_data.size() <= ((size_t) 0xffffu));
   69|  29.8k|        uint8_t hdr[3] = {0x99, 0x00, 0x00};
   70|  29.8k|        write_uint16(hdr + 1, key.pub_data.size());
   71|  29.8k|        hash.add(hdr, 3);
   72|  29.8k|        hash.add(key.pub_data);
   73|  29.8k|        break;
   74|      0|    }
   75|    660|    case PGP_V5: {
  ------------------
  |  Branch (75:5): [True: 660, False: 36.7k]
  ------------------
   76|    660|        assert(key.pub_data.size() <= (size_t) 0xffffffffu);
   77|    660|        uint8_t hdr[5] = {0x9A, 0x00, 0x00, 0x00, 0x00};
   78|    660|        write_uint32(hdr + 1, key.pub_data.size());
   79|    660|        hash.add(&hdr, 5);
   80|    660|        hash.add(key.pub_data);
   81|    660|        break;
   82|      0|    }
   83|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   84|  6.93k|    case PGP_V6: {
  ------------------
  |  Branch (84:5): [True: 6.93k, False: 30.4k]
  ------------------
   85|  6.93k|        assert(key.pub_data.size() <= (size_t) 0xffffffffu);
   86|  6.93k|        uint8_t hdr[5] = {0x9b, 0x00, 0x00, 0x00, 0x00};
   87|  6.93k|        write_uint32(hdr + 1, key.pub_data.size());
   88|  6.93k|        hash.add(hdr, sizeof(hdr));
   89|  6.93k|        hash.add(key.pub_data);
   90|  6.93k|        break;
   91|      0|    }
   92|      0|#endif
   93|      0|    default:
  ------------------
  |  Branch (93:5): [True: 0, False: 37.4k]
  ------------------
   94|      0|        RNP_LOG("unknown key/sig version: %d", (int) pgpver);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   95|      0|        throw rnp::rnp_exception(RNP_ERROR_OUT_OF_MEMORY);
   96|  37.4k|    }
   97|  37.4k|}
_ZN3pgp3pkt9Signature10parse_v2v3ER17pgp_packet_body_t:
  756|  5.53k|{
  757|       |    /* parse v2/v3-specific fields, not the whole signature */
  758|  5.53k|    uint8_t buf[16] = {};
  759|  5.53k|    if (!pkt.get(buf, 16)) {
  ------------------
  |  Branch (759:9): [True: 430, False: 5.10k]
  ------------------
  760|    430|        RNP_LOG("cannot get enough bytes");
  ------------------
  |  |   76|    430|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    430|    do {                                                                                 \
  |  |  |  |   69|    430|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 430, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    430|            break;                                                                       \
  |  |  |  |   71|    430|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  761|    430|        return RNP_ERROR_BAD_FORMAT;
  762|    430|    }
  763|       |    /* length of hashed data, 5 */
  764|  5.10k|    if (buf[0] != 5) {
  ------------------
  |  Branch (764:9): [True: 333, False: 4.76k]
  ------------------
  765|    333|        RNP_LOG("wrong length of hashed data");
  ------------------
  |  |   76|    333|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    333|    do {                                                                                 \
  |  |  |  |   69|    333|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 333, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    333|            break;                                                                       \
  |  |  |  |   71|    333|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  766|    333|        return RNP_ERROR_BAD_FORMAT;
  767|    333|    }
  768|       |    /* hashed data */
  769|  4.76k|    hashed_data.assign(buf + 1, buf + 6);
  770|       |    /* signature type */
  771|  4.76k|    type_ = (pgp_sig_type_t) buf[1];
  772|       |    /* creation time */
  773|  4.76k|    creation_time = read_uint32(&buf[2]);
  774|       |    /* signer's key id */
  775|  4.76k|    static_assert(std::tuple_size<decltype(signer)>::value == PGP_KEY_ID_SIZE,
  776|  4.76k|                  "v3 signer field size mismatch");
  777|  4.76k|    memcpy(signer.data(), &buf[6], PGP_KEY_ID_SIZE);
  ------------------
  |  |   39|  4.76k|#define PGP_KEY_ID_SIZE 8
  ------------------
  778|       |    /* public key algorithm */
  779|  4.76k|    palg = (pgp_pubkey_alg_t) buf[14];
  780|       |    /* hash algorithm */
  781|  4.76k|    halg = (pgp_hash_alg_t) buf[15];
  782|  4.76k|    return RNP_SUCCESS;
  783|  5.10k|}
_ZN3pgp3pkt9Signature16parse_subpacketsEPhmb:
  789|  56.8k|{
  790|  56.8k|    bool res = true;
  791|       |
  792|   359k|    while (len) {
  ------------------
  |  Branch (792:12): [True: 305k, False: 53.9k]
  ------------------
  793|   305k|        if (subpkts.size() >= MAX_SUBPACKETS) {
  ------------------
  |  |  785|   305k|#define MAX_SUBPACKETS 64
  ------------------
  |  Branch (793:13): [True: 195, False: 305k]
  ------------------
  794|    195|            RNP_LOG("too many signature subpackets");
  ------------------
  |  |   76|    195|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    195|    do {                                                                                 \
  |  |  |  |   69|    195|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 195, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    195|            break;                                                                       \
  |  |  |  |   71|    195|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  795|    195|            return false;
  796|    195|        }
  797|   305k|        if (len < 2) {
  ------------------
  |  Branch (797:13): [True: 428, False: 304k]
  ------------------
  798|    428|            RNP_LOG("got single byte %" PRIu8, *buf);
  ------------------
  |  |   76|    428|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    428|    do {                                                                                 \
  |  |  |  |   69|    428|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 428, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    428|            break;                                                                       \
  |  |  |  |   71|    428|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  799|    428|            return false;
  800|    428|        }
  801|       |
  802|       |        /* subpacket length */
  803|   304k|        size_t splen = *buf++;
  804|   304k|        len--;
  805|   304k|        if ((splen >= 192) && (splen < 255)) {
  ------------------
  |  Branch (805:13): [True: 1.76k, False: 303k]
  |  Branch (805:31): [True: 1.27k, False: 493]
  ------------------
  806|  1.27k|            splen = ((splen - 192) << 8) + *buf++ + 192;
  807|  1.27k|            len--;
  808|   303k|        } else if (splen == 255) {
  ------------------
  |  Branch (808:20): [True: 493, False: 303k]
  ------------------
  809|    493|            if (len < 4) {
  ------------------
  |  Branch (809:17): [True: 204, False: 289]
  ------------------
  810|    204|                RNP_LOG("got 4-byte len but only %zu bytes in buffer", len);
  ------------------
  |  |   76|    204|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    204|    do {                                                                                 \
  |  |  |  |   69|    204|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 204, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    204|            break;                                                                       \
  |  |  |  |   71|    204|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  811|    204|                return false;
  812|    204|            }
  813|    289|            splen = read_uint32(buf);
  814|    289|            buf += 4;
  815|    289|            len -= 4;
  816|    289|        }
  817|       |
  818|   304k|        if (!splen) {
  ------------------
  |  Branch (818:13): [True: 500, False: 304k]
  ------------------
  819|    500|            RNP_LOG("got subpacket with 0 length");
  ------------------
  |  |   76|    500|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    500|    do {                                                                                 \
  |  |  |  |   69|    500|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 500, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    500|            break;                                                                       \
  |  |  |  |   71|    500|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  820|    500|            return false;
  821|    500|        }
  822|       |
  823|       |        /* subpacket data */
  824|   304k|        if (len < splen) {
  ------------------
  |  Branch (824:13): [True: 1.58k, False: 302k]
  ------------------
  825|  1.58k|            RNP_LOG("got subpacket len %zu, while only %zu bytes left", splen, len);
  ------------------
  |  |   76|  1.58k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.58k|    do {                                                                                 \
  |  |  |  |   69|  1.58k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.58k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.58k|            break;                                                                       \
  |  |  |  |   71|  1.58k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  826|  1.58k|            return false;
  827|  1.58k|        }
  828|       |
  829|   302k|        auto subpkt = sigsub::Raw::create(buf, splen, hashed);
  830|   302k|        if (!subpkt) {
  ------------------
  |  Branch (830:13): [True: 214k, False: 87.8k]
  ------------------
  831|   214k|            res = false;
  832|   214k|        } else {
  833|  87.8k|            subpkts.items.push_back(std::move(subpkt));
  834|  87.8k|        }
  835|   302k|        len -= splen;
  836|   302k|        buf += splen;
  837|   302k|    }
  838|  53.9k|    return res;
  839|  56.8k|}
_ZN3pgp3pkt9Signature14get_subpkt_lenER17pgp_packet_body_tRm:
  843|  59.3k|{
  844|  59.3k|    switch (version) {
  845|  44.5k|    case PGP_V4:
  ------------------
  |  Branch (845:5): [True: 44.5k, False: 14.7k]
  ------------------
  846|  53.1k|    case PGP_V5: {
  ------------------
  |  Branch (846:5): [True: 8.58k, False: 50.7k]
  ------------------
  847|  53.1k|        uint16_t len = 0;
  848|  53.1k|        if (!pkt.get(len)) {
  ------------------
  |  Branch (848:13): [True: 385, False: 52.7k]
  ------------------
  849|    385|            return false;
  850|    385|        }
  851|  52.7k|        splen = len;
  852|  52.7k|        return true;
  853|  53.1k|    }
  854|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  855|  6.15k|    case PGP_V6: {
  ------------------
  |  Branch (855:5): [True: 6.15k, False: 53.1k]
  ------------------
  856|  6.15k|        uint32_t len = 0;
  857|  6.15k|        if (!pkt.get(len)) {
  ------------------
  |  Branch (857:13): [True: 252, False: 5.90k]
  ------------------
  858|    252|            return false;
  859|    252|        }
  860|  5.90k|        splen = len;
  861|  5.90k|        return true;
  862|  6.15k|    }
  863|      0|#endif
  864|      0|    default:
  ------------------
  |  Branch (864:5): [True: 0, False: 59.3k]
  ------------------
  865|      0|        RNP_LOG("unsupported signature version: %d", (int) version);
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  866|      0|        return false;
  867|  59.3k|    }
  868|  59.3k|}
_ZN3pgp3pkt9Signature10parse_v4upER17pgp_packet_body_t:
  896|  32.8k|{
  897|       |    /* parse v4 (and up) specific fields, not the whole signature */
  898|  32.8k|    uint8_t buf[3];
  899|  32.8k|    if (!pkt.get(buf, 3)) {
  ------------------
  |  Branch (899:9): [True: 700, False: 32.1k]
  ------------------
  900|    700|        RNP_LOG("cannot get first 3 bytes");
  ------------------
  |  |   76|    700|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    700|    do {                                                                                 \
  |  |  |  |   69|    700|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 700, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    700|            break;                                                                       \
  |  |  |  |   71|    700|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  901|    700|        return RNP_ERROR_BAD_FORMAT;
  902|    700|    }
  903|       |
  904|       |    /* signature type */
  905|  32.1k|    type_ = (pgp_sig_type_t) buf[0];
  906|       |    /* public key algorithm */
  907|  32.1k|    palg = (pgp_pubkey_alg_t) buf[1];
  908|       |    /* hash algorithm */
  909|  32.1k|    halg = (pgp_hash_alg_t) buf[2];
  910|       |    /* hashed subpackets length */
  911|       |
  912|  32.1k|    size_t splen = 0;
  913|  32.1k|    auto   hash_begin = pkt.cur();
  914|  32.1k|    if (!get_subpkt_len(pkt, splen)) {
  ------------------
  |  Branch (914:9): [True: 637, False: 31.4k]
  ------------------
  915|    637|        RNP_LOG("cannot get hashed len");
  ------------------
  |  |   76|    637|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    637|    do {                                                                                 \
  |  |  |  |   69|    637|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 637, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    637|            break;                                                                       \
  |  |  |  |   71|    637|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  916|    637|        return RNP_ERROR_BAD_FORMAT;
  917|    637|    }
  918|  31.4k|    size_t splen_size = pkt.cur() - hash_begin;
  919|       |    /* hashed subpackets length + splen_size bytes of length of unhashed subpackets */
  920|  31.4k|    if (pkt.left() < splen + splen_size) {
  ------------------
  |  Branch (920:9): [True: 644, False: 30.8k]
  ------------------
  921|    644|        RNP_LOG("wrong packet or hashed subpackets length");
  ------------------
  |  |   76|    644|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    644|    do {                                                                                 \
  |  |  |  |   69|    644|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 644, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    644|            break;                                                                       \
  |  |  |  |   71|    644|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  922|    644|        return RNP_ERROR_BAD_FORMAT;
  923|    644|    }
  924|       |    /* building hashed data */
  925|  30.8k|    size_t hlen = 4 + splen + splen_size;
  926|  30.8k|    hashed_data.resize(hlen);
  927|  30.8k|    hashed_data[0] = version;
  928|  30.8k|    static_assert(sizeof(buf) == 3, "Wrong signature header size.");
  929|  30.8k|    pkt.skip_back(3 + splen_size);
  930|       |
  931|  30.8k|    if (!pkt.get(hashed_data.data() + 1, hlen - 1)) {
  ------------------
  |  Branch (931:9): [True: 0, False: 30.8k]
  ------------------
  932|      0|        RNP_LOG("cannot get hashed subpackets data");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  933|      0|        return RNP_ERROR_BAD_FORMAT;
  934|      0|    }
  935|       |    /* parsing hashed subpackets */
  936|  30.8k|    if (!parse_subpackets(hashed_data.data() + 4 + splen_size, splen, true)) {
  ------------------
  |  Branch (936:9): [True: 3.58k, False: 27.2k]
  ------------------
  937|  3.58k|        RNP_LOG("failed to parse hashed subpackets");
  ------------------
  |  |   76|  3.58k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.58k|    do {                                                                                 \
  |  |  |  |   69|  3.58k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.58k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.58k|            break;                                                                       \
  |  |  |  |   71|  3.58k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  938|  3.58k|        return RNP_ERROR_BAD_FORMAT;
  939|  3.58k|    }
  940|       |
  941|       |    /* reading unhashed subpackets */
  942|  27.2k|    if (!get_subpkt_len(pkt, splen)) {
  ------------------
  |  Branch (942:9): [True: 0, False: 27.2k]
  ------------------
  943|      0|        RNP_LOG("cannot get unhashed len");
  ------------------
  |  |   76|      0|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|      0|    do {                                                                                 \
  |  |  |  |   69|      0|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|      0|            break;                                                                       \
  |  |  |  |   71|      0|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  944|      0|        return RNP_ERROR_BAD_FORMAT;
  945|      0|    }
  946|  27.2k|    if (pkt.left() < splen) {
  ------------------
  |  Branch (946:9): [True: 1.20k, False: 26.0k]
  ------------------
  947|  1.20k|        RNP_LOG("not enough data for unhashed subpackets");
  ------------------
  |  |   76|  1.20k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.20k|    do {                                                                                 \
  |  |  |  |   69|  1.20k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.20k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.20k|            break;                                                                       \
  |  |  |  |   71|  1.20k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  948|  1.20k|        return RNP_ERROR_BAD_FORMAT;
  949|  1.20k|    }
  950|  26.0k|    if (!parse_subpackets(pkt.cur(), splen, false)) {
  ------------------
  |  Branch (950:9): [True: 427, False: 25.6k]
  ------------------
  951|    427|        RNP_LOG("failed to parse unhashed subpackets");
  ------------------
  |  |   76|    427|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    427|    do {                                                                                 \
  |  |  |  |   69|    427|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 427, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    427|            break;                                                                       \
  |  |  |  |   71|    427|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  952|    427|        return RNP_ERROR_BAD_FORMAT;
  953|    427|    }
  954|  25.6k|    pkt.skip(splen);
  955|  25.6k|    return RNP_SUCCESS;
  956|  26.0k|}
_ZN3pgp3pkt9Signature5parseER17pgp_packet_body_t:
  960|  40.0k|{
  961|  40.0k|    uint8_t ver = 0;
  962|  40.0k|    if (!pkt.get(ver)) {
  ------------------
  |  Branch (962:9): [True: 340, False: 39.7k]
  ------------------
  963|    340|        return RNP_ERROR_BAD_FORMAT;
  964|    340|    }
  965|  39.7k|    version = (pgp_version_t) ver;
  966|       |
  967|       |    /* v3 or v4 or v6 signature body */
  968|  39.7k|    rnp_result_t res;
  969|  39.7k|    switch (ver) {
  970|  1.59k|    case PGP_V2:
  ------------------
  |  Branch (970:5): [True: 1.59k, False: 38.1k]
  ------------------
  971|  1.59k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.59k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  972|  5.53k|    case PGP_V3:
  ------------------
  |  Branch (972:5): [True: 3.93k, False: 35.8k]
  ------------------
  973|  5.53k|        res = parse_v2v3(pkt);
  974|  5.53k|        break;
  975|  23.5k|    case PGP_V4:
  ------------------
  |  Branch (975:5): [True: 23.5k, False: 16.1k]
  ------------------
  976|  23.5k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  23.5k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  977|  29.1k|    case PGP_V5:
  ------------------
  |  Branch (977:5): [True: 5.60k, False: 34.1k]
  ------------------
  978|  29.1k|#if defined(ENABLE_CRYPTO_REFRESH)
  979|  29.1k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  29.1k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  980|  32.8k|    case PGP_V6:
  ------------------
  |  Branch (980:5): [True: 3.60k, False: 36.1k]
  ------------------
  981|  32.8k|#endif
  982|  32.8k|        res = parse_v4up(pkt);
  983|  32.8k|        break;
  984|  1.41k|    default:
  ------------------
  |  Branch (984:5): [True: 1.41k, False: 38.3k]
  ------------------
  985|  1.41k|        RNP_LOG("unknown signature version: %d", (int) ver);
  ------------------
  |  |   76|  1.41k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.41k|    do {                                                                                 \
  |  |  |  |   69|  1.41k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.41k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.41k|            break;                                                                       \
  |  |  |  |   71|  1.41k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  986|  1.41k|        res = RNP_ERROR_BAD_FORMAT;
  987|  39.7k|    }
  988|       |
  989|  39.7k|    if (res) {
  ------------------
  |  Branch (989:9): [True: 9.37k, False: 30.3k]
  ------------------
  990|  9.37k|        return res;
  991|  9.37k|    }
  992|       |
  993|       |    /* left 16 bits of the hash */
  994|  30.3k|    if (!pkt.get(lbits.data(), 2)) {
  ------------------
  |  Branch (994:9): [True: 236, False: 30.1k]
  ------------------
  995|    236|        RNP_LOG("not enough data for hash left bits");
  ------------------
  |  |   76|    236|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    236|    do {                                                                                 \
  |  |  |  |   69|    236|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 236, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    236|            break;                                                                       \
  |  |  |  |   71|    236|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  996|    236|        return RNP_ERROR_BAD_FORMAT;
  997|    236|    }
  998|       |
  999|  30.1k|#if defined(ENABLE_CRYPTO_REFRESH)
 1000|  30.1k|    if (ver == PGP_V6) {
  ------------------
  |  Branch (1000:9): [True: 2.76k, False: 27.3k]
  ------------------
 1001|  2.76k|        uint8_t salt_size = 0;
 1002|  2.76k|        if (!pkt.get(salt_size)) {
  ------------------
  |  Branch (1002:13): [True: 74, False: 2.69k]
  ------------------
 1003|     74|            RNP_LOG("not enough data for v6 salt size octet");
  ------------------
  |  |   76|     74|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     74|    do {                                                                                 \
  |  |  |  |   69|     74|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 74, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     74|            break;                                                                       \
  |  |  |  |   71|     74|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1004|     74|            return RNP_ERROR_BAD_FORMAT;
 1005|     74|        }
 1006|  2.69k|        if (salt_size != rnp::Hash::size(halg) / 2) {
  ------------------
  |  Branch (1006:13): [True: 2.00k, False: 692]
  ------------------
 1007|  2.00k|            RNP_LOG("invalid salt size");
  ------------------
  |  |   76|  2.00k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.00k|    do {                                                                                 \
  |  |  |  |   69|  2.00k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.00k|            break;                                                                       \
  |  |  |  |   71|  2.00k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1008|  2.00k|            return RNP_ERROR_BAD_FORMAT;
 1009|  2.00k|        }
 1010|    692|        if (!pkt.get(salt, salt_size)) {
  ------------------
  |  Branch (1010:13): [True: 202, False: 490]
  ------------------
 1011|    202|            RNP_LOG("not enough data for v6 signature salt");
  ------------------
  |  |   76|    202|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    202|    do {                                                                                 \
  |  |  |  |   69|    202|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 202, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    202|            break;                                                                       \
  |  |  |  |   71|    202|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1012|    202|            return RNP_ERROR_BAD_FORMAT;
 1013|    202|        }
 1014|    692|    }
 1015|  27.8k|#endif
 1016|       |
 1017|       |    /* raw signature material */
 1018|       |    /* we cannot fail here */
 1019|  27.8k|    pkt.get(material_buf, pkt.left());
 1020|       |    /* check whether it can be parsed */
 1021|  27.8k|    if (!parse_material()) {
  ------------------
  |  Branch (1021:9): [True: 6.82k, False: 21.0k]
  ------------------
 1022|  6.82k|        return RNP_ERROR_BAD_FORMAT;
 1023|  6.82k|    }
 1024|  21.0k|    return RNP_SUCCESS;
 1025|  27.8k|}
_ZN3pgp3pkt9Signature5parseER12pgp_source_t:
 1029|  47.2k|{
 1030|  47.2k|    pgp_packet_body_t pkt(PGP_PKT_SIGNATURE);
 1031|  47.2k|    rnp_result_t      res = pkt.read(src);
 1032|  47.2k|    if (res) {
  ------------------
  |  Branch (1032:9): [True: 11.1k, False: 36.1k]
  ------------------
 1033|  11.1k|        return res;
 1034|  11.1k|    }
 1035|  36.1k|    return parse(pkt);
 1036|  47.2k|}
_ZNK3pgp3pkt9Signature14parse_materialEv:
 1040|  46.7k|{
 1041|  46.7k|    auto sig = SigMaterial::create(palg, halg);
 1042|  46.7k|    if (!sig) {
  ------------------
  |  Branch (1042:9): [True: 513, False: 46.2k]
  ------------------
 1043|    513|        return nullptr;
 1044|    513|    }
 1045|  46.2k|    pgp_packet_body_t pkt(material_buf);
 1046|  46.2k|    if (!sig->parse(pkt)) {
  ------------------
  |  Branch (1046:9): [True: 4.98k, False: 41.2k]
  ------------------
 1047|  4.98k|        return nullptr;
 1048|  4.98k|    }
 1049|  41.2k|    if (pkt.left()) {
  ------------------
  |  Branch (1049:9): [True: 1.33k, False: 39.8k]
  ------------------
 1050|  1.33k|        RNP_LOG("extra %zu bytes in pk packet", pkt.left());
  ------------------
  |  |   76|  1.33k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.33k|    do {                                                                                 \
  |  |  |  |   69|  1.33k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.33k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.33k|            break;                                                                       \
  |  |  |  |   71|  1.33k|        (void) fprintf((fd), "[%s() %s:%d] ", __func__, __SOURCE_PATH_FILE__, __LINE__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define __SOURCE_PATH_FILE__ (&(__FILE__[SOURCE_PATH_SIZE + 3]))
  |  |  |  |  ------------------
  |  |  |  |   72|      0|        (void) fprintf((fd), __VA_ARGS__);                                               \
  |  |  |  |   73|      0|        (void) fprintf((fd), "\n");                                                      \
  |  |  |  |   74|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (74:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1051|  1.33k|        return nullptr;
 1052|  1.33k|    }
 1053|  39.8k|    return sig;
 1054|  41.2k|}

_ZN3pgp3pkt9SignatureC2Ev:
   77|  51.2k|        : type_(PGP_SIG_BINARY), version(PGP_VUNKNOWN), palg(PGP_PKA_NOTHING),
   78|  51.2k|          halg(PGP_HASH_UNKNOWN), creation_time(0){};
_ZNK3pgp3pkt9Signature4typeEv:
   85|  18.8k|    {
   86|  18.8k|        return type_;
   87|  18.8k|    };