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

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

_ZN5Botan13reverse_bytesEj:
   35|  1.96M|inline constexpr uint32_t reverse_bytes(uint32_t x) {
   36|  1.96M|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap32)
   37|  1.96M|   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|  1.96M|}
_ZN5Botan13reverse_bytesEm:
   50|  6.00k|inline constexpr uint64_t reverse_bytes(uint64_t x) {
   51|  6.00k|#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_bswap64)
   52|  6.00k|   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|  6.00k|}

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

_ZN5Botan2CT4MaskIhEC2Eh:
  286|   178M|      constexpr Mask(T m) : m_mask(m) {}
_ZNK5Botan2CT4MaskIhE5valueEv:
  283|   178M|      constexpr T value() const { return m_mask; }
_ZN5Botan2CT4MaskIhE5is_ltEhh:
  139|   178M|      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|   178M|      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|  48.0k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  48.0k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  48.0k|   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|  48.0k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 48.0k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  48.0k|   } 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|  48.0k|      } else if constexpr(is_opposite(endianness)) {
  506|  48.0k|         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|  48.0k|   }
  512|  48.0k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ENS0_10AutoDetectETkNS0_20unsigned_integralishEmQoosr3stdE7same_asIS3_T0_Esr3stdE7same_asIT1_S4_EEEvS5_Ph:
  677|  6.00k|inline constexpr void store_any(T in, uint8_t out[]) {
  678|       |   // asserts that *out points to enough bytes to write into
  679|  6.00k|   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  680|  6.00k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ENS0_10AutoDetectETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm8EEEQsr3stdE7same_asIS3_T0_EEEvT1_OT2_:
  612|  6.00k|inline constexpr void store_any(T in, OutR&& out_range) {
  613|  6.00k|   store_any<endianness, T>(in, std::forward<OutR>(out_range));
  614|  6.00k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0ETkNSt3__117unsigned_integralEmTkNS_6ranges23contiguous_output_rangeIhEENS3_4spanIhLm8EEEEEvT0_OT1_:
  491|  6.00k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  6.00k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  6.00k|   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|  6.00k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 6.00k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  6.00k|   } 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|  6.00k|      } else if constexpr(is_opposite(endianness)) {
  506|  6.00k|         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|  6.00k|   }
  512|  6.00k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS0_20unsigned_integralishEmQoosr3stdE7same_asIS3_T0_Esr3stdE7same_asIT1_S4_EEEvS5_Ph:
  677|  3.05k|inline constexpr void store_any(T in, uint8_t out[]) {
  678|       |   // asserts that *out points to enough bytes to write into
  679|  3.05k|   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
  680|  3.05k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ENS0_10AutoDetectETkNS0_20unsigned_integralishEmTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm8EEEQsr3stdE7same_asIS3_T0_EEEvT1_OT2_:
  612|  3.05k|inline constexpr void store_any(T in, OutR&& out_range) {
  613|  3.05k|   store_any<endianness, T>(in, std::forward<OutR>(out_range));
  614|  3.05k|}
_ZN5Botan6detail9store_anyILNS0_10EndiannessE1ETkNSt3__117unsigned_integralEmTkNS_6ranges23contiguous_output_rangeIhEENS3_4spanIhLm8EEEEEvT0_OT1_:
  491|  3.05k|inline constexpr void store_any(InT in, OutR&& out_range) {
  492|  3.05k|   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
  493|  3.05k|   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.05k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (498:7): [Folded, False: 3.05k]
  ------------------
  499|      0|      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
  500|  3.05k|   } else {
  501|       |      if constexpr(sizeof(InT) == 1) {
  502|       |         out[0] = static_cast<uint8_t>(in);
  503|  3.05k|      } else if constexpr(is_native(endianness)) {
  504|  3.05k|         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.05k|   }
  512|  3.05k|}
_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|  1.91M|inline constexpr OutT load_any(InR&& in_range) {
  249|  1.91M|   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
  250|  1.91M|   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|  1.91M|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (255:7): [Folded, False: 1.91M]
  ------------------
  256|      0|      return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
  257|  1.91M|   } 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|  1.91M|      } else if constexpr(is_opposite(endianness)) {
  263|  1.91M|         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|  1.91M|   }
  269|  1.91M|}
_ZN5Botan6detail33copy_out_any_word_aligned_portionILNS0_10EndiannessE0ETkNS0_20unsigned_integralishEjEEmRNSt3__14spanIhLm18446744073709551615EEERNS4_IKT0_Lm18446744073709551615EEE:
  718|  6.00k|size_t copy_out_any_word_aligned_portion(std::span<uint8_t>& out, std::span<const T>& in) {
  719|  6.00k|   const size_t full_words = out.size() / sizeof(T);
  720|  6.00k|   const size_t full_word_bytes = full_words * sizeof(T);
  721|  6.00k|   const size_t remaining_bytes = out.size() - full_word_bytes;
  722|  6.00k|   BOTAN_ASSERT_NOMSG(in.size_bytes() >= full_word_bytes + remaining_bytes);
  ------------------
  |  |   60|  6.00k|   do {                                                                     \
  |  |   61|  6.00k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 6.00k]
  |  |  ------------------
  |  |   62|  6.00k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  6.00k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 6.00k]
  |  |  ------------------
  ------------------
  723|       |
  724|       |   // copy full words
  725|  6.00k|   store_any<endianness, T>(out.first(full_word_bytes), in.first(full_words));
  726|  6.00k|   out = out.subspan(full_word_bytes);
  727|  6.00k|   in = in.subspan(full_words);
  728|       |
  729|  6.00k|   return remaining_bytes;
  730|  6.00k|}
_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|  6.00k|inline constexpr void store_any(OutR&& out, InR&& in) {
  570|  6.00k|   ranges::assert_equal_byte_lengths(out, in);
  571|       |
  572|  6.00k|   auto store_elementwise = [&] {
  573|  6.00k|      using element_type = std::ranges::range_value_t<InR>;
  574|  6.00k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  6.00k|      std::span<uint8_t> out_s(out);
  576|  6.00k|      for(auto in_elem : in) {
  577|  6.00k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  6.00k|         out_s = out_s.subspan(bytes_per_element);
  579|  6.00k|      }
  580|  6.00k|   };
  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|  6.00k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (585:7): [Folded, False: 6.00k]
  ------------------
  586|      0|      store_elementwise();
  587|  6.00k|   } else {
  588|       |      if constexpr(is_native(endianness)) {
  589|       |         typecast_copy(out, in);
  590|  6.00k|      } else {
  591|  6.00k|         store_elementwise();
  592|  6.00k|      }
  593|  6.00k|   }
  594|  6.00k|}
_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|  6.00k|   auto store_elementwise = [&] {
  573|  6.00k|      using element_type = std::ranges::range_value_t<InR>;
  574|  6.00k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  6.00k|      std::span<uint8_t> out_s(out);
  576|  48.0k|      for(auto in_elem : in) {
  ------------------
  |  Branch (576:24): [True: 48.0k, False: 6.00k]
  ------------------
  577|  48.0k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  48.0k|         out_s = out_s.subspan(bytes_per_element);
  579|  48.0k|      }
  580|  6.00k|   };
_ZN5Botan6detail9store_anyILNS0_10EndiannessE0EjTkNS_6ranges23contiguous_output_rangeIhEENSt3__14spanIhLm4EEETpTkNS0_20unsigned_integralishEJjEQaagtsZT2_Li0Eooaasr3stdE7same_asINS0_10AutoDetectET0_E10all_same_vIDpT2_Eaa20unsigned_integralishIS9_E10all_same_vIS9_SB_EEEvOT1_SB_:
  548|  48.0k|inline constexpr void store_any(OutR&& out, Ts... ins) {
  549|  48.0k|   ranges::assert_exact_byte_length<(sizeof(Ts) + ...)>(out);
  550|  48.0k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  551|  48.0k|      store_any<endianness, T>(i, o.subspan(off).template first<sizeof(T)>());
  552|  48.0k|      off += sizeof(T);
  553|  48.0k|   };
  554|       |
  555|  48.0k|   (store_one(std::span{out}, ins), ...);
  556|  48.0k|}
_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|  48.0k|   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
  551|  48.0k|      store_any<endianness, T>(i, o.subspan(off).template first<sizeof(T)>());
  552|  48.0k|      off += sizeof(T);
  553|  48.0k|   };
_ZN5Botan6detail8load_anyILNS0_10EndiannessE0ETkNS0_20unsigned_integralishEjEET0_PKhm:
  421|  1.91M|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|  1.91M|   constexpr size_t out_size = sizeof(OutT);
  424|  1.91M|   return load_any<endianness, OutT>(std::span<const uint8_t, out_size>(in + off * out_size, out_size));
  425|  1.91M|}
_ZN5Botan7load_beIjJPKhiEEEDaDpOT0_:
  471|  1.91M|inline constexpr auto load_be(ParamTs&&... params) {
  472|  1.91M|   return detail::load_any<detail::Endianness::Big, OutT>(std::forward<ParamTs>(params)...);
  473|  1.91M|}
_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.59M|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.59M|   load_any<endianness, OutT>(std::span<T>(out, count), std::span<const uint8_t>(in, count * sizeof(T)));
  453|  2.59M|}
_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.59M|inline constexpr void load_any(OutR&& out, InR&& in) {
  323|  2.59M|   ranges::assert_equal_byte_lengths(out, in);
  324|       |
  325|  2.59M|   auto load_elementwise = [&] {
  326|  2.59M|      using element_type = std::ranges::range_value_t<OutR>;
  327|  2.59M|      constexpr size_t bytes_per_element = sizeof(element_type);
  328|  2.59M|      std::span<const uint8_t> in_s(in);
  329|  2.59M|      for(auto& out_elem : out) {
  330|  2.59M|         out_elem = load_any<endianness, element_type>(in_s.template first<bytes_per_element>());
  331|  2.59M|         in_s = in_s.subspan(bytes_per_element);
  332|  2.59M|      }
  333|  2.59M|   };
  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.59M|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (338:7): [Folded, False: 2.59M]
  ------------------
  339|      0|      load_elementwise();
  340|  2.59M|   } else {
  341|  2.59M|      if constexpr(is_native(endianness)) {
  342|  2.59M|         typecast_copy(out, in);
  343|       |      } else {
  344|       |         load_elementwise();
  345|       |      }
  346|  2.59M|   }
  347|  2.59M|}
_ZN5Botan7load_leINS_6detail10AutoDetectEJPjPKhmEEEDaDpOT0_:
  462|  5.63k|inline constexpr auto load_le(ParamTs&&... params) {
  463|  5.63k|   return detail::load_any<detail::Endianness::Little, OutT>(std::forward<ParamTs>(params)...);
  464|  5.63k|}
_ZN5Botan8store_leINS_6detail10AutoDetectEJRKmPhEEEDaDpOT0_:
  702|  3.05k|inline constexpr auto store_le(ParamTs&&... params) {
  703|  3.05k|   return detail::store_any<detail::Endianness::Little, ModifierT>(std::forward<ParamTs>(params)...);
  704|  3.05k|}
_ZN5Botan11copy_out_leITkNS_6ranges14spanable_rangeERNSt3__16vectorIjNS_16secure_allocatorIjEEEEEEvNS2_4spanIhLm18446744073709551615EEEOT_:
  755|  3.05k|void copy_out_le(std::span<uint8_t> out, InR&& in) {
  756|  3.05k|   using T = std::ranges::range_value_t<InR>;
  757|  3.05k|   std::span<const T> in_s{in};
  758|  3.05k|   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.05k|   for(size_t i = 0; i < remaining_bytes; ++i) {
  ------------------
  |  Branch (761:22): [True: 0, False: 3.05k]
  ------------------
  762|      0|      out[i] = get_byte_var(sizeof(T) - 1 - i, in_s.front());
  763|      0|   }
  764|  3.05k|}
_ZN5Botan6detail33copy_out_any_word_aligned_portionILNS0_10EndiannessE1ETkNS0_20unsigned_integralishEjEEmRNSt3__14spanIhLm18446744073709551615EEERNS4_IKT0_Lm18446744073709551615EEE:
  718|  3.05k|size_t copy_out_any_word_aligned_portion(std::span<uint8_t>& out, std::span<const T>& in) {
  719|  3.05k|   const size_t full_words = out.size() / sizeof(T);
  720|  3.05k|   const size_t full_word_bytes = full_words * sizeof(T);
  721|  3.05k|   const size_t remaining_bytes = out.size() - full_word_bytes;
  722|  3.05k|   BOTAN_ASSERT_NOMSG(in.size_bytes() >= full_word_bytes + remaining_bytes);
  ------------------
  |  |   60|  3.05k|   do {                                                                     \
  |  |   61|  3.05k|      if(!(expr))                                                           \
  |  |  ------------------
  |  |  |  Branch (61:10): [True: 0, False: 3.05k]
  |  |  ------------------
  |  |   62|  3.05k|         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \
  |  |   63|  3.05k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (63:12): [Folded, False: 3.05k]
  |  |  ------------------
  ------------------
  723|       |
  724|       |   // copy full words
  725|  3.05k|   store_any<endianness, T>(out.first(full_word_bytes), in.first(full_words));
  726|  3.05k|   out = out.subspan(full_word_bytes);
  727|  3.05k|   in = in.subspan(full_words);
  728|       |
  729|  3.05k|   return remaining_bytes;
  730|  3.05k|}
_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.05k|inline constexpr void store_any(OutR&& out, InR&& in) {
  570|  3.05k|   ranges::assert_equal_byte_lengths(out, in);
  571|       |
  572|  3.05k|   auto store_elementwise = [&] {
  573|  3.05k|      using element_type = std::ranges::range_value_t<InR>;
  574|  3.05k|      constexpr size_t bytes_per_element = sizeof(element_type);
  575|  3.05k|      std::span<uint8_t> out_s(out);
  576|  3.05k|      for(auto in_elem : in) {
  577|  3.05k|         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
  578|  3.05k|         out_s = out_s.subspan(bytes_per_element);
  579|  3.05k|      }
  580|  3.05k|   };
  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.05k|   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
  ------------------
  |  Branch (585:7): [Folded, False: 3.05k]
  ------------------
  586|      0|      store_elementwise();
  587|  3.05k|   } else {
  588|  3.05k|      if constexpr(is_native(endianness)) {
  589|  3.05k|         typecast_copy(out, in);
  590|       |      } else {
  591|       |         store_elementwise();
  592|       |      }
  593|  3.05k|   }
  594|  3.05k|}
_ZN5Botan8store_beINS_6detail10AutoDetectEJRKmPhEEEDaDpOT0_:
  711|  6.00k|inline constexpr auto store_be(ParamTs&&... params) {
  712|  6.00k|   return detail::store_any<detail::Endianness::Big, ModifierT>(std::forward<ParamTs>(params)...);
  713|  6.00k|}
_ZN5Botan11copy_out_beITkNS_6ranges14spanable_rangeERNSt3__16vectorIjNS_16secure_allocatorIjEEEEEEvNS2_4spanIhLm18446744073709551615EEEOT_:
  739|  6.00k|void copy_out_be(std::span<uint8_t> out, InR&& in) {
  740|  6.00k|   using T = std::ranges::range_value_t<InR>;
  741|  6.00k|   std::span<const T> in_s{in};
  742|  6.00k|   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|  6.00k|   for(size_t i = 0; i < remaining_bytes; ++i) {
  ------------------
  |  Branch (745:22): [True: 0, False: 6.00k]
  ------------------
  746|      0|      out[i] = get_byte_var(i, in_s.front());
  747|      0|   }
  748|  6.00k|}

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

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

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

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

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

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

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

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

_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIhLm4EEEEEvOT0_:
   97|  96.1k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  96.1k|   const std::span s{r};
   99|  96.1k|   if constexpr(statically_spanable_range<R>) {
  100|  96.1k|      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|  96.1k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm4EEETpTkNS0_14spanable_rangeEJRNS3_IKjLm1EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  48.0k|{
  119|  48.0k|   const std::span s0{r0};
  120|       |
  121|  48.0k|   if constexpr(statically_spanable_range<R0>) {
  122|  48.0k|      constexpr size_t expected_size = s0.size_bytes();
  123|  48.0k|      (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|  48.0k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIKjLm1EEEEEvOT0_:
   97|  48.0k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  48.0k|   const std::span s{r};
   99|  48.0k|   if constexpr(statically_spanable_range<R>) {
  100|  48.0k|      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|  48.0k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm4EEEEEmOT_:
   84|  48.0k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  48.0k|   return std::span{r}.size_bytes();
   86|  48.0k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeERNSt3__14spanIhLm8EEEEEvOT0_:
   97|  9.06k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  9.06k|   const std::span s{r};
   99|  9.06k|   if constexpr(statically_spanable_range<R>) {
  100|  9.06k|      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|  9.06k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm8EEETpTkNS0_14spanable_rangeEJRNS3_IKmLm1EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  9.06k|{
  119|  9.06k|   const std::span s0{r0};
  120|       |
  121|  9.06k|   if constexpr(statically_spanable_range<R0>) {
  122|  9.06k|      constexpr size_t expected_size = s0.size_bytes();
  123|  9.06k|      (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|  9.06k|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm8ETkNS0_14spanable_rangeERNSt3__14spanIKmLm1EEEEEvOT0_:
   97|  9.06k|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  9.06k|   const std::span s{r};
   99|  9.06k|   if constexpr(statically_spanable_range<R>) {
  100|  9.06k|      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|  9.06k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm8EEEEEmOT_:
   84|  9.06k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  9.06k|   return std::span{r}.size_bytes();
   86|  9.06k|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIjLm18446744073709551615EEETpTkNS0_14spanable_rangeEJRNS3_IKhLm18446744073709551615EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  5.19M|{
  119|  5.19M|   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.19M|   } else {
  125|  5.19M|      const size_t expected_size = s0.size_bytes();
  126|  5.19M|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  5.19M|   do {                                                          \
  |  |   31|  5.19M|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 5.19M]
  |  |  ------------------
  |  |   32|  5.19M|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  5.19M|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded, False: 5.19M]
  |  |  ------------------
  ------------------
  127|  5.19M|                      "memory regions don't have equal lengths");
  128|  5.19M|   }
  129|  5.19M|}
_ZN5Botan6ranges24assert_exact_byte_lengthILm4ETkNS0_14spanable_rangeERNSt3__14spanIKhLm4EEEEEvOT0_:
   97|  3.83M|inline constexpr void assert_exact_byte_length(R&& r) {
   98|  3.83M|   const std::span s{r};
   99|  3.83M|   if constexpr(statically_spanable_range<R>) {
  100|  3.83M|      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|  3.83M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIjLm1EEETpTkNS0_14spanable_rangeEJRNS3_IKhLm4EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  1.91M|{
  119|  1.91M|   const std::span s0{r0};
  120|       |
  121|  1.91M|   if constexpr(statically_spanable_range<R0>) {
  122|  1.91M|      constexpr size_t expected_size = s0.size_bytes();
  123|  1.91M|      (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|  1.91M|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIjLm1EEEEEmOT_:
   84|  1.91M|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  1.91M|   return std::span{r}.size_bytes();
   86|  1.91M|}
_ZN5Botan6ranges25assert_equal_byte_lengthsITkNS0_14spanable_rangeERNSt3__14spanIhLm18446744073709551615EEETpTkNS0_14spanable_rangeEJRNS3_IKjLm18446744073709551615EEEEEEvOT_DpOT0_QgtsZT0_Li0E:
  118|  12.1k|{
  119|  12.1k|   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|  12.1k|   } else {
  125|  12.1k|      const size_t expected_size = s0.size_bytes();
  126|  12.1k|      BOTAN_ARG_CHECK(((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...),
  ------------------
  |  |   30|  12.1k|   do {                                                          \
  |  |   31|  12.1k|      if(!(expr))                                                \
  |  |  ------------------
  |  |  |  Branch (31:10): [True: 0, False: 12.1k]
  |  |  ------------------
  |  |   32|  12.1k|         Botan::throw_invalid_argument(msg, __func__, __FILE__); \
  |  |   33|  12.1k|   } while(0)
  |  |  ------------------
  |  |  |  Branch (33:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  127|  12.1k|                      "memory regions don't have equal lengths");
  128|  12.1k|   }
  129|  12.1k|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIjLm18446744073709551615EEEEEmOT_:
   84|  2.59M|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  2.59M|   return std::span{r}.size_bytes();
   86|  2.59M|}
_ZN5Botan6ranges10size_bytesITkNS0_14spanable_rangeERNSt3__14spanIhLm18446744073709551615EEEEEmOT_:
   84|  3.05k|inline constexpr size_t size_bytes(spanable_range auto&& r) {
   85|  3.05k|   return std::span{r}.size_bytes();
   86|  3.05k|}

_ZN5Botan11clear_bytesEPvm:
  103|  27.6k|inline constexpr void clear_bytes(void* ptr, size_t bytes) {
  104|  27.6k|   if(bytes > 0) {
  ------------------
  |  Branch (104:7): [True: 27.6k, False: 0]
  ------------------
  105|  27.6k|      std::memset(ptr, 0, bytes);
  106|  27.6k|   }
  107|  27.6k|}
_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|  48.0k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  202|  48.0k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  203|  48.0k|}
_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|  48.0k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  48.0k|   ranges::assert_equal_byte_lengths(out, in);
  180|  48.0k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  48.0k|}
_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|  9.06k|inline constexpr void typecast_copy(ToR&& out, const FromT& in) {
  202|  9.06k|   typecast_copy(out, std::span<const FromT, 1>(&in, 1));
  203|  9.06k|}
_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|  9.06k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  9.06k|   ranges::assert_equal_byte_lengths(out, in);
  180|  9.06k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  9.06k|}
_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|  1.91M|inline constexpr ToT typecast_copy(FromR&& src) noexcept {
  213|  1.91M|   ToT dst;
  214|  1.91M|   typecast_copy(dst, src);
  215|  1.91M|   return dst;
  216|  1.91M|}
_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|  1.91M|inline constexpr void typecast_copy(ToT& out, FromR&& in) noexcept {
  191|  1.91M|   typecast_copy(std::span<ToT, 1>(&out, 1), in);
  192|  1.91M|}
_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|  1.91M|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  1.91M|   ranges::assert_equal_byte_lengths(out, in);
  180|  1.91M|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  1.91M|}
_ZN5Botan9clear_memIhEEvPT_m:
  120|  27.6k|inline constexpr void clear_mem(T* ptr, size_t n) {
  121|  27.6k|   clear_bytes(ptr, sizeof(T) * n);
  122|  27.6k|}
_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.59M|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  2.59M|   ranges::assert_equal_byte_lengths(out, in);
  180|  2.59M|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  2.59M|}
_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.05k|inline constexpr void typecast_copy(ToR&& out, FromR&& in) {
  179|  3.05k|   ranges::assert_equal_byte_lengths(out, in);
  180|  3.05k|   std::memcpy(std::ranges::data(out), std::ranges::data(in), ranges::size_bytes(out));
  181|  3.05k|}
_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|  9.06k|      T* allocate(std::size_t n) { return static_cast<T*>(allocate_memory(n, sizeof(T))); }
_ZN5Botan16secure_allocatorIjE10deallocateEPjm:
   47|  9.06k|      void deallocate(T* p, std::size_t n) { deallocate_memory(p, n, sizeof(T)); }

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

_ZN9Botan_FFI15ffi_guard_thunkEPKcRKNSt3__18functionIFivEEE:
  116|   415k|int ffi_guard_thunk(const char* func_name, const std::function<int()>& thunk) {
  117|   415k|   g_last_exception_what.clear();
  118|       |
  119|   415k|   try {
  120|   415k|      return thunk();
  121|   415k|   } 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|   415k|}
botan_scrub_mem:
  308|   222k|int botan_scrub_mem(void* mem, size_t bytes) {
  309|   222k|   Botan::secure_scrub_memory(mem, bytes);
  310|   222k|   return BOTAN_FFI_SUCCESS;
  311|   222k|}
botan_hex_encode:
  313|   415k|int botan_hex_encode(const uint8_t* in, size_t len, char* out, uint32_t flags) {
  314|   415k|   return ffi_guard_thunk(__func__, [=]() -> int {
  315|   415k|      const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
  316|   415k|      Botan::hex_encode(out, in, len, uppercase);
  317|   415k|      return BOTAN_FFI_SUCCESS;
  318|   415k|   });
  319|   415k|}
ffi.cpp:_ZZ16botan_hex_encodeENK3$_0clEv:
  314|   415k|   return ffi_guard_thunk(__func__, [=]() -> int {
  315|   415k|      const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
  ------------------
  |  |  225|   415k|#define BOTAN_FFI_HEX_LOWER_CASE 1
  ------------------
  316|   415k|      Botan::hex_encode(out, in, len, uppercase);
  317|   415k|      return BOTAN_FFI_SUCCESS;
  318|   415k|   });

_ZN5Botan5CRC248add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  175|  2.50k|void CRC24::add_data(std::span<const uint8_t> input) {
  176|  2.50k|   uint32_t tmp = m_crc;
  177|       |
  178|       |   // Input is word aligned if WA & input == 0
  179|  2.50k|   static const uint8_t WA = sizeof(size_t) - 1;
  180|       |
  181|       |   // Ensure input is word aligned before processing in parallel
  182|  4.21k|   for(; !input.empty() && (reinterpret_cast<uintptr_t>(input.data()) & WA); input = input.last(input.size() - 1)) {
  ------------------
  |  Branch (182:10): [True: 3.25k, False: 959]
  |  Branch (182:28): [True: 1.71k, False: 1.54k]
  ------------------
  183|  1.71k|      tmp = process8(tmp, input.front());
  184|  1.71k|   }
  185|       |
  186|  2.59M|   while(input.size() >= 16) {
  ------------------
  |  Branch (186:10): [True: 2.59M, False: 2.50k]
  ------------------
  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|  16.7k|   for(; !input.empty(); input = input.last(input.size() - 1)) {
  ------------------
  |  Branch (197:10): [True: 14.2k, False: 2.50k]
  ------------------
  198|  14.2k|      tmp = process8(tmp, input.front());
  199|  14.2k|   }
  200|       |
  201|  2.50k|   m_crc = tmp;
  202|  2.50k|}
_ZN5Botan5CRC2412final_resultENSt3__14spanIhLm18446744073709551615EEE:
  207|    271|void CRC24::final_result(std::span<uint8_t> output) {
  208|    271|   output[0] = get_byte<3>(m_crc);
  209|    271|   output[1] = get_byte<2>(m_crc);
  210|    271|   output[2] = get_byte<1>(m_crc);
  211|    271|   clear();
  212|    271|}
crc24.cpp:_ZN5Botan12_GLOBAL__N_18process8Ejh:
  142|  15.9k|inline uint32_t process8(uint32_t crc, uint8_t data) {
  143|  15.9k|   return (crc >> 8) ^ CRC24_T0[get_byte<3>(crc) ^ data];
  144|  15.9k|}
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|  10.8k|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|  10.8k|   if(provider.empty() == false && provider != "base") {
  ------------------
  |  Branch (118:7): [True: 0, False: 10.8k]
  |  Branch (118:36): [True: 0, False: 0]
  ------------------
  119|      0|      return nullptr;  // unknown provider
  120|      0|   }
  121|       |
  122|  10.8k|#if defined(BOTAN_HAS_SHA1)
  123|  10.8k|   if(algo_spec == "SHA-1") {
  ------------------
  |  Branch (123:7): [True: 0, False: 10.8k]
  ------------------
  124|      0|      return std::make_unique<SHA_1>();
  125|      0|   }
  126|  10.8k|#endif
  127|       |
  128|  10.8k|#if defined(BOTAN_HAS_SHA2_32)
  129|  10.8k|   if(algo_spec == "SHA-224") {
  ------------------
  |  Branch (129:7): [True: 0, False: 10.8k]
  ------------------
  130|      0|      return std::make_unique<SHA_224>();
  131|      0|   }
  132|       |
  133|  10.8k|   if(algo_spec == "SHA-256") {
  ------------------
  |  Branch (133:7): [True: 6.00k, False: 4.86k]
  ------------------
  134|  6.00k|      return std::make_unique<SHA_256>();
  135|  6.00k|   }
  136|  4.86k|#endif
  137|       |
  138|  4.86k|#if defined(BOTAN_HAS_SHA2_64)
  139|  4.86k|   if(algo_spec == "SHA-384") {
  ------------------
  |  Branch (139:7): [True: 0, False: 4.86k]
  ------------------
  140|      0|      return std::make_unique<SHA_384>();
  141|      0|   }
  142|       |
  143|  4.86k|   if(algo_spec == "SHA-512") {
  ------------------
  |  Branch (143:7): [True: 0, False: 4.86k]
  ------------------
  144|      0|      return std::make_unique<SHA_512>();
  145|      0|   }
  146|       |
  147|  4.86k|   if(algo_spec == "SHA-512-256") {
  ------------------
  |  Branch (147:7): [True: 0, False: 4.86k]
  ------------------
  148|      0|      return std::make_unique<SHA_512_256>();
  149|      0|   }
  150|  4.86k|#endif
  151|       |
  152|  4.86k|#if defined(BOTAN_HAS_RIPEMD_160)
  153|  4.86k|   if(algo_spec == "RIPEMD-160") {
  ------------------
  |  Branch (153:7): [True: 0, False: 4.86k]
  ------------------
  154|      0|      return std::make_unique<RIPEMD_160>();
  155|      0|   }
  156|  4.86k|#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.86k|#if defined(BOTAN_HAS_MD5)
  165|  4.86k|   if(algo_spec == "MD5") {
  ------------------
  |  Branch (165:7): [True: 3.05k, False: 1.81k]
  ------------------
  166|  3.05k|      return std::make_unique<MD5>();
  167|  3.05k|   }
  168|  1.81k|#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.81k|#if defined(BOTAN_HAS_CRC24)
  189|  1.81k|   if(algo_spec == "CRC24") {
  ------------------
  |  Branch (189:7): [True: 1.81k, False: 0]
  ------------------
  190|  1.81k|      return std::make_unique<CRC24>();
  191|  1.81k|   }
  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|  4.94k|void MD5::compress_n(MD5::digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
   63|  4.94k|   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3];
   64|  4.94k|   std::array<uint32_t, 16> M;
   65|       |
   66|  4.94k|   BufferSlicer in(input);
   67|       |
   68|  10.5k|   for(size_t i = 0; i != blocks; ++i) {
  ------------------
  |  Branch (68:22): [True: 5.63k, False: 4.94k]
  ------------------
   69|  5.63k|      load_le(M.data(), in.take(block_bytes).data(), M.size());
   70|       |
   71|  5.63k|      FF<7>(A, B, C, D, M[0] + 0xD76AA478);
   72|  5.63k|      FF<12>(D, A, B, C, M[1] + 0xE8C7B756);
   73|  5.63k|      FF<17>(C, D, A, B, M[2] + 0x242070DB);
   74|  5.63k|      FF<22>(B, C, D, A, M[3] + 0xC1BDCEEE);
   75|  5.63k|      FF<7>(A, B, C, D, M[4] + 0xF57C0FAF);
   76|  5.63k|      FF<12>(D, A, B, C, M[5] + 0x4787C62A);
   77|  5.63k|      FF<17>(C, D, A, B, M[6] + 0xA8304613);
   78|  5.63k|      FF<22>(B, C, D, A, M[7] + 0xFD469501);
   79|  5.63k|      FF<7>(A, B, C, D, M[8] + 0x698098D8);
   80|  5.63k|      FF<12>(D, A, B, C, M[9] + 0x8B44F7AF);
   81|  5.63k|      FF<17>(C, D, A, B, M[10] + 0xFFFF5BB1);
   82|  5.63k|      FF<22>(B, C, D, A, M[11] + 0x895CD7BE);
   83|  5.63k|      FF<7>(A, B, C, D, M[12] + 0x6B901122);
   84|  5.63k|      FF<12>(D, A, B, C, M[13] + 0xFD987193);
   85|  5.63k|      FF<17>(C, D, A, B, M[14] + 0xA679438E);
   86|  5.63k|      FF<22>(B, C, D, A, M[15] + 0x49B40821);
   87|       |
   88|  5.63k|      GG<5>(A, B, C, D, M[1] + 0xF61E2562);
   89|  5.63k|      GG<9>(D, A, B, C, M[6] + 0xC040B340);
   90|  5.63k|      GG<14>(C, D, A, B, M[11] + 0x265E5A51);
   91|  5.63k|      GG<20>(B, C, D, A, M[0] + 0xE9B6C7AA);
   92|  5.63k|      GG<5>(A, B, C, D, M[5] + 0xD62F105D);
   93|  5.63k|      GG<9>(D, A, B, C, M[10] + 0x02441453);
   94|  5.63k|      GG<14>(C, D, A, B, M[15] + 0xD8A1E681);
   95|  5.63k|      GG<20>(B, C, D, A, M[4] + 0xE7D3FBC8);
   96|  5.63k|      GG<5>(A, B, C, D, M[9] + 0x21E1CDE6);
   97|  5.63k|      GG<9>(D, A, B, C, M[14] + 0xC33707D6);
   98|  5.63k|      GG<14>(C, D, A, B, M[3] + 0xF4D50D87);
   99|  5.63k|      GG<20>(B, C, D, A, M[8] + 0x455A14ED);
  100|  5.63k|      GG<5>(A, B, C, D, M[13] + 0xA9E3E905);
  101|  5.63k|      GG<9>(D, A, B, C, M[2] + 0xFCEFA3F8);
  102|  5.63k|      GG<14>(C, D, A, B, M[7] + 0x676F02D9);
  103|  5.63k|      GG<20>(B, C, D, A, M[12] + 0x8D2A4C8A);
  104|       |
  105|  5.63k|      HH<4>(A, B, C, D, M[5] + 0xFFFA3942);
  106|  5.63k|      HH<11>(D, A, B, C, M[8] + 0x8771F681);
  107|  5.63k|      HH<16>(C, D, A, B, M[11] + 0x6D9D6122);
  108|  5.63k|      HH<23>(B, C, D, A, M[14] + 0xFDE5380C);
  109|  5.63k|      HH<4>(A, B, C, D, M[1] + 0xA4BEEA44);
  110|  5.63k|      HH<11>(D, A, B, C, M[4] + 0x4BDECFA9);
  111|  5.63k|      HH<16>(C, D, A, B, M[7] + 0xF6BB4B60);
  112|  5.63k|      HH<23>(B, C, D, A, M[10] + 0xBEBFBC70);
  113|  5.63k|      HH<4>(A, B, C, D, M[13] + 0x289B7EC6);
  114|  5.63k|      HH<11>(D, A, B, C, M[0] + 0xEAA127FA);
  115|  5.63k|      HH<16>(C, D, A, B, M[3] + 0xD4EF3085);
  116|  5.63k|      HH<23>(B, C, D, A, M[6] + 0x04881D05);
  117|  5.63k|      HH<4>(A, B, C, D, M[9] + 0xD9D4D039);
  118|  5.63k|      HH<11>(D, A, B, C, M[12] + 0xE6DB99E5);
  119|  5.63k|      HH<16>(C, D, A, B, M[15] + 0x1FA27CF8);
  120|  5.63k|      HH<23>(B, C, D, A, M[2] + 0xC4AC5665);
  121|       |
  122|  5.63k|      II<6>(A, B, C, D, M[0] + 0xF4292244);
  123|  5.63k|      II<10>(D, A, B, C, M[7] + 0x432AFF97);
  124|  5.63k|      II<15>(C, D, A, B, M[14] + 0xAB9423A7);
  125|  5.63k|      II<21>(B, C, D, A, M[5] + 0xFC93A039);
  126|  5.63k|      II<6>(A, B, C, D, M[12] + 0x655B59C3);
  127|  5.63k|      II<10>(D, A, B, C, M[3] + 0x8F0CCC92);
  128|  5.63k|      II<15>(C, D, A, B, M[10] + 0xFFEFF47D);
  129|  5.63k|      II<21>(B, C, D, A, M[1] + 0x85845DD1);
  130|  5.63k|      II<6>(A, B, C, D, M[8] + 0x6FA87E4F);
  131|  5.63k|      II<10>(D, A, B, C, M[15] + 0xFE2CE6E0);
  132|  5.63k|      II<15>(C, D, A, B, M[6] + 0xA3014314);
  133|  5.63k|      II<21>(B, C, D, A, M[13] + 0x4E0811A1);
  134|  5.63k|      II<6>(A, B, C, D, M[4] + 0xF7537E82);
  135|  5.63k|      II<10>(D, A, B, C, M[11] + 0xBD3AF235);
  136|  5.63k|      II<15>(C, D, A, B, M[2] + 0x2AD7D2BB);
  137|  5.63k|      II<21>(B, C, D, A, M[9] + 0xEB86D391);
  138|       |
  139|  5.63k|      A = (digest[0] += A);
  140|  5.63k|      B = (digest[1] += B);
  141|  5.63k|      C = (digest[2] += C);
  142|  5.63k|      D = (digest[3] += D);
  143|  5.63k|   }
  144|  4.94k|}
_ZN5Botan3MD54initERNSt3__16vectorIjNS_16secure_allocatorIjEEEE:
  146|  6.10k|void MD5::init(digest_type& digest) {
  147|  6.10k|   digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476});
  148|  6.10k|}
_ZN5Botan3MD58add_dataENSt3__14spanIKhLm18446744073709551615EEE:
  158|  15.6k|void MD5::add_data(std::span<const uint8_t> input) {
  159|  15.6k|   m_md.update(input);
  160|  15.6k|}
_ZN5Botan3MD512final_resultENSt3__14spanIhLm18446744073709551615EEE:
  162|  3.05k|void MD5::final_result(std::span<uint8_t> output) {
  163|  3.05k|   m_md.final(output);
  164|  3.05k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm7EEEvRjjjjj:
   24|  22.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  22.5k|   A += choose(B, C, D) + M;
   26|  22.5k|   A = rotl<S>(A) + B;
   27|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm12EEEvRjjjjj:
   24|  22.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  22.5k|   A += choose(B, C, D) + M;
   26|  22.5k|   A = rotl<S>(A) + B;
   27|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm17EEEvRjjjjj:
   24|  22.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  22.5k|   A += choose(B, C, D) + M;
   26|  22.5k|   A = rotl<S>(A) + B;
   27|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12FFILm22EEEvRjjjjj:
   24|  22.5k|inline void FF(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   25|  22.5k|   A += choose(B, C, D) + M;
   26|  22.5k|   A = rotl<S>(A) + B;
   27|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm5EEEvRjjjjj:
   33|  22.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  22.5k|   A += choose(D, B, C) + M;
   35|  22.5k|   A = rotl<S>(A) + B;
   36|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm9EEEvRjjjjj:
   33|  22.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  22.5k|   A += choose(D, B, C) + M;
   35|  22.5k|   A = rotl<S>(A) + B;
   36|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm14EEEvRjjjjj:
   33|  22.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  22.5k|   A += choose(D, B, C) + M;
   35|  22.5k|   A = rotl<S>(A) + B;
   36|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12GGILm20EEEvRjjjjj:
   33|  22.5k|inline void GG(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   34|  22.5k|   A += choose(D, B, C) + M;
   35|  22.5k|   A = rotl<S>(A) + B;
   36|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm4EEEvRjjjjj:
   42|  22.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  22.5k|   A += (B ^ C ^ D) + M;
   44|  22.5k|   A = rotl<S>(A) + B;
   45|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm11EEEvRjjjjj:
   42|  22.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  22.5k|   A += (B ^ C ^ D) + M;
   44|  22.5k|   A = rotl<S>(A) + B;
   45|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm16EEEvRjjjjj:
   42|  22.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  22.5k|   A += (B ^ C ^ D) + M;
   44|  22.5k|   A = rotl<S>(A) + B;
   45|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12HHILm23EEEvRjjjjj:
   42|  22.5k|inline void HH(uint32_t& A, uint32_t B, uint32_t C, uint32_t D, uint32_t M) {
   43|  22.5k|   A += (B ^ C ^ D) + M;
   44|  22.5k|   A = rotl<S>(A) + B;
   45|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm6EEEvRjjjjj:
   51|  22.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|  22.5k|   A += (C ^ (B | ~D)) + M;
   54|  22.5k|   A = rotl<S>(A) + B;
   55|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm10EEEvRjjjjj:
   51|  22.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|  22.5k|   A += (C ^ (B | ~D)) + M;
   54|  22.5k|   A = rotl<S>(A) + B;
   55|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm15EEEvRjjjjj:
   51|  22.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|  22.5k|   A += (C ^ (B | ~D)) + M;
   54|  22.5k|   A = rotl<S>(A) + B;
   55|  22.5k|}
md5.cpp:_ZN5Botan12_GLOBAL__N_12IIILm21EEEvRjjjjj:
   51|  22.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|  22.5k|   A += (C ^ (B | ~D)) + M;
   54|  22.5k|   A = rotl<S>(A) + B;
   55|  22.5k|}

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

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

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

_ZN3rnp13is_blank_lineEPKcm:
   72|  9.63k|{
   73|  10.7k|    for (size_t i = 0; i < len && line[i]; i++) {
  ------------------
  |  Branch (73:24): [True: 10.7k, False: 0]
  |  Branch (73:35): [True: 10.7k, False: 0]
  ------------------
   74|  10.7k|        if (line[i] != ' ' && line[i] != '\t' && line[i] != '\r') {
  ------------------
  |  Branch (74:13): [True: 10.5k, False: 220]
  |  Branch (74:31): [True: 9.80k, False: 742]
  |  Branch (74:50): [True: 9.63k, False: 178]
  ------------------
   75|  9.63k|            return false;
   76|  9.63k|        }
   77|  10.7k|    }
   78|      0|    return true;
   79|  9.63k|}

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

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

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

_ZN26pgp_dilithium_public_key_tC2EPKhm21dilithium_parameter_e:
   34|  4.25k|    : key_encoded_(key_encoded, key_encoded + key_encoded_len), dilithium_param_(param),
   35|  4.25k|      is_initialized_(true)
   36|  4.25k|{
   37|  4.25k|}
_Z21dilithium_pubkey_size21dilithium_parameter_e:
   76|  9.62k|{
   77|  9.62k|    switch (parameter) {
   78|  7.26k|    case dilithium_L3:
  ------------------
  |  Branch (78:5): [True: 7.26k, False: 2.35k]
  ------------------
   79|  7.26k|        return 1952;
   80|  2.35k|    case dilithium_L5:
  ------------------
  |  Branch (80:5): [True: 2.35k, False: 7.26k]
  ------------------
   81|  2.35k|        return 2592;
   82|      0|    default:
  ------------------
  |  Branch (82:5): [True: 0, False: 9.62k]
  ------------------
   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|  9.62k|    }
   86|  9.62k|}
_Z24dilithium_signature_size21dilithium_parameter_e:
   90|  1.09k|{
   91|  1.09k|    switch (parameter) {
   92|    636|    case dilithium_L3:
  ------------------
  |  Branch (92:5): [True: 636, False: 454]
  ------------------
   93|    636|        return 3293;
   94|    454|    case dilithium_L5:
  ------------------
  |  Branch (94:5): [True: 454, False: 636]
  ------------------
   95|    454|        return 4595;
   96|      0|    default:
  ------------------
  |  Branch (96:5): [True: 0, False: 1.09k]
  ------------------
   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.09k|    }
  100|  1.09k|}

_ZN35pgp_dilithium_exdsa_composite_key_tD2Ev:
   32|  15.5k|{
   33|  15.5k|}
_ZNK35pgp_dilithium_exdsa_composite_key_t20initialized_or_throwEv:
   37|  2.05k|{
   38|  2.05k|    if (!is_initialized()) {
  ------------------
  |  Branch (38:9): [True: 0, False: 2.05k]
  ------------------
   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|  2.05k|}
_ZN35pgp_dilithium_exdsa_composite_key_t23exdsa_curve_pubkey_sizeE11pgp_curve_t:
   96|  13.8k|{
   97|  13.8k|    switch (curve) {
   98|  5.31k|    case PGP_CURVE_ED25519:
  ------------------
  |  Branch (98:5): [True: 5.31k, False: 8.56k]
  ------------------
   99|  5.31k|        return 32;
  100|       |    /* TODO */
  101|       |    //  case PGP_CURVE_ED448:
  102|       |    //    return 56;
  103|  2.82k|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (103:5): [True: 2.82k, False: 11.0k]
  ------------------
  104|  2.82k|        return 65;
  105|  1.38k|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (105:5): [True: 1.38k, False: 12.4k]
  ------------------
  106|  1.38k|        return 97;
  107|  2.34k|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (107:5): [True: 2.34k, False: 11.5k]
  ------------------
  108|  2.34k|        return 65;
  109|  2.01k|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (109:5): [True: 2.01k, False: 11.8k]
  ------------------
  110|  2.01k|        return 97;
  111|      0|    default:
  ------------------
  |  Branch (111:5): [True: 0, False: 13.8k]
  ------------------
  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|  13.8k|    }
  115|  13.8k|}
_ZN35pgp_dilithium_exdsa_composite_key_t26exdsa_curve_signature_sizeE11pgp_curve_t:
  119|  1.09k|{
  120|  1.09k|    switch (curve) {
  121|    214|    case PGP_CURVE_ED25519:
  ------------------
  |  Branch (121:5): [True: 214, False: 876]
  ------------------
  122|    214|        return 64;
  123|       |    /* TODO */
  124|       |    //  case PGP_CURVE_ED448:
  125|       |    //    return 114;
  126|    212|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (126:5): [True: 212, False: 878]
  ------------------
  127|    212|        return 64;
  128|    223|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (128:5): [True: 223, False: 867]
  ------------------
  129|    223|        return 96;
  130|    210|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (130:5): [True: 210, False: 880]
  ------------------
  131|    210|        return 64;
  132|    231|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (132:5): [True: 231, False: 859]
  ------------------
  133|    231|        return 96;
  134|      0|    default:
  ------------------
  |  Branch (134:5): [True: 0, False: 1.09k]
  ------------------
  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.09k|    }
  138|  1.09k|}
_ZN35pgp_dilithium_exdsa_composite_key_t22pk_alg_to_dilithium_idE16pgp_pubkey_alg_t:
  142|  14.9k|{
  143|  14.9k|    switch (pk_alg) {
  144|  5.53k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (144:5): [True: 5.53k, False: 9.44k]
  ------------------
  145|  5.53k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  5.53k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  146|  8.56k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (146:5): [True: 3.03k, False: 11.9k]
  ------------------
  147|  8.56k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  8.56k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  148|  11.1k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (148:5): [True: 2.55k, False: 12.4k]
  ------------------
  149|  11.1k|        return dilithium_L3;
  150|  2.24k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (150:5): [True: 2.24k, False: 12.7k]
  ------------------
  151|  2.24k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.24k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  152|  3.85k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (152:5): [True: 1.60k, False: 13.3k]
  ------------------
  153|  3.85k|        return dilithium_L5;
  154|      0|    default:
  ------------------
  |  Branch (154:5): [True: 0, False: 14.9k]
  ------------------
  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|  14.9k|    }
  158|  14.9k|}
_ZN35pgp_dilithium_exdsa_composite_key_t18pk_alg_to_curve_idE16pgp_pubkey_alg_t:
  162|  19.2k|{
  163|  19.2k|    switch (pk_alg) {
  164|  7.21k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (164:5): [True: 7.21k, False: 12.0k]
  ------------------
  165|  7.21k|        return PGP_CURVE_ED25519;
  166|  3.85k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (166:5): [True: 3.85k, False: 15.3k]
  ------------------
  167|  3.85k|        return PGP_CURVE_NIST_P_256;
  168|  3.26k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (168:5): [True: 3.26k, False: 15.9k]
  ------------------
  169|  3.26k|        return PGP_CURVE_BP256;
  170|  2.84k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (170:5): [True: 2.84k, False: 16.3k]
  ------------------
  171|  2.84k|        return PGP_CURVE_BP384;
  172|  2.04k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (172:5): [True: 2.04k, False: 17.1k]
  ------------------
  173|  2.04k|        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: 19.2k]
  ------------------
  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|  19.2k|    }
  180|  19.2k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE16pgp_pubkey_alg_t:
  191|  4.25k|    : pk_alg_(pk_alg)
  192|  4.25k|{
  193|  4.25k|    parse_component_keys(key_encoded);
  194|  4.25k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_t12encoded_sizeE16pgp_pubkey_alg_t:
  358|  9.62k|{
  359|  9.62k|    dilithium_parameter_e dilithium_param = pk_alg_to_dilithium_id(pk_alg);
  360|  9.62k|    pgp_curve_t           curve = pk_alg_to_curve_id(pk_alg);
  361|  9.62k|    return exdsa_curve_pubkey_size(curve) + dilithium_pubkey_size(dilithium_param);
  362|  9.62k|}
_ZN42pgp_dilithium_exdsa_composite_public_key_t20parse_component_keysENSt3__16vectorIhNS0_9allocatorIhEEEE:
  367|  4.25k|{
  368|  4.25k|    if (key_encoded.size() != encoded_size(pk_alg_)) {
  ------------------
  |  Branch (368:9): [True: 0, False: 4.25k]
  ------------------
  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|  4.25k|    dilithium_parameter_e dilithium_param = pk_alg_to_dilithium_id(pk_alg_);
  374|  4.25k|    pgp_curve_t           curve = pk_alg_to_curve_id(pk_alg_);
  375|  4.25k|    size_t                split_at = exdsa_curve_pubkey_size(pk_alg_to_curve_id(pk_alg_));
  376|       |
  377|  4.25k|    dilithium_key_ = pgp_dilithium_public_key_t(
  378|  4.25k|      key_encoded.data() + split_at, key_encoded.size() - split_at, dilithium_param);
  379|  4.25k|    exdsa_key_ = exdsa_public_key_t(key_encoded.data(), split_at, curve);
  380|       |
  381|  4.25k|    is_initialized_ = true;
  382|  4.25k|}
_ZNK42pgp_dilithium_exdsa_composite_public_key_t11get_encodedEv:
  386|  2.05k|{
  387|  2.05k|    initialized_or_throw();
  388|  2.05k|    std::vector<uint8_t> result;
  389|  2.05k|    std::vector<uint8_t> exdsa_key_encoded = exdsa_key_.get_encoded();
  390|  2.05k|    std::vector<uint8_t> dilithium_key_encoded = dilithium_key_.get_encoded();
  391|       |
  392|  2.05k|    result.insert(result.end(), std::begin(exdsa_key_encoded), std::end(exdsa_key_encoded));
  393|  2.05k|    result.insert(
  394|  2.05k|      result.end(), std::begin(dilithium_key_encoded), std::end(dilithium_key_encoded));
  395|  2.05k|    return result;
  396|  2.05k|};

_ZNK35pgp_dilithium_exdsa_composite_key_t14is_initializedEv:
   58|  2.05k|    {
   59|  2.05k|        return is_initialized_;
   60|  2.05k|    }
_ZN31pgp_dilithium_exdsa_signature_t24composite_signature_sizeE16pgp_pubkey_alg_t:
   72|  1.09k|    {
   73|  1.09k|        return dilithium_signature_size(
   74|  1.09k|                 pgp_dilithium_exdsa_composite_key_t::pk_alg_to_dilithium_id(pk_alg)) +
   75|  1.09k|               pgp_dilithium_exdsa_composite_key_t::exdsa_curve_signature_size(
   76|  1.09k|                 pgp_dilithium_exdsa_composite_key_t::pk_alg_to_curve_id(pk_alg));
   77|  1.09k|    }
_ZN43pgp_dilithium_exdsa_composite_private_key_tC2Ev:
   96|  5.64k|    pgp_dilithium_exdsa_composite_private_key_t() = default;
_ZN42pgp_dilithium_exdsa_composite_public_key_tC2Ev:
  140|  5.64k|    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.40k|    {
  103|       |        return BITS_TO_BYTES(bitlen);
  ------------------
  |  |   56|  4.40k|#define BITS_TO_BYTES(b) (((b) + (CHAR_BIT - 1)) / CHAR_BIT)
  ------------------
  104|  4.40k|    }
_ZN3pgp2ec3Key12clear_secretEv:
  125|  10.4k|    {
  126|  10.4k|        x.forget();
  127|  10.4k|    }
_ZN3pgp2ec3KeyD2Ev:
  130|  10.4k|    {
  131|  10.4k|        clear_secret();
  132|  10.4k|    }
_ZN17pgp_ed25519_key_t12clear_secretEv:
  189|  1.82k|    {
  190|  1.82k|        secure_clear(priv.data(), priv.size());
  191|  1.82k|        priv.resize(0);
  192|  1.82k|    }
_ZN17pgp_ed25519_key_tD2Ev:
  195|  1.82k|    {
  196|  1.82k|        clear_secret();
  197|  1.82k|    }
_ZN16pgp_x25519_key_t12clear_secretEv:
  210|  2.19k|    {
  211|  2.19k|        secure_clear(priv.data(), priv.size());
  212|  2.19k|        priv.resize(0);
  213|  2.19k|    }
_ZN16pgp_x25519_key_tD2Ev:
  216|  2.19k|    {
  217|  2.19k|        clear_secret();
  218|  2.19k|    }

_ZN3pgp2ec5Curve6by_OIDERKNSt3__16vectorIhNS2_9allocatorIhEEEE:
  262|  8.09k|{
  263|  41.6k|    for (size_t i = 0; i < PGP_CURVE_MAX; i++) {
  ------------------
  |  Branch (263:24): [True: 39.8k, False: 1.85k]
  ------------------
  264|  39.8k|        if (oid == ec_curves[i].OID) {
  ------------------
  |  Branch (264:13): [True: 6.23k, False: 33.5k]
  ------------------
  265|  6.23k|            return static_cast<pgp_curve_t>(i);
  266|  6.23k|        }
  267|  39.8k|    }
  268|  1.85k|    return PGP_CURVE_MAX;
  269|  8.09k|}
_ZN3pgp2ec5Curve3getE11pgp_curve_t:
  285|  7.79k|{
  286|  7.79k|    return (curve_id < PGP_CURVE_MAX && curve_id > 0) ? &ec_curves[curve_id] : NULL;
  ------------------
  |  Branch (286:13): [True: 7.79k, False: 0]
  |  Branch (286:41): [True: 5.67k, False: 2.12k]
  ------------------
  287|  7.79k|}

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

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

_ZNK21ecdh_kem_public_key_t11get_encodedEv:
   85|  1.71k|    {
   86|  1.71k|        return key_;
   87|  1.71k|    }
_ZNK18exdsa_public_key_t11get_encodedEv:
  148|  2.05k|    {
  149|  2.05k|        return key_;
  150|  2.05k|    }
_ZN8ec_key_tC2Ev:
   50|  19.6k|    ec_key_t() = default;
_ZN21ecdh_kem_public_key_tC2Ev:
   73|  9.71k|    ecdh_kem_public_key_t() = default;
_ZN18exdsa_public_key_tC2Ev:
  136|  9.89k|    exdsa_public_key_t() = default;

_ZN3rnp10Hash_BotanC2E14pgp_hash_alg_t:
   49|  9.06k|Hash_Botan::Hash_Botan(pgp_hash_alg_t alg) : Hash(alg)
   50|  9.06k|{
   51|  9.06k|    auto name = Hash_Botan::name_backend(alg);
   52|  9.06k|    if (!name) {
  ------------------
  |  Branch (52:9): [True: 0, False: 9.06k]
  ------------------
   53|      0|        throw rnp_exception(RNP_ERROR_BAD_PARAMETERS);
   54|      0|    }
   55|       |
   56|  9.06k|    fn_ = Botan::HashFunction::create(name);
   57|  9.06k|    if (!fn_) {
  ------------------
  |  Branch (57:9): [True: 0, False: 9.06k]
  ------------------
   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|  9.06k|    assert(size_ == fn_->output_length());
   63|  9.06k|}
_ZN3rnp10Hash_BotanD2Ev:
   74|  9.06k|{
   75|  9.06k|}
_ZN3rnp10Hash_Botan6createE14pgp_hash_alg_t:
   79|  9.06k|{
   80|  9.06k|    return std::unique_ptr<Hash_Botan>(new Hash_Botan(alg));
   81|  9.06k|}
_ZN3rnp10Hash_Botan3addEPKvm:
   91|  27.6k|{
   92|  27.6k|    if (!fn_) {
  ------------------
  |  Branch (92:9): [True: 0, False: 27.6k]
  ------------------
   93|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
   94|      0|    }
   95|  27.6k|    fn_->update(static_cast<const uint8_t *>(buf), len);
   96|  27.6k|}
_ZN3rnp10Hash_Botan6finishEPh:
  100|  9.06k|{
  101|  9.06k|    assert(fn_);
  102|  9.06k|    if (!fn_) {
  ------------------
  |  Branch (102:9): [True: 0, False: 9.06k]
  ------------------
  103|      0|        return;
  104|      0|    }
  105|  9.06k|    if (digest) {
  ------------------
  |  Branch (105:9): [True: 9.06k, False: 0]
  ------------------
  106|  9.06k|        fn_->final(digest);
  107|  9.06k|    }
  108|  9.06k|    fn_ = nullptr;
  109|  9.06k|    size_ = 0;
  110|  9.06k|}
_ZN3rnp10Hash_Botan12name_backendE14pgp_hash_alg_t:
  114|  9.06k|{
  115|  9.06k|    return id_str_pair::lookup(botan_alg_map, alg);
  116|  9.06k|}
_ZN3rnp11CRC24_BotanC2Ev:
  119|  1.81k|{
  120|  1.81k|    fn_ = Botan::HashFunction::create("CRC24");
  121|  1.81k|    if (!fn_) {
  ------------------
  |  Branch (121:9): [True: 0, False: 1.81k]
  ------------------
  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.81k|    assert(3 == fn_->output_length());
  126|  1.81k|}
_ZN3rnp11CRC24_BotanD2Ev:
  129|  1.81k|{
  130|  1.81k|}
_ZN3rnp11CRC24_Botan6createEv:
  134|  1.81k|{
  135|  1.81k|    return std::unique_ptr<CRC24_Botan>(new CRC24_Botan());
  136|  1.81k|}
_ZN3rnp11CRC24_Botan3addEPKvm:
  140|  2.50k|{
  141|  2.50k|    if (!fn_) {
  ------------------
  |  Branch (141:9): [True: 0, False: 2.50k]
  ------------------
  142|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
  143|      0|    }
  144|  2.50k|    fn_->update(static_cast<const uint8_t *>(buf), len);
  145|  2.50k|}
_ZN3rnp11CRC24_Botan6finishEv:
  149|    271|{
  150|    271|    if (!fn_) {
  ------------------
  |  Branch (150:9): [True: 0, False: 271]
  ------------------
  151|      0|        throw rnp_exception(RNP_ERROR_NULL_POINTER);
  152|      0|    }
  153|    271|    std::array<uint8_t, 3> crc{};
  154|    271|    fn_->final(crc.data());
  155|    271|    fn_ = nullptr;
  156|    271|    return crc;
  157|    271|}

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

_ZN3rnp4Hash6createE14pgp_hash_alg_t:
   72|  37.5k|{
   73|  37.5k|    if (alg == PGP_HASH_SHA1) {
  ------------------
  |  Branch (73:9): [True: 28.5k, False: 9.06k]
  ------------------
   74|  28.5k|        return Hash_SHA1CD::create();
   75|  28.5k|    }
   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|  9.06k|    return Hash_Botan::create(alg);
   86|       |#else
   87|       |#error "Crypto backend not specified"
   88|       |#endif
   89|  37.5k|}
_ZN3rnp5CRC246createEv:
   93|  1.81k|{
   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.81k|}
_ZN3rnp4Hash3addERKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  105|  34.5k|{
  106|  34.5k|    add(val.data(), val.size());
  107|  34.5k|}
_ZN3rnp4Hash3addEj:
  111|  6.10k|{
  112|  6.10k|    uint8_t ibuf[4];
  113|  6.10k|    write_uint32(ibuf, val);
  114|  6.10k|    add(ibuf, sizeof(ibuf));
  115|  6.10k|}
_ZN3rnp4Hash3addERKN3pgp3mpiE:
  119|  6.10k|{
  120|  6.10k|    size_t len = val.size();
  121|  6.10k|    size_t idx = 0;
  122|  6.76k|    while ((idx < len) && (!val[idx])) {
  ------------------
  |  Branch (122:12): [True: 6.55k, False: 208]
  |  Branch (122:27): [True: 656, False: 5.89k]
  ------------------
  123|    656|        idx++;
  124|    656|    }
  125|       |
  126|  6.10k|    if (idx >= len) {
  ------------------
  |  Branch (126:9): [True: 208, False: 5.89k]
  ------------------
  127|    208|        add(0);
  128|    208|        return;
  129|    208|    }
  130|       |
  131|  5.89k|    add(len - idx);
  132|  5.89k|    if (val[idx] & 0x80) {
  ------------------
  |  Branch (132:9): [True: 3.64k, False: 2.25k]
  ------------------
  133|  3.64k|        uint8_t padbyte = 0;
  134|  3.64k|        add(&padbyte, 1);
  135|  3.64k|    }
  136|  5.89k|    add(val.data() + idx, len - idx);
  137|  5.89k|}
_ZN3rnp4Hash6finishEv:
  141|  37.5k|{
  142|  37.5k|    std::vector<uint8_t> res(size_, 0);
  143|  37.5k|    finish(res.data());
  144|  37.5k|    return res;
  145|  37.5k|}
_ZN3rnp4HashD2Ev:
  156|  37.5k|{
  157|  37.5k|}
_ZN3rnp4Hash4sizeE14pgp_hash_alg_t:
  183|  40.1k|{
  184|  40.1k|    size_t val = 0;
  185|  40.1k|    ARRAY_LOOKUP_BY_ID(hash_alg_map, type, len, alg, val);
  ------------------
  |  |   45|  40.1k|    do {                                                                  \
  |  |   46|   103k|        for (size_t i__ = 0; i__ < ARRAY_SIZE(array); i__++) {            \
  |  |  ------------------
  |  |  |  |   34|   103k|#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
  |  |  ------------------
  |  |  |  Branch (46:30): [True: 103k, False: 475]
  |  |  ------------------
  |  |   47|   103k|            if ((array)[i__].id_field == (lookup_value)) {                \
  |  |  ------------------
  |  |  |  Branch (47:17): [True: 39.6k, False: 63.5k]
  |  |  ------------------
  |  |   48|  39.6k|                (ret) = (array)[i__].ret_field;                           \
  |  |   49|  39.6k|                break;                                                    \
  |  |   50|  39.6k|            }                                                             \
  |  |   51|   103k|        }                                                                 \
  |  |   52|  40.1k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (52:14): [Folded, False: 40.1k]
  |  |  ------------------
  ------------------
  186|  40.1k|    return val;
  187|  40.1k|}

_ZN3rnp11Hash_SHA1CDC2Ev:
   35|  28.5k|Hash_SHA1CD::Hash_SHA1CD() : Hash(PGP_HASH_SHA1)
   36|  28.5k|{
   37|       |    assert(size_ == 20);
   38|  28.5k|    SHA1DCInit(&ctx_);
   39|  28.5k|}
_ZN3rnp11Hash_SHA1CDD2Ev:
   47|  28.5k|{
   48|  28.5k|}
_ZN3rnp11Hash_SHA1CD6createEv:
   52|  28.5k|{
   53|  28.5k|    return std::unique_ptr<Hash_SHA1CD>(new Hash_SHA1CD());
   54|  28.5k|}
_ZN3rnp11Hash_SHA1CD3addEPKvm:
   69|  57.0k|{
   70|  57.0k|    SHA1DCUpdate(&ctx_, (const char *) buf, len);
   71|  57.0k|}
_ZN3rnp11Hash_SHA1CD6finishEPh:
   78|  28.5k|{
   79|  28.5k|    unsigned char fixed_digest[20];
   80|  28.5k|    int           res = SHA1DCFinal(fixed_digest, &ctx_);
   81|  28.5k|    if (res && digest) {
  ------------------
  |  Branch (81:9): [True: 0, False: 28.5k]
  |  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|  28.5k|    if (res) {
  ------------------
  |  Branch (85:9): [True: 0, False: 28.5k]
  ------------------
   86|      0|        return;
   87|      0|    }
   88|  28.5k|    if (digest) {
  ------------------
  |  Branch (88:9): [True: 28.5k, False: 0]
  ------------------
   89|  28.5k|        memcpy(digest, fixed_digest, 20);
   90|  28.5k|    }
   91|  28.5k|}

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

_Z17kyber_pubkey_size17kyber_parameter_e:
   47|  9.35k|{
   48|  9.35k|    switch (parameter) {
   49|  5.19k|    case kyber_768:
  ------------------
  |  Branch (49:5): [True: 5.19k, False: 4.16k]
  ------------------
   50|  5.19k|        return 1184;
   51|  4.16k|    case kyber_1024:
  ------------------
  |  Branch (51:5): [True: 4.16k, False: 5.19k]
  ------------------
   52|  4.16k|        return 1568;
   53|      0|    default:
  ------------------
  |  Branch (53:5): [True: 0, False: 9.35k]
  ------------------
   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|  9.35k|    }
   57|  9.35k|}
_Z21kyber_ciphertext_size17kyber_parameter_e:
   75|  2.33k|{
   76|  2.33k|    switch (parameter) {
   77|  1.18k|    case kyber_768:
  ------------------
  |  Branch (77:5): [True: 1.18k, False: 1.14k]
  ------------------
   78|  1.18k|        return 1088;
   79|  1.14k|    case kyber_1024:
  ------------------
  |  Branch (79:5): [True: 1.14k, False: 1.18k]
  ------------------
   80|  1.14k|        return 1568;
   81|      0|    default:
  ------------------
  |  Branch (81:5): [True: 0, False: 2.33k]
  ------------------
   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.33k|    }
   85|  2.33k|}
_ZN22pgp_kyber_public_key_tC2EPKhm17kyber_parameter_e:
   90|  4.25k|    : key_encoded_(key_encoded, key_encoded + key_encoded_len), kyber_mode_(mode),
   91|  4.25k|      is_initialized_(true)
   92|  4.25k|{
   93|  4.25k|}

_ZN30pgp_kyber_ecdh_composite_key_tD2Ev:
   37|  15.1k|{
   38|  15.1k|}
_ZNK30pgp_kyber_ecdh_composite_key_t20initialized_or_throwEv:
   42|  1.71k|{
   43|  1.71k|    if (!is_initialized()) {
  ------------------
  |  Branch (43:9): [True: 0, False: 1.71k]
  ------------------
   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.71k|}
_ZN30pgp_kyber_ecdh_composite_key_t22ecdh_curve_pubkey_sizeE11pgp_curve_t:
  101|  13.6k|{
  102|  13.6k|    switch (curve) {
  103|  1.90k|    case PGP_CURVE_25519:
  ------------------
  |  Branch (103:5): [True: 1.90k, False: 11.6k]
  ------------------
  104|  1.90k|        return 32;
  105|       |    /* TODO */
  106|       |    //  case PGP_CURVE_X448:
  107|       |    //    return 56;
  108|  2.92k|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (108:5): [True: 2.92k, False: 10.6k]
  ------------------
  109|  2.92k|        return 65;
  110|  3.44k|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (110:5): [True: 3.44k, False: 10.1k]
  ------------------
  111|  3.44k|        return 97;
  112|  2.75k|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (112:5): [True: 2.75k, False: 10.8k]
  ------------------
  113|  2.75k|        return 65;
  114|  2.58k|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (114:5): [True: 2.58k, False: 11.0k]
  ------------------
  115|  2.58k|        return 97;
  116|      0|    default:
  ------------------
  |  Branch (116:5): [True: 0, False: 13.6k]
  ------------------
  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|  13.6k|    }
  120|  13.6k|}
_ZN30pgp_kyber_ecdh_composite_key_t25ecdh_curve_ephemeral_sizeE11pgp_curve_t:
  124|  2.33k|{
  125|  2.33k|    switch (curve) {
  126|    252|    case PGP_CURVE_25519:
  ------------------
  |  Branch (126:5): [True: 252, False: 2.08k]
  ------------------
  127|    252|        return 32;
  128|       |    /* TODO */
  129|       |    //  case PGP_CURVE_X448:
  130|       |    //    return 56;
  131|    517|    case PGP_CURVE_NIST_P_256:
  ------------------
  |  Branch (131:5): [True: 517, False: 1.81k]
  ------------------
  132|    517|        return 65;
  133|    794|    case PGP_CURVE_NIST_P_384:
  ------------------
  |  Branch (133:5): [True: 794, False: 1.53k]
  ------------------
  134|    794|        return 97;
  135|    418|    case PGP_CURVE_BP256:
  ------------------
  |  Branch (135:5): [True: 418, False: 1.91k]
  ------------------
  136|    418|        return 65;
  137|    352|    case PGP_CURVE_BP384:
  ------------------
  |  Branch (137:5): [True: 352, False: 1.98k]
  ------------------
  138|    352|        return 97;
  139|      0|    default:
  ------------------
  |  Branch (139:5): [True: 0, False: 2.33k]
  ------------------
  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.33k|    }
  143|  2.33k|}
_ZN30pgp_kyber_ecdh_composite_key_t18pk_alg_to_kyber_idE16pgp_pubkey_alg_t:
  170|  15.9k|{
  171|  15.9k|    switch (pk_alg) {
  172|  2.16k|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (172:5): [True: 2.16k, False: 13.7k]
  ------------------
  173|  2.16k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.16k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  174|  5.60k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (174:5): [True: 3.43k, False: 12.5k]
  ------------------
  175|  5.60k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  5.60k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  176|  8.76k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (176:5): [True: 3.16k, False: 12.7k]
  ------------------
  177|  8.76k|        return kyber_768;
  178|  2.93k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (178:5): [True: 2.93k, False: 13.0k]
  ------------------
  179|  2.93k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.93k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  180|  7.17k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (180:5): [True: 4.23k, False: 11.7k]
  ------------------
  181|  7.17k|        return kyber_1024;
  182|      0|    default:
  ------------------
  |  Branch (182:5): [True: 0, False: 15.9k]
  ------------------
  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|  15.9k|    }
  186|  15.9k|}
_ZN30pgp_kyber_ecdh_composite_key_t18pk_alg_to_curve_idE16pgp_pubkey_alg_t:
  190|  20.1k|{
  191|  20.1k|    switch (pk_alg) {
  192|  2.77k|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (192:5): [True: 2.77k, False: 17.4k]
  ------------------
  193|  2.77k|        return PGP_CURVE_25519;
  194|  4.39k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (194:5): [True: 4.39k, False: 15.8k]
  ------------------
  195|  4.39k|        return PGP_CURVE_NIST_P_256;
  196|  3.99k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (196:5): [True: 3.99k, False: 16.1k]
  ------------------
  197|  3.99k|        return PGP_CURVE_BP256;
  198|  3.72k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (198:5): [True: 3.72k, False: 16.4k]
  ------------------
  199|  3.72k|        return PGP_CURVE_BP384;
  200|  5.31k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (200:5): [True: 5.31k, False: 14.8k]
  ------------------
  201|  5.31k|        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: 20.1k]
  ------------------
  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|  20.1k|    }
  208|  20.1k|}
_ZN37pgp_kyber_ecdh_composite_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE16pgp_pubkey_alg_t:
  447|  4.25k|    : pk_alg_(pk_alg)
  448|  4.25k|{
  449|  4.25k|    parse_component_keys(key_encoded);
  450|  4.25k|}
_ZN37pgp_kyber_ecdh_composite_public_key_t12encoded_sizeE16pgp_pubkey_alg_t:
  469|  9.35k|{
  470|  9.35k|    kyber_parameter_e kyber_param = pk_alg_to_kyber_id(pk_alg);
  471|  9.35k|    pgp_curve_t       curve = pk_alg_to_curve_id(pk_alg);
  472|  9.35k|    return ecdh_curve_pubkey_size(curve) + kyber_pubkey_size(kyber_param);
  473|  9.35k|}
_ZN37pgp_kyber_ecdh_composite_public_key_t20parse_component_keysENSt3__16vectorIhNS0_9allocatorIhEEEE:
  477|  4.25k|{
  478|  4.25k|    if (key_encoded.size() != encoded_size(pk_alg_)) {
  ------------------
  |  Branch (478:9): [True: 0, False: 4.25k]
  ------------------
  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|  4.25k|    kyber_parameter_e kyber_param = pk_alg_to_kyber_id(pk_alg_);
  484|  4.25k|    pgp_curve_t       ecdh_curve = pk_alg_to_curve_id(pk_alg_);
  485|  4.25k|    size_t            split_at = ecdh_curve_pubkey_size(pk_alg_to_curve_id(pk_alg_));
  486|       |
  487|  4.25k|    kyber_key_ = pgp_kyber_public_key_t(
  488|  4.25k|      key_encoded.data() + split_at, key_encoded.size() - split_at, kyber_param);
  489|  4.25k|    ecdh_key_ = ecdh_kem_public_key_t(key_encoded.data(), split_at, ecdh_curve);
  490|       |
  491|  4.25k|    is_initialized_ = true;
  492|  4.25k|}
_ZNK37pgp_kyber_ecdh_composite_public_key_t11get_encodedEv:
  555|  1.71k|{
  556|  1.71k|    initialized_or_throw();
  557|  1.71k|    std::vector<uint8_t> result;
  558|  1.71k|    std::vector<uint8_t> ecdh_key_encoded = ecdh_key_.get_encoded();
  559|  1.71k|    std::vector<uint8_t> kyber_key_encoded = kyber_key_.get_encoded();
  560|       |
  561|  1.71k|    result.insert(result.end(), std::begin(ecdh_key_encoded), std::end(ecdh_key_encoded));
  562|  1.71k|    result.insert(result.end(), std::begin(kyber_key_encoded), std::end(kyber_key_encoded));
  563|  1.71k|    return result;
  564|  1.71k|};

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

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

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

_ZNK3pgp3mpi4bitsEv:
   37|   211k|{
   38|   211k|    size_t  bits = 0;
   39|   211k|    size_t  idx = 0;
   40|   211k|    uint8_t bt;
   41|       |
   42|   232k|    for (idx = 0; (idx < size()) && !data_[idx]; idx++)
  ------------------
  |  Branch (42:19): [True: 229k, False: 3.57k]
  |  Branch (42:37): [True: 20.9k, False: 208k]
  ------------------
   43|  20.9k|        ;
   44|       |
   45|   211k|    if (idx < size()) {
  ------------------
  |  Branch (45:9): [True: 208k, False: 3.57k]
  ------------------
   46|  1.39M|        for (bits = (size() - idx - 1) << 3, bt = data_[idx]; bt; bits++, bt = bt >> 1)
  ------------------
  |  Branch (46:63): [True: 1.18M, False: 208k]
  ------------------
   47|  1.18M|            ;
   48|   208k|    }
   49|       |
   50|   211k|    return bits;
   51|   211k|}
_ZNK3pgp3mpi4sizeEv:
   55|   664k|{
   56|   664k|    return data_.size();
   57|   664k|}
_ZN3pgp3mpi4dataEv:
   61|   132k|{
   62|   132k|    return data_.data();
   63|   132k|}
_ZNK3pgp3mpi4dataEv:
   67|  8.94k|{
   68|  8.94k|    return data_.data();
   69|  8.94k|}
_ZNK3pgp3mpiixEm:
  101|  12.4k|{
  102|  12.4k|    return data_.at(idx);
  103|  12.4k|}
_ZN3pgp3mpi6resizeEmh:
  119|   132k|{
  120|   132k|    data_.resize(size, fill);
  121|   132k|}
_ZN3pgp3mpi6forgetEv:
  125|   110k|{
  126|   110k|    secure_clear(data_.data(), data_.size());
  127|   110k|    data_.resize(0);
  128|   110k|}

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

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

sha1_compression_states:
  465|   138k|{
  466|   138k|    uint32_t a = ihv[0], b = ihv[1], c = ihv[2], d = ihv[3], e = ihv[4];
  467|   138k|    uint32_t temp;
  468|       |
  469|       |#ifdef DOSTORESTATE00
  470|       |    SHA1_STORE_STATE(0)
  471|       |#endif
  472|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 0, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  473|       |
  474|       |#ifdef DOSTORESTATE01
  475|       |    SHA1_STORE_STATE(1)
  476|       |#endif
  477|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 1, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  478|       |
  479|       |#ifdef DOSTORESTATE02
  480|       |    SHA1_STORE_STATE(2)
  481|       |#endif
  482|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 2, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  483|       |
  484|       |#ifdef DOSTORESTATE03
  485|       |    SHA1_STORE_STATE(3)
  486|       |#endif
  487|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 3, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  488|       |
  489|       |#ifdef DOSTORESTATE04
  490|       |    SHA1_STORE_STATE(4)
  491|       |#endif
  492|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 4, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  493|       |
  494|       |#ifdef DOSTORESTATE05
  495|       |    SHA1_STORE_STATE(5)
  496|       |#endif
  497|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 5, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  498|       |
  499|       |#ifdef DOSTORESTATE06
  500|       |    SHA1_STORE_STATE(6)
  501|       |#endif
  502|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 6, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  503|       |
  504|       |#ifdef DOSTORESTATE07
  505|       |    SHA1_STORE_STATE(7)
  506|       |#endif
  507|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 7, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  508|       |
  509|       |#ifdef DOSTORESTATE08
  510|       |    SHA1_STORE_STATE(8)
  511|       |#endif
  512|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 8, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  513|       |
  514|       |#ifdef DOSTORESTATE09
  515|       |    SHA1_STORE_STATE(9)
  516|       |#endif
  517|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 9, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  518|       |
  519|       |#ifdef DOSTORESTATE10
  520|       |    SHA1_STORE_STATE(10)
  521|       |#endif
  522|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 10, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  523|       |
  524|       |#ifdef DOSTORESTATE11
  525|       |    SHA1_STORE_STATE(11)
  526|       |#endif
  527|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 11, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  528|       |
  529|       |#ifdef DOSTORESTATE12
  530|       |    SHA1_STORE_STATE(12)
  531|       |#endif
  532|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 12, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  533|       |
  534|       |#ifdef DOSTORESTATE13
  535|       |    SHA1_STORE_STATE(13)
  536|       |#endif
  537|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 13, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  538|       |
  539|       |#ifdef DOSTORESTATE14
  540|       |    SHA1_STORE_STATE(14)
  541|       |#endif
  542|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 14, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  543|       |
  544|       |#ifdef DOSTORESTATE15
  545|       |    SHA1_STORE_STATE(15)
  546|       |#endif
  547|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 15, temp);
  ------------------
  |  |  208|   138k|    {                                                                    \
  |  |  209|   138k|        sha1_load(m, t, temp);                                           \
  |  |  ------------------
  |  |  |  |  152|   138k|    {                         \
  |  |  |  |  153|   138k|        temp = m[t];          \
  |  |  |  |  154|   138k|        sha1_bswap32(temp);   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  138|   138k|    {                                                        \
  |  |  |  |  |  |  139|   138k|        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); \
  |  |  |  |  |  |  140|   138k|        x = (x << 16) | (x >> 16);                           \
  |  |  |  |  |  |  141|   138k|    }
  |  |  |  |  ------------------
  |  |  |  |  155|   138k|    }
  |  |  ------------------
  |  |  210|   138k|        sha1_store(W, t, temp);                                          \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  211|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;   \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  212|   138k|        b = rotate_left(b, 30);                                          \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  213|   138k|    }
  ------------------
  548|       |
  549|       |#ifdef DOSTORESTATE16
  550|       |    SHA1_STORE_STATE(16)
  551|       |#endif
  552|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(e, a, b, c, d, W, 16, temp);
  ------------------
  |  |  216|   138k|    {                                                                   \
  |  |  217|   138k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   138k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   138k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   138k|    }
  ------------------
  553|       |
  554|       |#ifdef DOSTORESTATE17
  555|       |    SHA1_STORE_STATE(17)
  556|       |#endif
  557|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(d, e, a, b, c, W, 17, temp);
  ------------------
  |  |  216|   138k|    {                                                                   \
  |  |  217|   138k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   138k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   138k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   138k|    }
  ------------------
  558|       |
  559|       |#ifdef DOSTORESTATE18
  560|       |    SHA1_STORE_STATE(18)
  561|       |#endif
  562|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(c, d, e, a, b, W, 18, temp);
  ------------------
  |  |  216|   138k|    {                                                                   \
  |  |  217|   138k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   138k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   138k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   138k|    }
  ------------------
  563|       |
  564|       |#ifdef DOSTORESTATE19
  565|       |    SHA1_STORE_STATE(19)
  566|       |#endif
  567|   138k|    SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(b, c, d, e, a, W, 19, temp);
  ------------------
  |  |  216|   138k|    {                                                                   \
  |  |  217|   138k|        temp = sha1_mix(W, t);                                          \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  218|   138k|        sha1_store(W, t, temp);                                         \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  219|   138k|        e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999;  \
  |  |  ------------------
  |  |  |  |  160|   138k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  220|   138k|        b = rotate_left(b, 30);                                         \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  221|   138k|    }
  ------------------
  568|       |
  569|       |#ifdef DOSTORESTATE20
  570|       |    SHA1_STORE_STATE(20)
  571|       |#endif
  572|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 20, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  573|       |
  574|       |#ifdef DOSTORESTATE21
  575|       |    SHA1_STORE_STATE(21)
  576|       |#endif
  577|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 21, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  578|       |
  579|       |#ifdef DOSTORESTATE22
  580|       |    SHA1_STORE_STATE(22)
  581|       |#endif
  582|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 22, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  583|       |
  584|       |#ifdef DOSTORESTATE23
  585|       |    SHA1_STORE_STATE(23)
  586|       |#endif
  587|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 23, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  588|       |
  589|       |#ifdef DOSTORESTATE24
  590|       |    SHA1_STORE_STATE(24)
  591|       |#endif
  592|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 24, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  593|       |
  594|       |#ifdef DOSTORESTATE25
  595|       |    SHA1_STORE_STATE(25)
  596|       |#endif
  597|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 25, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  598|       |
  599|       |#ifdef DOSTORESTATE26
  600|       |    SHA1_STORE_STATE(26)
  601|       |#endif
  602|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 26, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  603|       |
  604|       |#ifdef DOSTORESTATE27
  605|       |    SHA1_STORE_STATE(27)
  606|       |#endif
  607|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 27, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  608|       |
  609|       |#ifdef DOSTORESTATE28
  610|       |    SHA1_STORE_STATE(28)
  611|       |#endif
  612|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 28, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  613|       |
  614|       |#ifdef DOSTORESTATE29
  615|       |    SHA1_STORE_STATE(29)
  616|       |#endif
  617|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 29, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  618|       |
  619|       |#ifdef DOSTORESTATE30
  620|       |    SHA1_STORE_STATE(30)
  621|       |#endif
  622|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 30, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  623|       |
  624|       |#ifdef DOSTORESTATE31
  625|       |    SHA1_STORE_STATE(31)
  626|       |#endif
  627|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 31, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  628|       |
  629|       |#ifdef DOSTORESTATE32
  630|       |    SHA1_STORE_STATE(32)
  631|       |#endif
  632|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 32, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  633|       |
  634|       |#ifdef DOSTORESTATE33
  635|       |    SHA1_STORE_STATE(33)
  636|       |#endif
  637|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 33, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  638|       |
  639|       |#ifdef DOSTORESTATE34
  640|       |    SHA1_STORE_STATE(34)
  641|       |#endif
  642|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 34, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  643|       |
  644|       |#ifdef DOSTORESTATE35
  645|       |    SHA1_STORE_STATE(35)
  646|       |#endif
  647|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 35, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  648|       |
  649|       |#ifdef DOSTORESTATE36
  650|       |    SHA1_STORE_STATE(36)
  651|       |#endif
  652|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 36, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  653|       |
  654|       |#ifdef DOSTORESTATE37
  655|       |    SHA1_STORE_STATE(37)
  656|       |#endif
  657|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 37, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  658|       |
  659|       |#ifdef DOSTORESTATE38
  660|       |    SHA1_STORE_STATE(38)
  661|       |#endif
  662|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 38, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  663|       |
  664|       |#ifdef DOSTORESTATE39
  665|       |    SHA1_STORE_STATE(39)
  666|       |#endif
  667|   138k|    SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 39, temp);
  ------------------
  |  |  224|   138k|    {                                                                  \
  |  |  225|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  226|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  227|   138k|        e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1; \
  |  |  ------------------
  |  |  |  |  161|   138k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  228|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  229|   138k|    }
  ------------------
  668|       |
  669|       |#ifdef DOSTORESTATE40
  670|       |    SHA1_STORE_STATE(40)
  671|       |#endif
  672|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 40, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  673|       |
  674|       |#ifdef DOSTORESTATE41
  675|       |    SHA1_STORE_STATE(41)
  676|       |#endif
  677|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 41, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  678|       |
  679|       |#ifdef DOSTORESTATE42
  680|       |    SHA1_STORE_STATE(42)
  681|       |#endif
  682|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 42, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  683|       |
  684|       |#ifdef DOSTORESTATE43
  685|       |    SHA1_STORE_STATE(43)
  686|       |#endif
  687|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 43, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  688|       |
  689|       |#ifdef DOSTORESTATE44
  690|       |    SHA1_STORE_STATE(44)
  691|       |#endif
  692|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 44, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  693|       |
  694|       |#ifdef DOSTORESTATE45
  695|       |    SHA1_STORE_STATE(45)
  696|       |#endif
  697|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 45, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  698|       |
  699|       |#ifdef DOSTORESTATE46
  700|       |    SHA1_STORE_STATE(46)
  701|       |#endif
  702|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 46, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  703|       |
  704|       |#ifdef DOSTORESTATE47
  705|       |    SHA1_STORE_STATE(47)
  706|       |#endif
  707|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 47, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  708|       |
  709|       |#ifdef DOSTORESTATE48
  710|       |    SHA1_STORE_STATE(48)
  711|       |#endif
  712|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 48, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  713|       |
  714|       |#ifdef DOSTORESTATE49
  715|       |    SHA1_STORE_STATE(49)
  716|       |#endif
  717|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 49, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  718|       |
  719|       |#ifdef DOSTORESTATE50
  720|       |    SHA1_STORE_STATE(50)
  721|       |#endif
  722|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 50, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  723|       |
  724|       |#ifdef DOSTORESTATE51
  725|       |    SHA1_STORE_STATE(51)
  726|       |#endif
  727|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 51, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  728|       |
  729|       |#ifdef DOSTORESTATE52
  730|       |    SHA1_STORE_STATE(52)
  731|       |#endif
  732|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 52, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  733|       |
  734|       |#ifdef DOSTORESTATE53
  735|       |    SHA1_STORE_STATE(53)
  736|       |#endif
  737|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 53, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  738|       |
  739|       |#ifdef DOSTORESTATE54
  740|       |    SHA1_STORE_STATE(54)
  741|       |#endif
  742|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 54, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  743|       |
  744|       |#ifdef DOSTORESTATE55
  745|       |    SHA1_STORE_STATE(55)
  746|       |#endif
  747|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 55, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  748|       |
  749|       |#ifdef DOSTORESTATE56
  750|       |    SHA1_STORE_STATE(56)
  751|       |#endif
  752|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 56, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  753|       |
  754|       |#ifdef DOSTORESTATE57
  755|       |    SHA1_STORE_STATE(57)
  756|       |#endif
  757|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 57, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  758|       |
  759|   138k|#ifdef DOSTORESTATE58
  760|   138k|    SHA1_STORE_STATE(58)
  ------------------
  |  |  248|   138k|    states[i][0] = a;       \
  |  |  249|   138k|    states[i][1] = b;       \
  |  |  250|   138k|    states[i][2] = c;       \
  |  |  251|   138k|    states[i][3] = d;       \
  |  |  252|   138k|    states[i][4] = e;
  ------------------
  761|   138k|#endif
  762|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 58, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  763|       |
  764|       |#ifdef DOSTORESTATE59
  765|       |    SHA1_STORE_STATE(59)
  766|       |#endif
  767|   138k|    SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 59, temp);
  ------------------
  |  |  232|   138k|    {                                                                  \
  |  |  233|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  235|   138k|        e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC; \
  |  |  ------------------
  |  |  |  |  162|   138k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  236|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  237|   138k|    }
  ------------------
  768|       |
  769|       |#ifdef DOSTORESTATE60
  770|       |    SHA1_STORE_STATE(60)
  771|       |#endif
  772|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 60, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  773|       |
  774|       |#ifdef DOSTORESTATE61
  775|       |    SHA1_STORE_STATE(61)
  776|       |#endif
  777|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 61, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  778|       |
  779|       |#ifdef DOSTORESTATE62
  780|       |    SHA1_STORE_STATE(62)
  781|       |#endif
  782|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 62, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  783|       |
  784|       |#ifdef DOSTORESTATE63
  785|       |    SHA1_STORE_STATE(63)
  786|       |#endif
  787|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 63, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  788|       |
  789|       |#ifdef DOSTORESTATE64
  790|       |    SHA1_STORE_STATE(64)
  791|       |#endif
  792|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 64, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  793|       |
  794|   138k|#ifdef DOSTORESTATE65
  795|   138k|    SHA1_STORE_STATE(65)
  ------------------
  |  |  248|   138k|    states[i][0] = a;       \
  |  |  249|   138k|    states[i][1] = b;       \
  |  |  250|   138k|    states[i][2] = c;       \
  |  |  251|   138k|    states[i][3] = d;       \
  |  |  252|   138k|    states[i][4] = e;
  ------------------
  796|   138k|#endif
  797|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 65, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  798|       |
  799|       |#ifdef DOSTORESTATE66
  800|       |    SHA1_STORE_STATE(66)
  801|       |#endif
  802|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 66, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  803|       |
  804|       |#ifdef DOSTORESTATE67
  805|       |    SHA1_STORE_STATE(67)
  806|       |#endif
  807|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 67, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  808|       |
  809|       |#ifdef DOSTORESTATE68
  810|       |    SHA1_STORE_STATE(68)
  811|       |#endif
  812|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 68, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  813|       |
  814|       |#ifdef DOSTORESTATE69
  815|       |    SHA1_STORE_STATE(69)
  816|       |#endif
  817|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 69, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  818|       |
  819|       |#ifdef DOSTORESTATE70
  820|       |    SHA1_STORE_STATE(70)
  821|       |#endif
  822|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 70, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  823|       |
  824|       |#ifdef DOSTORESTATE71
  825|       |    SHA1_STORE_STATE(71)
  826|       |#endif
  827|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 71, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  828|       |
  829|       |#ifdef DOSTORESTATE72
  830|       |    SHA1_STORE_STATE(72)
  831|       |#endif
  832|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 72, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  833|       |
  834|       |#ifdef DOSTORESTATE73
  835|       |    SHA1_STORE_STATE(73)
  836|       |#endif
  837|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 73, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  838|       |
  839|       |#ifdef DOSTORESTATE74
  840|       |    SHA1_STORE_STATE(74)
  841|       |#endif
  842|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 74, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  843|       |
  844|       |#ifdef DOSTORESTATE75
  845|       |    SHA1_STORE_STATE(75)
  846|       |#endif
  847|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 75, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  848|       |
  849|       |#ifdef DOSTORESTATE76
  850|       |    SHA1_STORE_STATE(76)
  851|       |#endif
  852|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 76, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  853|       |
  854|       |#ifdef DOSTORESTATE77
  855|       |    SHA1_STORE_STATE(77)
  856|       |#endif
  857|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 77, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  858|       |
  859|       |#ifdef DOSTORESTATE78
  860|       |    SHA1_STORE_STATE(78)
  861|       |#endif
  862|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 78, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  863|       |
  864|       |#ifdef DOSTORESTATE79
  865|       |    SHA1_STORE_STATE(79)
  866|       |#endif
  867|   138k|    SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 79, temp);
  ------------------
  |  |  240|   138k|    {                                                                  \
  |  |  241|   138k|        temp = sha1_mix(W, t);                                         \
  |  |  ------------------
  |  |  |  |  143|   138k|#define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|   138k|        sha1_store(W, t, temp);                                        \
  |  |  ------------------
  |  |  |  |  158|   138k|#define sha1_store(W, t, x) *(volatile uint32_t *) &W[t] = x
  |  |  ------------------
  |  |  243|   138k|        e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += temp + rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6; \
  |  |  ------------------
  |  |  |  |  163|   138k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  244|   138k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|   138k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  245|   138k|    }
  ------------------
  868|       |
  869|   138k|    ihv[0] += a;
  870|   138k|    ihv[1] += b;
  871|   138k|    ihv[2] += c;
  872|   138k|    ihv[3] += d;
  873|   138k|    ihv[4] += e;
  874|   138k|}
SHA1DCInit:
 2019|  28.5k|{
 2020|  28.5k|    ctx->total = 0;
 2021|  28.5k|    ctx->ihv[0] = 0x67452301;
 2022|  28.5k|    ctx->ihv[1] = 0xEFCDAB89;
 2023|  28.5k|    ctx->ihv[2] = 0x98BADCFE;
 2024|  28.5k|    ctx->ihv[3] = 0x10325476;
 2025|  28.5k|    ctx->ihv[4] = 0xC3D2E1F0;
 2026|  28.5k|    ctx->found_collision = 0;
 2027|  28.5k|    ctx->safe_hash = SHA1DC_INIT_SAFE_HASH_DEFAULT;
  ------------------
  |  |   23|  28.5k|#define SHA1DC_INIT_SAFE_HASH_DEFAULT 1
  ------------------
 2028|  28.5k|    ctx->ubc_check = 1;
 2029|  28.5k|    ctx->detect_coll = 1;
 2030|  28.5k|    ctx->reduced_round_coll = 0;
 2031|       |    ctx->callback = NULL;
 2032|  28.5k|}
SHA1DCUpdate:
 2078|  85.5k|{
 2079|  85.5k|    unsigned left, fill;
 2080|       |
 2081|  85.5k|    if (len == 0)
  ------------------
  |  Branch (2081:9): [True: 0, False: 85.5k]
  ------------------
 2082|      0|        return;
 2083|       |
 2084|  85.5k|    left = ctx->total & 63;
 2085|  85.5k|    fill = 64 - left;
 2086|       |
 2087|  85.5k|    if (left && len >= fill) {
  ------------------
  |  Branch (2087:9): [True: 56.7k, False: 28.7k]
  |  Branch (2087:17): [True: 5.92k, False: 50.8k]
  ------------------
 2088|  5.92k|        ctx->total += fill;
 2089|  5.92k|        memcpy(ctx->buffer + left, buf, fill);
 2090|  5.92k|        sha1_process(ctx, (uint32_t *) (ctx->buffer));
 2091|  5.92k|        buf += fill;
 2092|  5.92k|        len -= fill;
 2093|  5.92k|        left = 0;
 2094|  5.92k|    }
 2095|   190k|    while (len >= 64) {
  ------------------
  |  Branch (2095:12): [True: 104k, False: 85.5k]
  ------------------
 2096|   104k|        ctx->total += 64;
 2097|       |
 2098|   104k|#if defined(SHA1DC_ALLOW_UNALIGNED_ACCESS)
 2099|   104k|        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|   104k|        buf += 64;
 2105|   104k|        len -= 64;
 2106|   104k|    }
 2107|  85.5k|    if (len > 0) {
  ------------------
  |  Branch (2107:9): [True: 85.3k, False: 244]
  ------------------
 2108|  85.3k|        ctx->total += len;
 2109|  85.3k|        memcpy(ctx->buffer + left, buf, len);
 2110|  85.3k|    }
 2111|  85.5k|}
SHA1DCFinal:
 2120|  28.5k|{
 2121|  28.5k|    uint32_t last = ctx->total & 63;
 2122|  28.5k|    uint32_t padn = (last < 56) ? (56 - last) : (120 - last);
  ------------------
  |  Branch (2122:21): [True: 27.8k, False: 687]
  ------------------
 2123|  28.5k|    uint64_t total;
 2124|  28.5k|    SHA1DCUpdate(ctx, (const char *) (sha1_padding), padn);
 2125|       |
 2126|  28.5k|    total = ctx->total - padn;
 2127|  28.5k|    total <<= 3;
 2128|  28.5k|    ctx->buffer[56] = (unsigned char) (total >> 56);
 2129|  28.5k|    ctx->buffer[57] = (unsigned char) (total >> 48);
 2130|  28.5k|    ctx->buffer[58] = (unsigned char) (total >> 40);
 2131|  28.5k|    ctx->buffer[59] = (unsigned char) (total >> 32);
 2132|  28.5k|    ctx->buffer[60] = (unsigned char) (total >> 24);
 2133|  28.5k|    ctx->buffer[61] = (unsigned char) (total >> 16);
 2134|  28.5k|    ctx->buffer[62] = (unsigned char) (total >> 8);
 2135|  28.5k|    ctx->buffer[63] = (unsigned char) (total);
 2136|  28.5k|    sha1_process(ctx, (uint32_t *) (ctx->buffer));
 2137|  28.5k|    output[0] = (unsigned char) (ctx->ihv[0] >> 24);
 2138|  28.5k|    output[1] = (unsigned char) (ctx->ihv[0] >> 16);
 2139|  28.5k|    output[2] = (unsigned char) (ctx->ihv[0] >> 8);
 2140|  28.5k|    output[3] = (unsigned char) (ctx->ihv[0]);
 2141|  28.5k|    output[4] = (unsigned char) (ctx->ihv[1] >> 24);
 2142|  28.5k|    output[5] = (unsigned char) (ctx->ihv[1] >> 16);
 2143|  28.5k|    output[6] = (unsigned char) (ctx->ihv[1] >> 8);
 2144|  28.5k|    output[7] = (unsigned char) (ctx->ihv[1]);
 2145|  28.5k|    output[8] = (unsigned char) (ctx->ihv[2] >> 24);
 2146|  28.5k|    output[9] = (unsigned char) (ctx->ihv[2] >> 16);
 2147|  28.5k|    output[10] = (unsigned char) (ctx->ihv[2] >> 8);
 2148|  28.5k|    output[11] = (unsigned char) (ctx->ihv[2]);
 2149|  28.5k|    output[12] = (unsigned char) (ctx->ihv[3] >> 24);
 2150|  28.5k|    output[13] = (unsigned char) (ctx->ihv[3] >> 16);
 2151|  28.5k|    output[14] = (unsigned char) (ctx->ihv[3] >> 8);
 2152|  28.5k|    output[15] = (unsigned char) (ctx->ihv[3]);
 2153|  28.5k|    output[16] = (unsigned char) (ctx->ihv[4] >> 24);
 2154|  28.5k|    output[17] = (unsigned char) (ctx->ihv[4] >> 16);
 2155|  28.5k|    output[18] = (unsigned char) (ctx->ihv[4] >> 8);
 2156|  28.5k|    output[19] = (unsigned char) (ctx->ihv[4]);
 2157|  28.5k|    return ctx->found_collision;
 2158|  28.5k|}
sha1.c:sha1_process:
 1963|   138k|{
 1964|   138k|    unsigned i, j;
 1965|   138k|    uint32_t ubc_dv_mask[DVMASKSIZE] = {0xFFFFFFFF};
 1966|   138k|    uint32_t ihvtmp[5];
 1967|       |
 1968|   138k|    ctx->ihv1[0] = ctx->ihv[0];
 1969|   138k|    ctx->ihv1[1] = ctx->ihv[1];
 1970|   138k|    ctx->ihv1[2] = ctx->ihv[2];
 1971|   138k|    ctx->ihv1[3] = ctx->ihv[3];
 1972|   138k|    ctx->ihv1[4] = ctx->ihv[4];
 1973|       |
 1974|   138k|    sha1_compression_states(ctx->ihv, block, ctx->m1, ctx->states);
 1975|       |
 1976|   138k|    if (ctx->detect_coll) {
  ------------------
  |  Branch (1976:9): [True: 138k, False: 0]
  ------------------
 1977|   138k|        if (ctx->ubc_check) {
  ------------------
  |  Branch (1977:13): [True: 138k, False: 0]
  ------------------
 1978|   138k|            ubc_check(ctx->m1, ubc_dv_mask);
 1979|   138k|        }
 1980|       |
 1981|   138k|        if (ubc_dv_mask[0] != 0) {
  ------------------
  |  Branch (1981:13): [True: 17.1k, False: 121k]
  ------------------
 1982|   566k|            for (i = 0; sha1_dvs[i].dvType != 0; ++i) {
  ------------------
  |  Branch (1982:25): [True: 549k, False: 17.1k]
  ------------------
 1983|   549k|                if (ubc_dv_mask[0] & ((uint32_t)(1) << sha1_dvs[i].maskb)) {
  ------------------
  |  Branch (1983:21): [True: 18.5k, False: 530k]
  ------------------
 1984|  1.50M|                    for (j = 0; j < 80; ++j)
  ------------------
  |  Branch (1984:33): [True: 1.48M, False: 18.5k]
  ------------------
 1985|  1.48M|                        ctx->m2[j] = ctx->m1[j] ^ sha1_dvs[i].dm[j];
 1986|       |
 1987|  18.5k|                    sha1_recompression_step(sha1_dvs[i].testt,
 1988|  18.5k|                                            ctx->ihv2,
 1989|  18.5k|                                            ihvtmp,
 1990|  18.5k|                                            ctx->m2,
 1991|  18.5k|                                            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.5k|                    if ((0 == ((ihvtmp[0] ^ ctx->ihv[0]) | (ihvtmp[1] ^ ctx->ihv[1]) |
  ------------------
  |  Branch (1995:25): [True: 0, False: 18.5k]
  ------------------
 1996|  18.5k|                               (ihvtmp[2] ^ ctx->ihv[2]) | (ihvtmp[3] ^ ctx->ihv[3]) |
 1997|  18.5k|                               (ihvtmp[4] ^ ctx->ihv[4]))) ||
 1998|  18.5k|                        (ctx->reduced_round_coll &&
  ------------------
  |  Branch (1998:26): [True: 0, False: 18.5k]
  ------------------
 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.5k|                }
 2012|   549k|            }
 2013|  17.1k|        }
 2014|   138k|    }
 2015|   138k|}
sha1.c:sha1_recompression_step:
 1554|  18.5k|{
 1555|  18.5k|    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|  12.4k|    case 58:
  ------------------
  |  Branch (1847:5): [True: 12.4k, False: 6.13k]
  ------------------
 1848|  12.4k|        sha1recompress_fast_58(ihvin, ihvout, me2, state);
 1849|  12.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|  6.13k|    case 65:
  ------------------
  |  Branch (1882:5): [True: 6.13k, False: 12.4k]
  ------------------
 1883|  6.13k|        sha1recompress_fast_65(ihvin, ihvout, me2, state);
 1884|  6.13k|        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.5k]
  ------------------
 1957|      0|        abort();
 1958|  18.5k|    }
 1959|  18.5k|}
sha1.c:sha1recompress_fast_58:
  879|  12.4k|    {                                                                                         \
  880|  12.4k|        uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];        \
  881|  12.4k|        if (t > 79)                                                                           \
  ------------------
  |  Branch (881:13): [Folded, False: 12.4k]
  ------------------
  882|  12.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|  12.4k|        if (t > 78)                                                                           \
  ------------------
  |  Branch (883:13): [Folded, False: 12.4k]
  ------------------
  884|  12.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|  12.4k|        if (t > 77)                                                                           \
  ------------------
  |  Branch (885:13): [Folded, False: 12.4k]
  ------------------
  886|  12.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|  12.4k|        if (t > 76)                                                                           \
  ------------------
  |  Branch (887:13): [Folded, False: 12.4k]
  ------------------
  888|  12.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|  12.4k|        if (t > 75)                                                                           \
  ------------------
  |  Branch (889:13): [Folded, False: 12.4k]
  ------------------
  890|  12.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|  12.4k|        if (t > 74)                                                                           \
  ------------------
  |  Branch (891:13): [Folded, False: 12.4k]
  ------------------
  892|  12.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|  12.4k|        if (t > 73)                                                                           \
  ------------------
  |  Branch (893:13): [Folded, False: 12.4k]
  ------------------
  894|  12.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|  12.4k|        if (t > 72)                                                                           \
  ------------------
  |  Branch (895:13): [Folded, False: 12.4k]
  ------------------
  896|  12.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|  12.4k|        if (t > 71)                                                                           \
  ------------------
  |  Branch (897:13): [Folded, False: 12.4k]
  ------------------
  898|  12.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|  12.4k|        if (t > 70)                                                                           \
  ------------------
  |  Branch (899:13): [Folded, False: 12.4k]
  ------------------
  900|  12.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|  12.4k|        if (t > 69)                                                                           \
  ------------------
  |  Branch (901:13): [Folded, False: 12.4k]
  ------------------
  902|  12.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|  12.4k|        if (t > 68)                                                                           \
  ------------------
  |  Branch (903:13): [Folded, False: 12.4k]
  ------------------
  904|  12.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|  12.4k|        if (t > 67)                                                                           \
  ------------------
  |  Branch (905:13): [Folded, False: 12.4k]
  ------------------
  906|  12.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|  12.4k|        if (t > 66)                                                                           \
  ------------------
  |  Branch (907:13): [Folded, False: 12.4k]
  ------------------
  908|  12.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|  12.4k|        if (t > 65)                                                                           \
  ------------------
  |  Branch (909:13): [Folded, False: 12.4k]
  ------------------
  910|  12.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|  12.4k|        if (t > 64)                                                                           \
  ------------------
  |  Branch (911:13): [Folded, False: 12.4k]
  ------------------
  912|  12.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|  12.4k|        if (t > 63)                                                                           \
  ------------------
  |  Branch (913:13): [Folded, False: 12.4k]
  ------------------
  914|  12.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|  12.4k|        if (t > 62)                                                                           \
  ------------------
  |  Branch (915:13): [Folded, False: 12.4k]
  ------------------
  916|  12.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|  12.4k|        if (t > 61)                                                                           \
  ------------------
  |  Branch (917:13): [Folded, False: 12.4k]
  ------------------
  918|  12.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|  12.4k|        if (t > 60)                                                                           \
  ------------------
  |  Branch (919:13): [Folded, False: 12.4k]
  ------------------
  920|  12.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|  12.4k|        if (t > 59)                                                                           \
  ------------------
  |  Branch (921:13): [Folded, False: 12.4k]
  ------------------
  922|  12.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|  12.4k|        if (t > 58)                                                                           \
  ------------------
  |  Branch (923:13): [Folded, False: 12.4k]
  ------------------
  924|  12.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|  12.4k|        if (t > 57)                                                                           \
  ------------------
  |  Branch (925:13): [True: 12.4k, Folded]
  ------------------
  926|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 57);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  927|  12.4k|        if (t > 56)                                                                           \
  ------------------
  |  Branch (927:13): [True: 12.4k, Folded]
  ------------------
  928|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 56);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  929|  12.4k|        if (t > 55)                                                                           \
  ------------------
  |  Branch (929:13): [True: 12.4k, Folded]
  ------------------
  930|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 55);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  931|  12.4k|        if (t > 54)                                                                           \
  ------------------
  |  Branch (931:13): [True: 12.4k, Folded]
  ------------------
  932|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 54);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  933|  12.4k|        if (t > 53)                                                                           \
  ------------------
  |  Branch (933:13): [True: 12.4k, Folded]
  ------------------
  934|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 53);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  935|  12.4k|        if (t > 52)                                                                           \
  ------------------
  |  Branch (935:13): [True: 12.4k, Folded]
  ------------------
  936|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 52);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  937|  12.4k|        if (t > 51)                                                                           \
  ------------------
  |  Branch (937:13): [True: 12.4k, Folded]
  ------------------
  938|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 51);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  939|  12.4k|        if (t > 50)                                                                           \
  ------------------
  |  Branch (939:13): [True: 12.4k, Folded]
  ------------------
  940|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 50);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  941|  12.4k|        if (t > 49)                                                                           \
  ------------------
  |  Branch (941:13): [True: 12.4k, Folded]
  ------------------
  942|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 49);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  943|  12.4k|        if (t > 48)                                                                           \
  ------------------
  |  Branch (943:13): [True: 12.4k, Folded]
  ------------------
  944|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 48);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  945|  12.4k|        if (t > 47)                                                                           \
  ------------------
  |  Branch (945:13): [True: 12.4k, Folded]
  ------------------
  946|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 47);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  947|  12.4k|        if (t > 46)                                                                           \
  ------------------
  |  Branch (947:13): [True: 12.4k, Folded]
  ------------------
  948|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 46);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  949|  12.4k|        if (t > 45)                                                                           \
  ------------------
  |  Branch (949:13): [True: 12.4k, Folded]
  ------------------
  950|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 45);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  951|  12.4k|        if (t > 44)                                                                           \
  ------------------
  |  Branch (951:13): [True: 12.4k, Folded]
  ------------------
  952|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 44);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  953|  12.4k|        if (t > 43)                                                                           \
  ------------------
  |  Branch (953:13): [True: 12.4k, Folded]
  ------------------
  954|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 43);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  955|  12.4k|        if (t > 42)                                                                           \
  ------------------
  |  Branch (955:13): [True: 12.4k, Folded]
  ------------------
  956|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 42);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  957|  12.4k|        if (t > 41)                                                                           \
  ------------------
  |  Branch (957:13): [True: 12.4k, Folded]
  ------------------
  958|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 41);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  959|  12.4k|        if (t > 40)                                                                           \
  ------------------
  |  Branch (959:13): [True: 12.4k, Folded]
  ------------------
  960|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 40);                    \
  ------------------
  |  |  197|  12.4k|    {                                                                  \
  |  |  198|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  12.4k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  12.4k|    }
  ------------------
  961|  12.4k|        if (t > 39)                                                                           \
  ------------------
  |  Branch (961:13): [True: 12.4k, Folded]
  ------------------
  962|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 39);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  963|  12.4k|        if (t > 38)                                                                           \
  ------------------
  |  Branch (963:13): [True: 12.4k, Folded]
  ------------------
  964|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 38);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  965|  12.4k|        if (t > 37)                                                                           \
  ------------------
  |  Branch (965:13): [True: 12.4k, Folded]
  ------------------
  966|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 37);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  967|  12.4k|        if (t > 36)                                                                           \
  ------------------
  |  Branch (967:13): [True: 12.4k, Folded]
  ------------------
  968|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 36);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  969|  12.4k|        if (t > 35)                                                                           \
  ------------------
  |  Branch (969:13): [True: 12.4k, Folded]
  ------------------
  970|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 35);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  971|  12.4k|        if (t > 34)                                                                           \
  ------------------
  |  Branch (971:13): [True: 12.4k, Folded]
  ------------------
  972|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 34);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  973|  12.4k|        if (t > 33)                                                                           \
  ------------------
  |  Branch (973:13): [True: 12.4k, Folded]
  ------------------
  974|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 33);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  975|  12.4k|        if (t > 32)                                                                           \
  ------------------
  |  Branch (975:13): [True: 12.4k, Folded]
  ------------------
  976|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 32);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  977|  12.4k|        if (t > 31)                                                                           \
  ------------------
  |  Branch (977:13): [True: 12.4k, Folded]
  ------------------
  978|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 31);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  979|  12.4k|        if (t > 30)                                                                           \
  ------------------
  |  Branch (979:13): [True: 12.4k, Folded]
  ------------------
  980|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 30);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  981|  12.4k|        if (t > 29)                                                                           \
  ------------------
  |  Branch (981:13): [True: 12.4k, Folded]
  ------------------
  982|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 29);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  983|  12.4k|        if (t > 28)                                                                           \
  ------------------
  |  Branch (983:13): [True: 12.4k, Folded]
  ------------------
  984|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 28);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  985|  12.4k|        if (t > 27)                                                                           \
  ------------------
  |  Branch (985:13): [True: 12.4k, Folded]
  ------------------
  986|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 27);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  987|  12.4k|        if (t > 26)                                                                           \
  ------------------
  |  Branch (987:13): [True: 12.4k, Folded]
  ------------------
  988|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 26);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  989|  12.4k|        if (t > 25)                                                                           \
  ------------------
  |  Branch (989:13): [True: 12.4k, Folded]
  ------------------
  990|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 25);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  991|  12.4k|        if (t > 24)                                                                           \
  ------------------
  |  Branch (991:13): [True: 12.4k, Folded]
  ------------------
  992|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 24);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  993|  12.4k|        if (t > 23)                                                                           \
  ------------------
  |  Branch (993:13): [True: 12.4k, Folded]
  ------------------
  994|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 23);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  995|  12.4k|        if (t > 22)                                                                           \
  ------------------
  |  Branch (995:13): [True: 12.4k, Folded]
  ------------------
  996|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 22);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  997|  12.4k|        if (t > 21)                                                                           \
  ------------------
  |  Branch (997:13): [True: 12.4k, Folded]
  ------------------
  998|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 21);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
  999|  12.4k|        if (t > 20)                                                                           \
  ------------------
  |  Branch (999:13): [True: 12.4k, Folded]
  ------------------
 1000|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 20);                    \
  ------------------
  |  |  192|  12.4k|    {                                                                  \
  |  |  193|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  12.4k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  12.4k|    }
  ------------------
 1001|  12.4k|        if (t > 19)                                                                           \
  ------------------
  |  Branch (1001:13): [True: 12.4k, Folded]
  ------------------
 1002|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 19);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1003|  12.4k|        if (t > 18)                                                                           \
  ------------------
  |  Branch (1003:13): [True: 12.4k, Folded]
  ------------------
 1004|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 18);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1005|  12.4k|        if (t > 17)                                                                           \
  ------------------
  |  Branch (1005:13): [True: 12.4k, Folded]
  ------------------
 1006|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 17);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1007|  12.4k|        if (t > 16)                                                                           \
  ------------------
  |  Branch (1007:13): [True: 12.4k, Folded]
  ------------------
 1008|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 16);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1009|  12.4k|        if (t > 15)                                                                           \
  ------------------
  |  Branch (1009:13): [True: 12.4k, Folded]
  ------------------
 1010|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 15);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1011|  12.4k|        if (t > 14)                                                                           \
  ------------------
  |  Branch (1011:13): [True: 12.4k, Folded]
  ------------------
 1012|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 14);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1013|  12.4k|        if (t > 13)                                                                           \
  ------------------
  |  Branch (1013:13): [True: 12.4k, Folded]
  ------------------
 1014|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 13);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1015|  12.4k|        if (t > 12)                                                                           \
  ------------------
  |  Branch (1015:13): [True: 12.4k, Folded]
  ------------------
 1016|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 12);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1017|  12.4k|        if (t > 11)                                                                           \
  ------------------
  |  Branch (1017:13): [True: 12.4k, Folded]
  ------------------
 1018|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 11);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1019|  12.4k|        if (t > 10)                                                                           \
  ------------------
  |  Branch (1019:13): [True: 12.4k, Folded]
  ------------------
 1020|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 10);                    \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1021|  12.4k|        if (t > 9)                                                                            \
  ------------------
  |  Branch (1021:13): [True: 12.4k, Folded]
  ------------------
 1022|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 9);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1023|  12.4k|        if (t > 8)                                                                            \
  ------------------
  |  Branch (1023:13): [True: 12.4k, Folded]
  ------------------
 1024|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 8);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1025|  12.4k|        if (t > 7)                                                                            \
  ------------------
  |  Branch (1025:13): [True: 12.4k, Folded]
  ------------------
 1026|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 7);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1027|  12.4k|        if (t > 6)                                                                            \
  ------------------
  |  Branch (1027:13): [True: 12.4k, Folded]
  ------------------
 1028|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 6);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1029|  12.4k|        if (t > 5)                                                                            \
  ------------------
  |  Branch (1029:13): [True: 12.4k, Folded]
  ------------------
 1030|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 5);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1031|  12.4k|        if (t > 4)                                                                            \
  ------------------
  |  Branch (1031:13): [True: 12.4k, Folded]
  ------------------
 1032|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 4);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1033|  12.4k|        if (t > 3)                                                                            \
  ------------------
  |  Branch (1033:13): [True: 12.4k, Folded]
  ------------------
 1034|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 3);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1035|  12.4k|        if (t > 2)                                                                            \
  ------------------
  |  Branch (1035:13): [True: 12.4k, Folded]
  ------------------
 1036|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 2);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1037|  12.4k|        if (t > 1)                                                                            \
  ------------------
  |  Branch (1037:13): [True: 12.4k, Folded]
  ------------------
 1038|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 1);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1039|  12.4k|        if (t > 0)                                                                            \
  ------------------
  |  Branch (1039:13): [True: 12.4k, Folded]
  ------------------
 1040|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 0);                     \
  ------------------
  |  |  187|  12.4k|    {                                                                  \
  |  |  188|  12.4k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  12.4k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  12.4k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  12.4k|    }
  ------------------
 1041|  12.4k|        ihvin[0] = a;                                                                         \
 1042|  12.4k|        ihvin[1] = b;                                                                         \
 1043|  12.4k|        ihvin[2] = c;                                                                         \
 1044|  12.4k|        ihvin[3] = d;                                                                         \
 1045|  12.4k|        ihvin[4] = e;                                                                         \
 1046|  12.4k|        a = state[0];                                                                         \
 1047|  12.4k|        b = state[1];                                                                         \
 1048|  12.4k|        c = state[2];                                                                         \
 1049|  12.4k|        d = state[3];                                                                         \
 1050|  12.4k|        e = state[4];                                                                         \
 1051|  12.4k|        if (t <= 0)                                                                           \
  ------------------
  |  Branch (1051:13): [Folded, False: 12.4k]
  ------------------
 1052|  12.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|  12.4k|        if (t <= 1)                                                                           \
  ------------------
  |  Branch (1053:13): [Folded, False: 12.4k]
  ------------------
 1054|  12.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|  12.4k|        if (t <= 2)                                                                           \
  ------------------
  |  Branch (1055:13): [Folded, False: 12.4k]
  ------------------
 1056|  12.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|  12.4k|        if (t <= 3)                                                                           \
  ------------------
  |  Branch (1057:13): [Folded, False: 12.4k]
  ------------------
 1058|  12.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|  12.4k|        if (t <= 4)                                                                           \
  ------------------
  |  Branch (1059:13): [Folded, False: 12.4k]
  ------------------
 1060|  12.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|  12.4k|        if (t <= 5)                                                                           \
  ------------------
  |  Branch (1061:13): [Folded, False: 12.4k]
  ------------------
 1062|  12.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|  12.4k|        if (t <= 6)                                                                           \
  ------------------
  |  Branch (1063:13): [Folded, False: 12.4k]
  ------------------
 1064|  12.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|  12.4k|        if (t <= 7)                                                                           \
  ------------------
  |  Branch (1065:13): [Folded, False: 12.4k]
  ------------------
 1066|  12.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|  12.4k|        if (t <= 8)                                                                           \
  ------------------
  |  Branch (1067:13): [Folded, False: 12.4k]
  ------------------
 1068|  12.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|  12.4k|        if (t <= 9)                                                                           \
  ------------------
  |  Branch (1069:13): [Folded, False: 12.4k]
  ------------------
 1070|  12.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|  12.4k|        if (t <= 10)                                                                          \
  ------------------
  |  Branch (1071:13): [Folded, False: 12.4k]
  ------------------
 1072|  12.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|  12.4k|        if (t <= 11)                                                                          \
  ------------------
  |  Branch (1073:13): [Folded, False: 12.4k]
  ------------------
 1074|  12.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|  12.4k|        if (t <= 12)                                                                          \
  ------------------
  |  Branch (1075:13): [Folded, False: 12.4k]
  ------------------
 1076|  12.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|  12.4k|        if (t <= 13)                                                                          \
  ------------------
  |  Branch (1077:13): [Folded, False: 12.4k]
  ------------------
 1078|  12.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|  12.4k|        if (t <= 14)                                                                          \
  ------------------
  |  Branch (1079:13): [Folded, False: 12.4k]
  ------------------
 1080|  12.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|  12.4k|        if (t <= 15)                                                                          \
  ------------------
  |  Branch (1081:13): [Folded, False: 12.4k]
  ------------------
 1082|  12.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|  12.4k|        if (t <= 16)                                                                          \
  ------------------
  |  Branch (1083:13): [Folded, False: 12.4k]
  ------------------
 1084|  12.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|  12.4k|        if (t <= 17)                                                                          \
  ------------------
  |  Branch (1085:13): [Folded, False: 12.4k]
  ------------------
 1086|  12.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|  12.4k|        if (t <= 18)                                                                          \
  ------------------
  |  Branch (1087:13): [Folded, False: 12.4k]
  ------------------
 1088|  12.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|  12.4k|        if (t <= 19)                                                                          \
  ------------------
  |  Branch (1089:13): [Folded, False: 12.4k]
  ------------------
 1090|  12.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|  12.4k|        if (t <= 20)                                                                          \
  ------------------
  |  Branch (1091:13): [Folded, False: 12.4k]
  ------------------
 1092|  12.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|  12.4k|        if (t <= 21)                                                                          \
  ------------------
  |  Branch (1093:13): [Folded, False: 12.4k]
  ------------------
 1094|  12.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|  12.4k|        if (t <= 22)                                                                          \
  ------------------
  |  Branch (1095:13): [Folded, False: 12.4k]
  ------------------
 1096|  12.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|  12.4k|        if (t <= 23)                                                                          \
  ------------------
  |  Branch (1097:13): [Folded, False: 12.4k]
  ------------------
 1098|  12.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|  12.4k|        if (t <= 24)                                                                          \
  ------------------
  |  Branch (1099:13): [Folded, False: 12.4k]
  ------------------
 1100|  12.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|  12.4k|        if (t <= 25)                                                                          \
  ------------------
  |  Branch (1101:13): [Folded, False: 12.4k]
  ------------------
 1102|  12.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|  12.4k|        if (t <= 26)                                                                          \
  ------------------
  |  Branch (1103:13): [Folded, False: 12.4k]
  ------------------
 1104|  12.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|  12.4k|        if (t <= 27)                                                                          \
  ------------------
  |  Branch (1105:13): [Folded, False: 12.4k]
  ------------------
 1106|  12.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|  12.4k|        if (t <= 28)                                                                          \
  ------------------
  |  Branch (1107:13): [Folded, False: 12.4k]
  ------------------
 1108|  12.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|  12.4k|        if (t <= 29)                                                                          \
  ------------------
  |  Branch (1109:13): [Folded, False: 12.4k]
  ------------------
 1110|  12.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|  12.4k|        if (t <= 30)                                                                          \
  ------------------
  |  Branch (1111:13): [Folded, False: 12.4k]
  ------------------
 1112|  12.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|  12.4k|        if (t <= 31)                                                                          \
  ------------------
  |  Branch (1113:13): [Folded, False: 12.4k]
  ------------------
 1114|  12.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|  12.4k|        if (t <= 32)                                                                          \
  ------------------
  |  Branch (1115:13): [Folded, False: 12.4k]
  ------------------
 1116|  12.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|  12.4k|        if (t <= 33)                                                                          \
  ------------------
  |  Branch (1117:13): [Folded, False: 12.4k]
  ------------------
 1118|  12.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|  12.4k|        if (t <= 34)                                                                          \
  ------------------
  |  Branch (1119:13): [Folded, False: 12.4k]
  ------------------
 1120|  12.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|  12.4k|        if (t <= 35)                                                                          \
  ------------------
  |  Branch (1121:13): [Folded, False: 12.4k]
  ------------------
 1122|  12.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|  12.4k|        if (t <= 36)                                                                          \
  ------------------
  |  Branch (1123:13): [Folded, False: 12.4k]
  ------------------
 1124|  12.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|  12.4k|        if (t <= 37)                                                                          \
  ------------------
  |  Branch (1125:13): [Folded, False: 12.4k]
  ------------------
 1126|  12.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|  12.4k|        if (t <= 38)                                                                          \
  ------------------
  |  Branch (1127:13): [Folded, False: 12.4k]
  ------------------
 1128|  12.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|  12.4k|        if (t <= 39)                                                                          \
  ------------------
  |  Branch (1129:13): [Folded, False: 12.4k]
  ------------------
 1130|  12.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|  12.4k|        if (t <= 40)                                                                          \
  ------------------
  |  Branch (1131:13): [Folded, False: 12.4k]
  ------------------
 1132|  12.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|  12.4k|        if (t <= 41)                                                                          \
  ------------------
  |  Branch (1133:13): [Folded, False: 12.4k]
  ------------------
 1134|  12.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|  12.4k|        if (t <= 42)                                                                          \
  ------------------
  |  Branch (1135:13): [Folded, False: 12.4k]
  ------------------
 1136|  12.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|  12.4k|        if (t <= 43)                                                                          \
  ------------------
  |  Branch (1137:13): [Folded, False: 12.4k]
  ------------------
 1138|  12.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|  12.4k|        if (t <= 44)                                                                          \
  ------------------
  |  Branch (1139:13): [Folded, False: 12.4k]
  ------------------
 1140|  12.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|  12.4k|        if (t <= 45)                                                                          \
  ------------------
  |  Branch (1141:13): [Folded, False: 12.4k]
  ------------------
 1142|  12.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|  12.4k|        if (t <= 46)                                                                          \
  ------------------
  |  Branch (1143:13): [Folded, False: 12.4k]
  ------------------
 1144|  12.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|  12.4k|        if (t <= 47)                                                                          \
  ------------------
  |  Branch (1145:13): [Folded, False: 12.4k]
  ------------------
 1146|  12.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|  12.4k|        if (t <= 48)                                                                          \
  ------------------
  |  Branch (1147:13): [Folded, False: 12.4k]
  ------------------
 1148|  12.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|  12.4k|        if (t <= 49)                                                                          \
  ------------------
  |  Branch (1149:13): [Folded, False: 12.4k]
  ------------------
 1150|  12.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|  12.4k|        if (t <= 50)                                                                          \
  ------------------
  |  Branch (1151:13): [Folded, False: 12.4k]
  ------------------
 1152|  12.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|  12.4k|        if (t <= 51)                                                                          \
  ------------------
  |  Branch (1153:13): [Folded, False: 12.4k]
  ------------------
 1154|  12.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|  12.4k|        if (t <= 52)                                                                          \
  ------------------
  |  Branch (1155:13): [Folded, False: 12.4k]
  ------------------
 1156|  12.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|  12.4k|        if (t <= 53)                                                                          \
  ------------------
  |  Branch (1157:13): [Folded, False: 12.4k]
  ------------------
 1158|  12.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|  12.4k|        if (t <= 54)                                                                          \
  ------------------
  |  Branch (1159:13): [Folded, False: 12.4k]
  ------------------
 1160|  12.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|  12.4k|        if (t <= 55)                                                                          \
  ------------------
  |  Branch (1161:13): [Folded, False: 12.4k]
  ------------------
 1162|  12.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|  12.4k|        if (t <= 56)                                                                          \
  ------------------
  |  Branch (1163:13): [Folded, False: 12.4k]
  ------------------
 1164|  12.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|  12.4k|        if (t <= 57)                                                                          \
  ------------------
  |  Branch (1165:13): [Folded, False: 12.4k]
  ------------------
 1166|  12.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|  12.4k|        if (t <= 58)                                                                          \
  ------------------
  |  Branch (1167:13): [True: 12.4k, Folded]
  ------------------
 1168|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 58);                       \
  ------------------
  |  |  176|  12.4k|    {                                                                  \
  |  |  177|  12.4k|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|  12.4k|    }
  ------------------
 1169|  12.4k|        if (t <= 59)                                                                          \
  ------------------
  |  Branch (1169:13): [True: 12.4k, Folded]
  ------------------
 1170|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 59);                       \
  ------------------
  |  |  176|  12.4k|    {                                                                  \
  |  |  177|  12.4k|        e += rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  178|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  179|  12.4k|    }
  ------------------
 1171|  12.4k|        if (t <= 60)                                                                          \
  ------------------
  |  Branch (1171:13): [True: 12.4k, Folded]
  ------------------
 1172|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 60);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1173|  12.4k|        if (t <= 61)                                                                          \
  ------------------
  |  Branch (1173:13): [True: 12.4k, Folded]
  ------------------
 1174|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 61);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1175|  12.4k|        if (t <= 62)                                                                          \
  ------------------
  |  Branch (1175:13): [True: 12.4k, Folded]
  ------------------
 1176|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 62);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1177|  12.4k|        if (t <= 63)                                                                          \
  ------------------
  |  Branch (1177:13): [True: 12.4k, Folded]
  ------------------
 1178|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 63);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1179|  12.4k|        if (t <= 64)                                                                          \
  ------------------
  |  Branch (1179:13): [True: 12.4k, Folded]
  ------------------
 1180|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 64);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1181|  12.4k|        if (t <= 65)                                                                          \
  ------------------
  |  Branch (1181:13): [True: 12.4k, Folded]
  ------------------
 1182|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 65);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1183|  12.4k|        if (t <= 66)                                                                          \
  ------------------
  |  Branch (1183:13): [True: 12.4k, Folded]
  ------------------
 1184|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 66);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1185|  12.4k|        if (t <= 67)                                                                          \
  ------------------
  |  Branch (1185:13): [True: 12.4k, Folded]
  ------------------
 1186|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 67);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1187|  12.4k|        if (t <= 68)                                                                          \
  ------------------
  |  Branch (1187:13): [True: 12.4k, Folded]
  ------------------
 1188|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 68);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1189|  12.4k|        if (t <= 69)                                                                          \
  ------------------
  |  Branch (1189:13): [True: 12.4k, Folded]
  ------------------
 1190|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 69);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1191|  12.4k|        if (t <= 70)                                                                          \
  ------------------
  |  Branch (1191:13): [True: 12.4k, Folded]
  ------------------
 1192|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 70);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1193|  12.4k|        if (t <= 71)                                                                          \
  ------------------
  |  Branch (1193:13): [True: 12.4k, Folded]
  ------------------
 1194|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 71);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1195|  12.4k|        if (t <= 72)                                                                          \
  ------------------
  |  Branch (1195:13): [True: 12.4k, Folded]
  ------------------
 1196|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 72);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1197|  12.4k|        if (t <= 73)                                                                          \
  ------------------
  |  Branch (1197:13): [True: 12.4k, Folded]
  ------------------
 1198|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 73);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1199|  12.4k|        if (t <= 74)                                                                          \
  ------------------
  |  Branch (1199:13): [True: 12.4k, Folded]
  ------------------
 1200|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 74);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1201|  12.4k|        if (t <= 75)                                                                          \
  ------------------
  |  Branch (1201:13): [True: 12.4k, Folded]
  ------------------
 1202|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 75);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1203|  12.4k|        if (t <= 76)                                                                          \
  ------------------
  |  Branch (1203:13): [True: 12.4k, Folded]
  ------------------
 1204|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 76);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1205|  12.4k|        if (t <= 77)                                                                          \
  ------------------
  |  Branch (1205:13): [True: 12.4k, Folded]
  ------------------
 1206|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 77);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1207|  12.4k|        if (t <= 78)                                                                          \
  ------------------
  |  Branch (1207:13): [True: 12.4k, Folded]
  ------------------
 1208|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 78);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1209|  12.4k|        if (t <= 79)                                                                          \
  ------------------
  |  Branch (1209:13): [True: 12.4k, Folded]
  ------------------
 1210|  12.4k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 79);                       \
  ------------------
  |  |  181|  12.4k|    {                                                                  \
  |  |  182|  12.4k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  12.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|  12.4k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  12.4k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  12.4k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  12.4k|    }
  ------------------
 1211|  12.4k|        ihvout[0] = ihvin[0] + a;                                                             \
 1212|  12.4k|        ihvout[1] = ihvin[1] + b;                                                             \
 1213|  12.4k|        ihvout[2] = ihvin[2] + c;                                                             \
 1214|  12.4k|        ihvout[3] = ihvin[3] + d;                                                             \
 1215|  12.4k|        ihvout[4] = ihvin[4] + e;                                                             \
 1216|  12.4k|    }
sha1.c:sha1recompress_fast_65:
  879|  6.13k|    {                                                                                         \
  880|  6.13k|        uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];        \
  881|  6.13k|        if (t > 79)                                                                           \
  ------------------
  |  Branch (881:13): [Folded, False: 6.13k]
  ------------------
  882|  6.13k|            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|  6.13k|        if (t > 78)                                                                           \
  ------------------
  |  Branch (883:13): [Folded, False: 6.13k]
  ------------------
  884|  6.13k|            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|  6.13k|        if (t > 77)                                                                           \
  ------------------
  |  Branch (885:13): [Folded, False: 6.13k]
  ------------------
  886|  6.13k|            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|  6.13k|        if (t > 76)                                                                           \
  ------------------
  |  Branch (887:13): [Folded, False: 6.13k]
  ------------------
  888|  6.13k|            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|  6.13k|        if (t > 75)                                                                           \
  ------------------
  |  Branch (889:13): [Folded, False: 6.13k]
  ------------------
  890|  6.13k|            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|  6.13k|        if (t > 74)                                                                           \
  ------------------
  |  Branch (891:13): [Folded, False: 6.13k]
  ------------------
  892|  6.13k|            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|  6.13k|        if (t > 73)                                                                           \
  ------------------
  |  Branch (893:13): [Folded, False: 6.13k]
  ------------------
  894|  6.13k|            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|  6.13k|        if (t > 72)                                                                           \
  ------------------
  |  Branch (895:13): [Folded, False: 6.13k]
  ------------------
  896|  6.13k|            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|  6.13k|        if (t > 71)                                                                           \
  ------------------
  |  Branch (897:13): [Folded, False: 6.13k]
  ------------------
  898|  6.13k|            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|  6.13k|        if (t > 70)                                                                           \
  ------------------
  |  Branch (899:13): [Folded, False: 6.13k]
  ------------------
  900|  6.13k|            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|  6.13k|        if (t > 69)                                                                           \
  ------------------
  |  Branch (901:13): [Folded, False: 6.13k]
  ------------------
  902|  6.13k|            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|  6.13k|        if (t > 68)                                                                           \
  ------------------
  |  Branch (903:13): [Folded, False: 6.13k]
  ------------------
  904|  6.13k|            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|  6.13k|        if (t > 67)                                                                           \
  ------------------
  |  Branch (905:13): [Folded, False: 6.13k]
  ------------------
  906|  6.13k|            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|  6.13k|        if (t > 66)                                                                           \
  ------------------
  |  Branch (907:13): [Folded, False: 6.13k]
  ------------------
  908|  6.13k|            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|  6.13k|        if (t > 65)                                                                           \
  ------------------
  |  Branch (909:13): [Folded, False: 6.13k]
  ------------------
  910|  6.13k|            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|  6.13k|        if (t > 64)                                                                           \
  ------------------
  |  Branch (911:13): [True: 6.13k, Folded]
  ------------------
  912|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 64);                    \
  ------------------
  |  |  202|  6.13k|    {                                                                  \
  |  |  203|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  6.13k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  6.13k|    }
  ------------------
  913|  6.13k|        if (t > 63)                                                                           \
  ------------------
  |  Branch (913:13): [True: 6.13k, Folded]
  ------------------
  914|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 63);                    \
  ------------------
  |  |  202|  6.13k|    {                                                                  \
  |  |  203|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  6.13k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  6.13k|    }
  ------------------
  915|  6.13k|        if (t > 62)                                                                           \
  ------------------
  |  Branch (915:13): [True: 6.13k, Folded]
  ------------------
  916|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 62);                    \
  ------------------
  |  |  202|  6.13k|    {                                                                  \
  |  |  203|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  6.13k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  6.13k|    }
  ------------------
  917|  6.13k|        if (t > 61)                                                                           \
  ------------------
  |  Branch (917:13): [True: 6.13k, Folded]
  ------------------
  918|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 61);                    \
  ------------------
  |  |  202|  6.13k|    {                                                                  \
  |  |  203|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  6.13k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  6.13k|    }
  ------------------
  919|  6.13k|        if (t > 60)                                                                           \
  ------------------
  |  Branch (919:13): [True: 6.13k, Folded]
  ------------------
  920|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 60);                    \
  ------------------
  |  |  202|  6.13k|    {                                                                  \
  |  |  203|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  204|  6.13k|        e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  205|  6.13k|    }
  ------------------
  921|  6.13k|        if (t > 59)                                                                           \
  ------------------
  |  Branch (921:13): [True: 6.13k, Folded]
  ------------------
  922|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 59);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  923|  6.13k|        if (t > 58)                                                                           \
  ------------------
  |  Branch (923:13): [True: 6.13k, Folded]
  ------------------
  924|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 58);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  925|  6.13k|        if (t > 57)                                                                           \
  ------------------
  |  Branch (925:13): [True: 6.13k, Folded]
  ------------------
  926|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 57);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  927|  6.13k|        if (t > 56)                                                                           \
  ------------------
  |  Branch (927:13): [True: 6.13k, Folded]
  ------------------
  928|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 56);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  929|  6.13k|        if (t > 55)                                                                           \
  ------------------
  |  Branch (929:13): [True: 6.13k, Folded]
  ------------------
  930|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 55);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  931|  6.13k|        if (t > 54)                                                                           \
  ------------------
  |  Branch (931:13): [True: 6.13k, Folded]
  ------------------
  932|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 54);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  933|  6.13k|        if (t > 53)                                                                           \
  ------------------
  |  Branch (933:13): [True: 6.13k, Folded]
  ------------------
  934|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 53);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  935|  6.13k|        if (t > 52)                                                                           \
  ------------------
  |  Branch (935:13): [True: 6.13k, Folded]
  ------------------
  936|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 52);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  937|  6.13k|        if (t > 51)                                                                           \
  ------------------
  |  Branch (937:13): [True: 6.13k, Folded]
  ------------------
  938|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 51);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  939|  6.13k|        if (t > 50)                                                                           \
  ------------------
  |  Branch (939:13): [True: 6.13k, Folded]
  ------------------
  940|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 50);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  941|  6.13k|        if (t > 49)                                                                           \
  ------------------
  |  Branch (941:13): [True: 6.13k, Folded]
  ------------------
  942|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 49);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  943|  6.13k|        if (t > 48)                                                                           \
  ------------------
  |  Branch (943:13): [True: 6.13k, Folded]
  ------------------
  944|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 48);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  945|  6.13k|        if (t > 47)                                                                           \
  ------------------
  |  Branch (945:13): [True: 6.13k, Folded]
  ------------------
  946|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 47);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  947|  6.13k|        if (t > 46)                                                                           \
  ------------------
  |  Branch (947:13): [True: 6.13k, Folded]
  ------------------
  948|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 46);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  949|  6.13k|        if (t > 45)                                                                           \
  ------------------
  |  Branch (949:13): [True: 6.13k, Folded]
  ------------------
  950|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 45);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  951|  6.13k|        if (t > 44)                                                                           \
  ------------------
  |  Branch (951:13): [True: 6.13k, Folded]
  ------------------
  952|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 44);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  953|  6.13k|        if (t > 43)                                                                           \
  ------------------
  |  Branch (953:13): [True: 6.13k, Folded]
  ------------------
  954|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 43);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  955|  6.13k|        if (t > 42)                                                                           \
  ------------------
  |  Branch (955:13): [True: 6.13k, Folded]
  ------------------
  956|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 42);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  957|  6.13k|        if (t > 41)                                                                           \
  ------------------
  |  Branch (957:13): [True: 6.13k, Folded]
  ------------------
  958|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 41);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  959|  6.13k|        if (t > 40)                                                                           \
  ------------------
  |  Branch (959:13): [True: 6.13k, Folded]
  ------------------
  960|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 40);                    \
  ------------------
  |  |  197|  6.13k|    {                                                                  \
  |  |  198|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  199|  6.13k|        e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f3(b, c, d) + 0x8F1BBCDC + m[t]; \
  |  |  ------------------
  |  |  |  |  162|  6.13k|#define sha1_f3(b, c, d) (((b) & (c)) + ((d) & ((b) ^ (c))))
  |  |  ------------------
  |  |  200|  6.13k|    }
  ------------------
  961|  6.13k|        if (t > 39)                                                                           \
  ------------------
  |  Branch (961:13): [True: 6.13k, Folded]
  ------------------
  962|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 39);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  963|  6.13k|        if (t > 38)                                                                           \
  ------------------
  |  Branch (963:13): [True: 6.13k, Folded]
  ------------------
  964|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 38);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  965|  6.13k|        if (t > 37)                                                                           \
  ------------------
  |  Branch (965:13): [True: 6.13k, Folded]
  ------------------
  966|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 37);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  967|  6.13k|        if (t > 36)                                                                           \
  ------------------
  |  Branch (967:13): [True: 6.13k, Folded]
  ------------------
  968|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 36);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  969|  6.13k|        if (t > 35)                                                                           \
  ------------------
  |  Branch (969:13): [True: 6.13k, Folded]
  ------------------
  970|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 35);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  971|  6.13k|        if (t > 34)                                                                           \
  ------------------
  |  Branch (971:13): [True: 6.13k, Folded]
  ------------------
  972|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 34);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  973|  6.13k|        if (t > 33)                                                                           \
  ------------------
  |  Branch (973:13): [True: 6.13k, Folded]
  ------------------
  974|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 33);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  975|  6.13k|        if (t > 32)                                                                           \
  ------------------
  |  Branch (975:13): [True: 6.13k, Folded]
  ------------------
  976|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 32);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  977|  6.13k|        if (t > 31)                                                                           \
  ------------------
  |  Branch (977:13): [True: 6.13k, Folded]
  ------------------
  978|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 31);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  979|  6.13k|        if (t > 30)                                                                           \
  ------------------
  |  Branch (979:13): [True: 6.13k, Folded]
  ------------------
  980|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 30);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  981|  6.13k|        if (t > 29)                                                                           \
  ------------------
  |  Branch (981:13): [True: 6.13k, Folded]
  ------------------
  982|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 29);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  983|  6.13k|        if (t > 28)                                                                           \
  ------------------
  |  Branch (983:13): [True: 6.13k, Folded]
  ------------------
  984|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 28);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  985|  6.13k|        if (t > 27)                                                                           \
  ------------------
  |  Branch (985:13): [True: 6.13k, Folded]
  ------------------
  986|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 27);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  987|  6.13k|        if (t > 26)                                                                           \
  ------------------
  |  Branch (987:13): [True: 6.13k, Folded]
  ------------------
  988|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 26);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  989|  6.13k|        if (t > 25)                                                                           \
  ------------------
  |  Branch (989:13): [True: 6.13k, Folded]
  ------------------
  990|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 25);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  991|  6.13k|        if (t > 24)                                                                           \
  ------------------
  |  Branch (991:13): [True: 6.13k, Folded]
  ------------------
  992|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 24);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  993|  6.13k|        if (t > 23)                                                                           \
  ------------------
  |  Branch (993:13): [True: 6.13k, Folded]
  ------------------
  994|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 23);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  995|  6.13k|        if (t > 22)                                                                           \
  ------------------
  |  Branch (995:13): [True: 6.13k, Folded]
  ------------------
  996|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 22);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  997|  6.13k|        if (t > 21)                                                                           \
  ------------------
  |  Branch (997:13): [True: 6.13k, Folded]
  ------------------
  998|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 21);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
  999|  6.13k|        if (t > 20)                                                                           \
  ------------------
  |  Branch (999:13): [True: 6.13k, Folded]
  ------------------
 1000|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 20);                    \
  ------------------
  |  |  192|  6.13k|    {                                                                  \
  |  |  193|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  194|  6.13k|        e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f2(b, c, d) + 0x6ED9EBA1 + m[t]; \
  |  |  ------------------
  |  |  |  |  161|  6.13k|#define sha1_f2(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  195|  6.13k|    }
  ------------------
 1001|  6.13k|        if (t > 19)                                                                           \
  ------------------
  |  Branch (1001:13): [True: 6.13k, Folded]
  ------------------
 1002|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 19);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1003|  6.13k|        if (t > 18)                                                                           \
  ------------------
  |  Branch (1003:13): [True: 6.13k, Folded]
  ------------------
 1004|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 18);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1005|  6.13k|        if (t > 17)                                                                           \
  ------------------
  |  Branch (1005:13): [True: 6.13k, Folded]
  ------------------
 1006|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 17);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1007|  6.13k|        if (t > 16)                                                                           \
  ------------------
  |  Branch (1007:13): [True: 6.13k, Folded]
  ------------------
 1008|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 16);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1009|  6.13k|        if (t > 15)                                                                           \
  ------------------
  |  Branch (1009:13): [True: 6.13k, Folded]
  ------------------
 1010|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 15);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1011|  6.13k|        if (t > 14)                                                                           \
  ------------------
  |  Branch (1011:13): [True: 6.13k, Folded]
  ------------------
 1012|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 14);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1013|  6.13k|        if (t > 13)                                                                           \
  ------------------
  |  Branch (1013:13): [True: 6.13k, Folded]
  ------------------
 1014|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 13);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1015|  6.13k|        if (t > 12)                                                                           \
  ------------------
  |  Branch (1015:13): [True: 6.13k, Folded]
  ------------------
 1016|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 12);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1017|  6.13k|        if (t > 11)                                                                           \
  ------------------
  |  Branch (1017:13): [True: 6.13k, Folded]
  ------------------
 1018|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 11);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1019|  6.13k|        if (t > 10)                                                                           \
  ------------------
  |  Branch (1019:13): [True: 6.13k, Folded]
  ------------------
 1020|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 10);                    \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1021|  6.13k|        if (t > 9)                                                                            \
  ------------------
  |  Branch (1021:13): [True: 6.13k, Folded]
  ------------------
 1022|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 9);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1023|  6.13k|        if (t > 8)                                                                            \
  ------------------
  |  Branch (1023:13): [True: 6.13k, Folded]
  ------------------
 1024|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 8);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1025|  6.13k|        if (t > 7)                                                                            \
  ------------------
  |  Branch (1025:13): [True: 6.13k, Folded]
  ------------------
 1026|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 7);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1027|  6.13k|        if (t > 6)                                                                            \
  ------------------
  |  Branch (1027:13): [True: 6.13k, Folded]
  ------------------
 1028|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 6);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1029|  6.13k|        if (t > 5)                                                                            \
  ------------------
  |  Branch (1029:13): [True: 6.13k, Folded]
  ------------------
 1030|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 5);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1031|  6.13k|        if (t > 4)                                                                            \
  ------------------
  |  Branch (1031:13): [True: 6.13k, Folded]
  ------------------
 1032|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 4);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1033|  6.13k|        if (t > 3)                                                                            \
  ------------------
  |  Branch (1033:13): [True: 6.13k, Folded]
  ------------------
 1034|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 3);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1035|  6.13k|        if (t > 2)                                                                            \
  ------------------
  |  Branch (1035:13): [True: 6.13k, Folded]
  ------------------
 1036|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 2);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1037|  6.13k|        if (t > 1)                                                                            \
  ------------------
  |  Branch (1037:13): [True: 6.13k, Folded]
  ------------------
 1038|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 1);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1039|  6.13k|        if (t > 0)                                                                            \
  ------------------
  |  Branch (1039:13): [True: 6.13k, Folded]
  ------------------
 1040|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 0);                     \
  ------------------
  |  |  187|  6.13k|    {                                                                  \
  |  |  188|  6.13k|        b = rotate_right(b, 30);                                       \
  |  |  ------------------
  |  |  |  |  134|  6.13k|#define rotate_right(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
  |  |  ------------------
  |  |  189|  6.13k|        e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e -= rotate_left(a, 5) + sha1_f1(b, c, d) + 0x5A827999 + m[t]; \
  |  |  ------------------
  |  |  |  |  160|  6.13k|#define sha1_f1(b, c, d) ((d) ^ ((b) & ((c) ^ (d))))
  |  |  ------------------
  |  |  190|  6.13k|    }
  ------------------
 1041|  6.13k|        ihvin[0] = a;                                                                         \
 1042|  6.13k|        ihvin[1] = b;                                                                         \
 1043|  6.13k|        ihvin[2] = c;                                                                         \
 1044|  6.13k|        ihvin[3] = d;                                                                         \
 1045|  6.13k|        ihvin[4] = e;                                                                         \
 1046|  6.13k|        a = state[0];                                                                         \
 1047|  6.13k|        b = state[1];                                                                         \
 1048|  6.13k|        c = state[2];                                                                         \
 1049|  6.13k|        d = state[3];                                                                         \
 1050|  6.13k|        e = state[4];                                                                         \
 1051|  6.13k|        if (t <= 0)                                                                           \
  ------------------
  |  Branch (1051:13): [Folded, False: 6.13k]
  ------------------
 1052|  6.13k|            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|  6.13k|        if (t <= 1)                                                                           \
  ------------------
  |  Branch (1053:13): [Folded, False: 6.13k]
  ------------------
 1054|  6.13k|            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|  6.13k|        if (t <= 2)                                                                           \
  ------------------
  |  Branch (1055:13): [Folded, False: 6.13k]
  ------------------
 1056|  6.13k|            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|  6.13k|        if (t <= 3)                                                                           \
  ------------------
  |  Branch (1057:13): [Folded, False: 6.13k]
  ------------------
 1058|  6.13k|            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|  6.13k|        if (t <= 4)                                                                           \
  ------------------
  |  Branch (1059:13): [Folded, False: 6.13k]
  ------------------
 1060|  6.13k|            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|  6.13k|        if (t <= 5)                                                                           \
  ------------------
  |  Branch (1061:13): [Folded, False: 6.13k]
  ------------------
 1062|  6.13k|            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|  6.13k|        if (t <= 6)                                                                           \
  ------------------
  |  Branch (1063:13): [Folded, False: 6.13k]
  ------------------
 1064|  6.13k|            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|  6.13k|        if (t <= 7)                                                                           \
  ------------------
  |  Branch (1065:13): [Folded, False: 6.13k]
  ------------------
 1066|  6.13k|            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|  6.13k|        if (t <= 8)                                                                           \
  ------------------
  |  Branch (1067:13): [Folded, False: 6.13k]
  ------------------
 1068|  6.13k|            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|  6.13k|        if (t <= 9)                                                                           \
  ------------------
  |  Branch (1069:13): [Folded, False: 6.13k]
  ------------------
 1070|  6.13k|            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|  6.13k|        if (t <= 10)                                                                          \
  ------------------
  |  Branch (1071:13): [Folded, False: 6.13k]
  ------------------
 1072|  6.13k|            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|  6.13k|        if (t <= 11)                                                                          \
  ------------------
  |  Branch (1073:13): [Folded, False: 6.13k]
  ------------------
 1074|  6.13k|            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|  6.13k|        if (t <= 12)                                                                          \
  ------------------
  |  Branch (1075:13): [Folded, False: 6.13k]
  ------------------
 1076|  6.13k|            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|  6.13k|        if (t <= 13)                                                                          \
  ------------------
  |  Branch (1077:13): [Folded, False: 6.13k]
  ------------------
 1078|  6.13k|            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|  6.13k|        if (t <= 14)                                                                          \
  ------------------
  |  Branch (1079:13): [Folded, False: 6.13k]
  ------------------
 1080|  6.13k|            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|  6.13k|        if (t <= 15)                                                                          \
  ------------------
  |  Branch (1081:13): [Folded, False: 6.13k]
  ------------------
 1082|  6.13k|            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|  6.13k|        if (t <= 16)                                                                          \
  ------------------
  |  Branch (1083:13): [Folded, False: 6.13k]
  ------------------
 1084|  6.13k|            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|  6.13k|        if (t <= 17)                                                                          \
  ------------------
  |  Branch (1085:13): [Folded, False: 6.13k]
  ------------------
 1086|  6.13k|            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|  6.13k|        if (t <= 18)                                                                          \
  ------------------
  |  Branch (1087:13): [Folded, False: 6.13k]
  ------------------
 1088|  6.13k|            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|  6.13k|        if (t <= 19)                                                                          \
  ------------------
  |  Branch (1089:13): [Folded, False: 6.13k]
  ------------------
 1090|  6.13k|            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|  6.13k|        if (t <= 20)                                                                          \
  ------------------
  |  Branch (1091:13): [Folded, False: 6.13k]
  ------------------
 1092|  6.13k|            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|  6.13k|        if (t <= 21)                                                                          \
  ------------------
  |  Branch (1093:13): [Folded, False: 6.13k]
  ------------------
 1094|  6.13k|            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|  6.13k|        if (t <= 22)                                                                          \
  ------------------
  |  Branch (1095:13): [Folded, False: 6.13k]
  ------------------
 1096|  6.13k|            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|  6.13k|        if (t <= 23)                                                                          \
  ------------------
  |  Branch (1097:13): [Folded, False: 6.13k]
  ------------------
 1098|  6.13k|            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|  6.13k|        if (t <= 24)                                                                          \
  ------------------
  |  Branch (1099:13): [Folded, False: 6.13k]
  ------------------
 1100|  6.13k|            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|  6.13k|        if (t <= 25)                                                                          \
  ------------------
  |  Branch (1101:13): [Folded, False: 6.13k]
  ------------------
 1102|  6.13k|            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|  6.13k|        if (t <= 26)                                                                          \
  ------------------
  |  Branch (1103:13): [Folded, False: 6.13k]
  ------------------
 1104|  6.13k|            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|  6.13k|        if (t <= 27)                                                                          \
  ------------------
  |  Branch (1105:13): [Folded, False: 6.13k]
  ------------------
 1106|  6.13k|            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|  6.13k|        if (t <= 28)                                                                          \
  ------------------
  |  Branch (1107:13): [Folded, False: 6.13k]
  ------------------
 1108|  6.13k|            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|  6.13k|        if (t <= 29)                                                                          \
  ------------------
  |  Branch (1109:13): [Folded, False: 6.13k]
  ------------------
 1110|  6.13k|            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|  6.13k|        if (t <= 30)                                                                          \
  ------------------
  |  Branch (1111:13): [Folded, False: 6.13k]
  ------------------
 1112|  6.13k|            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|  6.13k|        if (t <= 31)                                                                          \
  ------------------
  |  Branch (1113:13): [Folded, False: 6.13k]
  ------------------
 1114|  6.13k|            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|  6.13k|        if (t <= 32)                                                                          \
  ------------------
  |  Branch (1115:13): [Folded, False: 6.13k]
  ------------------
 1116|  6.13k|            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|  6.13k|        if (t <= 33)                                                                          \
  ------------------
  |  Branch (1117:13): [Folded, False: 6.13k]
  ------------------
 1118|  6.13k|            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|  6.13k|        if (t <= 34)                                                                          \
  ------------------
  |  Branch (1119:13): [Folded, False: 6.13k]
  ------------------
 1120|  6.13k|            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|  6.13k|        if (t <= 35)                                                                          \
  ------------------
  |  Branch (1121:13): [Folded, False: 6.13k]
  ------------------
 1122|  6.13k|            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|  6.13k|        if (t <= 36)                                                                          \
  ------------------
  |  Branch (1123:13): [Folded, False: 6.13k]
  ------------------
 1124|  6.13k|            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|  6.13k|        if (t <= 37)                                                                          \
  ------------------
  |  Branch (1125:13): [Folded, False: 6.13k]
  ------------------
 1126|  6.13k|            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|  6.13k|        if (t <= 38)                                                                          \
  ------------------
  |  Branch (1127:13): [Folded, False: 6.13k]
  ------------------
 1128|  6.13k|            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|  6.13k|        if (t <= 39)                                                                          \
  ------------------
  |  Branch (1129:13): [Folded, False: 6.13k]
  ------------------
 1130|  6.13k|            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|  6.13k|        if (t <= 40)                                                                          \
  ------------------
  |  Branch (1131:13): [Folded, False: 6.13k]
  ------------------
 1132|  6.13k|            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|  6.13k|        if (t <= 41)                                                                          \
  ------------------
  |  Branch (1133:13): [Folded, False: 6.13k]
  ------------------
 1134|  6.13k|            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|  6.13k|        if (t <= 42)                                                                          \
  ------------------
  |  Branch (1135:13): [Folded, False: 6.13k]
  ------------------
 1136|  6.13k|            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|  6.13k|        if (t <= 43)                                                                          \
  ------------------
  |  Branch (1137:13): [Folded, False: 6.13k]
  ------------------
 1138|  6.13k|            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|  6.13k|        if (t <= 44)                                                                          \
  ------------------
  |  Branch (1139:13): [Folded, False: 6.13k]
  ------------------
 1140|  6.13k|            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|  6.13k|        if (t <= 45)                                                                          \
  ------------------
  |  Branch (1141:13): [Folded, False: 6.13k]
  ------------------
 1142|  6.13k|            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|  6.13k|        if (t <= 46)                                                                          \
  ------------------
  |  Branch (1143:13): [Folded, False: 6.13k]
  ------------------
 1144|  6.13k|            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|  6.13k|        if (t <= 47)                                                                          \
  ------------------
  |  Branch (1145:13): [Folded, False: 6.13k]
  ------------------
 1146|  6.13k|            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|  6.13k|        if (t <= 48)                                                                          \
  ------------------
  |  Branch (1147:13): [Folded, False: 6.13k]
  ------------------
 1148|  6.13k|            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|  6.13k|        if (t <= 49)                                                                          \
  ------------------
  |  Branch (1149:13): [Folded, False: 6.13k]
  ------------------
 1150|  6.13k|            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|  6.13k|        if (t <= 50)                                                                          \
  ------------------
  |  Branch (1151:13): [Folded, False: 6.13k]
  ------------------
 1152|  6.13k|            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|  6.13k|        if (t <= 51)                                                                          \
  ------------------
  |  Branch (1153:13): [Folded, False: 6.13k]
  ------------------
 1154|  6.13k|            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|  6.13k|        if (t <= 52)                                                                          \
  ------------------
  |  Branch (1155:13): [Folded, False: 6.13k]
  ------------------
 1156|  6.13k|            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|  6.13k|        if (t <= 53)                                                                          \
  ------------------
  |  Branch (1157:13): [Folded, False: 6.13k]
  ------------------
 1158|  6.13k|            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|  6.13k|        if (t <= 54)                                                                          \
  ------------------
  |  Branch (1159:13): [Folded, False: 6.13k]
  ------------------
 1160|  6.13k|            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|  6.13k|        if (t <= 55)                                                                          \
  ------------------
  |  Branch (1161:13): [Folded, False: 6.13k]
  ------------------
 1162|  6.13k|            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|  6.13k|        if (t <= 56)                                                                          \
  ------------------
  |  Branch (1163:13): [Folded, False: 6.13k]
  ------------------
 1164|  6.13k|            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|  6.13k|        if (t <= 57)                                                                          \
  ------------------
  |  Branch (1165:13): [Folded, False: 6.13k]
  ------------------
 1166|  6.13k|            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|  6.13k|        if (t <= 58)                                                                          \
  ------------------
  |  Branch (1167:13): [Folded, False: 6.13k]
  ------------------
 1168|  6.13k|            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|  6.13k|        if (t <= 59)                                                                          \
  ------------------
  |  Branch (1169:13): [Folded, False: 6.13k]
  ------------------
 1170|  6.13k|            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|  6.13k|        if (t <= 60)                                                                          \
  ------------------
  |  Branch (1171:13): [Folded, False: 6.13k]
  ------------------
 1172|  6.13k|            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|  6.13k|        if (t <= 61)                                                                          \
  ------------------
  |  Branch (1173:13): [Folded, False: 6.13k]
  ------------------
 1174|  6.13k|            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|  6.13k|        if (t <= 62)                                                                          \
  ------------------
  |  Branch (1175:13): [Folded, False: 6.13k]
  ------------------
 1176|  6.13k|            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|  6.13k|        if (t <= 63)                                                                          \
  ------------------
  |  Branch (1177:13): [Folded, False: 6.13k]
  ------------------
 1178|  6.13k|            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|  6.13k|        if (t <= 64)                                                                          \
  ------------------
  |  Branch (1179:13): [Folded, False: 6.13k]
  ------------------
 1180|  6.13k|            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|  6.13k|        if (t <= 65)                                                                          \
  ------------------
  |  Branch (1181:13): [True: 6.13k, Folded]
  ------------------
 1182|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 65);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1183|  6.13k|        if (t <= 66)                                                                          \
  ------------------
  |  Branch (1183:13): [True: 6.13k, Folded]
  ------------------
 1184|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 66);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1185|  6.13k|        if (t <= 67)                                                                          \
  ------------------
  |  Branch (1185:13): [True: 6.13k, Folded]
  ------------------
 1186|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 67);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1187|  6.13k|        if (t <= 68)                                                                          \
  ------------------
  |  Branch (1187:13): [True: 6.13k, Folded]
  ------------------
 1188|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 68);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1189|  6.13k|        if (t <= 69)                                                                          \
  ------------------
  |  Branch (1189:13): [True: 6.13k, Folded]
  ------------------
 1190|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 69);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1191|  6.13k|        if (t <= 70)                                                                          \
  ------------------
  |  Branch (1191:13): [True: 6.13k, Folded]
  ------------------
 1192|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 70);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1193|  6.13k|        if (t <= 71)                                                                          \
  ------------------
  |  Branch (1193:13): [True: 6.13k, Folded]
  ------------------
 1194|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 71);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1195|  6.13k|        if (t <= 72)                                                                          \
  ------------------
  |  Branch (1195:13): [True: 6.13k, Folded]
  ------------------
 1196|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 72);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1197|  6.13k|        if (t <= 73)                                                                          \
  ------------------
  |  Branch (1197:13): [True: 6.13k, Folded]
  ------------------
 1198|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 73);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1199|  6.13k|        if (t <= 74)                                                                          \
  ------------------
  |  Branch (1199:13): [True: 6.13k, Folded]
  ------------------
 1200|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 74);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1201|  6.13k|        if (t <= 75)                                                                          \
  ------------------
  |  Branch (1201:13): [True: 6.13k, Folded]
  ------------------
 1202|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 75);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1203|  6.13k|        if (t <= 76)                                                                          \
  ------------------
  |  Branch (1203:13): [True: 6.13k, Folded]
  ------------------
 1204|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 76);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1205|  6.13k|        if (t <= 77)                                                                          \
  ------------------
  |  Branch (1205:13): [True: 6.13k, Folded]
  ------------------
 1206|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 77);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1207|  6.13k|        if (t <= 78)                                                                          \
  ------------------
  |  Branch (1207:13): [True: 6.13k, Folded]
  ------------------
 1208|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 78);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1209|  6.13k|        if (t <= 79)                                                                          \
  ------------------
  |  Branch (1209:13): [True: 6.13k, Folded]
  ------------------
 1210|  6.13k|            HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 79);                       \
  ------------------
  |  |  181|  6.13k|    {                                                                  \
  |  |  182|  6.13k|        e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |                       e += rotate_left(a, 5) + sha1_f4(b, c, d) + 0xCA62C1D6 + m[t]; \
  |  |  ------------------
  |  |  |  |  163|  6.13k|#define sha1_f4(b, c, d) ((b) ^ (c) ^ (d))
  |  |  ------------------
  |  |  183|  6.13k|        b = rotate_left(b, 30);                                        \
  |  |  ------------------
  |  |  |  |  135|  6.13k|#define rotate_left(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
  |  |  ------------------
  |  |  184|  6.13k|    }
  ------------------
 1211|  6.13k|        ihvout[0] = ihvin[0] + a;                                                             \
 1212|  6.13k|        ihvout[1] = ihvin[1] + b;                                                             \
 1213|  6.13k|        ihvout[2] = ihvin[2] + c;                                                             \
 1214|  6.13k|        ihvout[3] = ihvin[3] + d;                                                             \
 1215|  6.13k|        ihvout[4] = ihvin[4] + e;                                                             \
 1216|  6.13k|    }

ubc_check:
  571|   138k|{
  572|   138k|    uint32_t mask = ~((uint32_t)(0));
  573|   138k|    mask &= (((((W[44] ^ W[45]) >> 29) & 1) - 1) |
  574|   138k|             ~(DV_I_48_0_bit | DV_I_51_0_bit | DV_I_52_0_bit | DV_II_45_0_bit |
  575|   138k|               DV_II_46_0_bit | DV_II_50_0_bit | DV_II_51_0_bit));
  576|   138k|    mask &= (((((W[49] ^ W[50]) >> 29) & 1) - 1) |
  577|   138k|             ~(DV_I_46_0_bit | DV_II_45_0_bit | DV_II_50_0_bit | DV_II_51_0_bit |
  578|   138k|               DV_II_55_0_bit | DV_II_56_0_bit));
  579|   138k|    mask &= (((((W[48] ^ W[49]) >> 29) & 1) - 1) |
  580|   138k|             ~(DV_I_45_0_bit | DV_I_52_0_bit | DV_II_49_0_bit | DV_II_50_0_bit |
  581|   138k|               DV_II_54_0_bit | DV_II_55_0_bit));
  582|   138k|    mask &= ((((W[47] ^ (W[50] >> 25)) & (1 << 4)) - (1 << 4)) |
  583|   138k|             ~(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit |
  584|   138k|               DV_II_51_0_bit | DV_II_56_0_bit));
  585|   138k|    mask &= (((((W[47] ^ W[48]) >> 29) & 1) - 1) |
  586|   138k|             ~(DV_I_44_0_bit | DV_I_51_0_bit | DV_II_48_0_bit | DV_II_49_0_bit |
  587|   138k|               DV_II_53_0_bit | DV_II_54_0_bit));
  588|   138k|    mask &= (((((W[46] >> 4) ^ (W[49] >> 29)) & 1) - 1) |
  589|   138k|             ~(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|   138k|               DV_II_55_0_bit));
  591|   138k|    mask &= (((((W[46] ^ W[47]) >> 29) & 1) - 1) |
  592|   138k|             ~(DV_I_43_0_bit | DV_I_50_0_bit | DV_II_47_0_bit | DV_II_48_0_bit |
  593|   138k|               DV_II_52_0_bit | DV_II_53_0_bit));
  594|   138k|    mask &= (((((W[45] >> 4) ^ (W[48] >> 29)) & 1) - 1) |
  595|   138k|             ~(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|   138k|               DV_II_54_0_bit));
  597|   138k|    mask &= (((((W[45] ^ W[46]) >> 29) & 1) - 1) |
  598|   138k|             ~(DV_I_49_0_bit | DV_I_52_0_bit | DV_II_46_0_bit | DV_II_47_0_bit |
  599|   138k|               DV_II_51_0_bit | DV_II_52_0_bit));
  600|   138k|    mask &= (((((W[44] >> 4) ^ (W[47] >> 29)) & 1) - 1) |
  601|   138k|             ~(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|   138k|               DV_II_53_0_bit));
  603|   138k|    mask &= (((((W[43] >> 4) ^ (W[46] >> 29)) & 1) - 1) |
  604|   138k|             ~(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|   138k|               DV_II_52_0_bit));
  606|   138k|    mask &= (((((W[43] ^ W[44]) >> 29) & 1) - 1) |
  607|   138k|             ~(DV_I_47_0_bit | DV_I_50_0_bit | DV_I_51_0_bit | DV_II_45_0_bit |
  608|   138k|               DV_II_49_0_bit | DV_II_50_0_bit));
  609|   138k|    mask &= (((((W[42] >> 4) ^ (W[45] >> 29)) & 1) - 1) |
  610|   138k|             ~(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|   138k|               DV_II_51_0_bit));
  612|   138k|    mask &= (((((W[41] >> 4) ^ (W[44] >> 29)) & 1) - 1) |
  613|   138k|             ~(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|   138k|               DV_II_50_0_bit));
  615|   138k|    mask &= (((((W[40] ^ W[41]) >> 29) & 1) - 1) |
  616|   138k|             ~(DV_I_44_0_bit | DV_I_47_0_bit | DV_I_48_0_bit | DV_II_46_0_bit |
  617|   138k|               DV_II_47_0_bit | DV_II_56_0_bit));
  618|   138k|    mask &=
  619|   138k|      (((((W[54] ^ W[55]) >> 29) & 1) - 1) |
  620|   138k|       ~(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|   138k|    mask &=
  622|   138k|      (((((W[53] ^ W[54]) >> 29) & 1) - 1) |
  623|   138k|       ~(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|   138k|    mask &=
  625|   138k|      (((((W[52] ^ W[53]) >> 29) & 1) - 1) |
  626|   138k|       ~(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|   138k|    mask &=
  628|   138k|      ((((W[50] ^ (W[53] >> 25)) & (1 << 4)) - (1 << 4)) |
  629|   138k|       ~(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|   138k|    mask &=
  631|   138k|      (((((W[50] ^ W[51]) >> 29) & 1) - 1) |
  632|   138k|       ~(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|   138k|    mask &=
  634|   138k|      ((((W[49] ^ (W[52] >> 25)) & (1 << 4)) - (1 << 4)) |
  635|   138k|       ~(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|   138k|    mask &=
  637|   138k|      ((((W[48] ^ (W[51] >> 25)) & (1 << 4)) - (1 << 4)) |
  638|   138k|       ~(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|   138k|    mask &=
  640|   138k|      (((((W[42] ^ W[43]) >> 29) & 1) - 1) |
  641|   138k|       ~(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|   138k|    mask &=
  643|   138k|      (((((W[41] ^ W[42]) >> 29) & 1) - 1) |
  644|   138k|       ~(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|   138k|    mask &=
  646|   138k|      (((((W[40] >> 4) ^ (W[43] >> 29)) & 1) - 1) |
  647|   138k|       ~(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|   138k|    mask &=
  649|   138k|      (((((W[39] >> 4) ^ (W[42] >> 29)) & 1) - 1) |
  650|   138k|       ~(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|   138k|    if (mask &
  ------------------
  |  Branch (651:9): [True: 15.0k, False: 123k]
  ------------------
  652|   138k|        (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|  15.0k|        mask &= (((((W[38] >> 4) ^ (W[41] >> 29)) & 1) - 1) |
  654|  15.0k|                 ~(DV_I_44_0_bit | DV_I_48_0_bit | DV_II_47_0_bit | DV_II_54_0_bit |
  655|  15.0k|                   DV_II_56_0_bit));
  656|   138k|    mask &=
  657|   138k|      (((((W[37] >> 4) ^ (W[40] >> 29)) & 1) - 1) |
  658|   138k|       ~(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|   138k|    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: 9.31k, False: 129k]
  ------------------
  660|  9.31k|        mask &= (((((W[55] ^ W[56]) >> 29) & 1) - 1) |
  661|  9.31k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_51_0_bit | DV_II_56_0_bit));
  662|   138k|    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: 9.17k, False: 129k]
  ------------------
  663|  9.17k|        mask &= ((((W[52] ^ (W[55] >> 25)) & (1 << 4)) - (1 << 4)) |
  664|  9.17k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_50_0_bit | DV_II_56_0_bit));
  665|   138k|    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: 6.87k, False: 132k]
  ------------------
  666|  6.87k|        mask &= ((((W[51] ^ (W[54] >> 25)) & (1 << 4)) - (1 << 4)) |
  667|  6.87k|                 ~(DV_I_51_0_bit | DV_II_47_0_bit | DV_II_49_0_bit | DV_II_55_0_bit));
  668|   138k|    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: 9.70k, False: 129k]
  ------------------
  669|  9.70k|        mask &= (((((W[51] ^ W[52]) >> 29) & 1) - 1) |
  670|  9.70k|                 ~(DV_I_48_0_bit | DV_II_47_0_bit | DV_II_52_0_bit | DV_II_53_0_bit));
  671|   138k|    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: 131k]
  ------------------
  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|   138k|    if (mask & (DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit))
  ------------------
  |  Branch (674:9): [True: 4.23k, False: 134k]
  ------------------
  675|  4.23k|        mask &= ((0 - (((W[53] ^ W[56]) >> 29) & 1)) |
  676|  4.23k|                 ~(DV_I_52_0_bit | DV_II_48_0_bit | DV_II_49_0_bit));
  677|   138k|    if (mask & (DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (677:9): [True: 2.48k, False: 136k]
  ------------------
  678|  2.48k|        mask &= ((0 - (((W[51] ^ W[54]) >> 29) & 1)) |
  679|  2.48k|                 ~(DV_I_50_0_bit | DV_II_46_0_bit | DV_II_47_0_bit));
  680|   138k|    if (mask & (DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (680:9): [True: 3.21k, False: 135k]
  ------------------
  681|  3.21k|        mask &= ((0 - (((W[50] ^ W[52]) >> 29) & 1)) |
  682|  3.21k|                 ~(DV_I_49_0_bit | DV_I_51_0_bit | DV_II_45_0_bit));
  683|   138k|    if (mask & (DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit))
  ------------------
  |  Branch (683:9): [True: 1.57k, False: 137k]
  ------------------
  684|  1.57k|        mask &= ((0 - (((W[49] ^ W[51]) >> 29) & 1)) |
  685|  1.57k|                 ~(DV_I_48_0_bit | DV_I_50_0_bit | DV_I_52_0_bit));
  686|   138k|    if (mask & (DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit))
  ------------------
  |  Branch (686:9): [True: 2.09k, False: 136k]
  ------------------
  687|  2.09k|        mask &= ((0 - (((W[48] ^ W[50]) >> 29) & 1)) |
  688|  2.09k|                 ~(DV_I_47_0_bit | DV_I_49_0_bit | DV_I_51_0_bit));
  689|   138k|    if (mask & (DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit))
  ------------------
  |  Branch (689:9): [True: 2.92k, False: 135k]
  ------------------
  690|  2.92k|        mask &= ((0 - (((W[47] ^ W[49]) >> 29) & 1)) |
  691|  2.92k|                 ~(DV_I_46_0_bit | DV_I_48_0_bit | DV_I_50_0_bit));
  692|   138k|    if (mask & (DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit))
  ------------------
  |  Branch (692:9): [True: 6.23k, False: 132k]
  ------------------
  693|  6.23k|        mask &= ((0 - (((W[46] ^ W[48]) >> 29) & 1)) |
  694|  6.23k|                 ~(DV_I_45_0_bit | DV_I_47_0_bit | DV_I_49_0_bit));
  695|   138k|    mask &= ((((W[45] ^ W[47]) & (1 << 6)) - (1 << 6)) |
  696|   138k|             ~(DV_I_47_2_bit | DV_I_49_2_bit | DV_I_51_2_bit));
  697|   138k|    if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit))
  ------------------
  |  Branch (697:9): [True: 5.50k, False: 133k]
  ------------------
  698|  5.50k|        mask &= ((0 - (((W[45] ^ W[47]) >> 29) & 1)) |
  699|  5.50k|                 ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_I_48_0_bit));
  700|   138k|    mask &=
  701|   138k|      (((((W[44] ^ W[46]) >> 6) & 1) - 1) | ~(DV_I_46_2_bit | DV_I_48_2_bit | DV_I_50_2_bit));
  702|   138k|    if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit))
  ------------------
  |  Branch (702:9): [True: 6.71k, False: 132k]
  ------------------
  703|  6.71k|        mask &= ((0 - (((W[44] ^ W[46]) >> 29) & 1)) |
  704|  6.71k|                 ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_I_47_0_bit));
  705|   138k|    mask &= ((0 - ((W[41] ^ (W[42] >> 5)) & (1 << 1))) |
  706|   138k|             ~(DV_I_48_2_bit | DV_II_46_2_bit | DV_II_51_2_bit));
  707|   138k|    mask &= ((0 - ((W[40] ^ (W[41] >> 5)) & (1 << 1))) |
  708|   138k|             ~(DV_I_47_2_bit | DV_I_51_2_bit | DV_II_50_2_bit));
  709|   138k|    if (mask & (DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (709:9): [True: 4.49k, False: 134k]
  ------------------
  710|  4.49k|        mask &= ((0 - (((W[40] ^ W[42]) >> 4) & 1)) |
  711|  4.49k|                 ~(DV_I_44_0_bit | DV_I_46_0_bit | DV_II_56_0_bit));
  712|   138k|    mask &= ((0 - ((W[39] ^ (W[40] >> 5)) & (1 << 1))) |
  713|   138k|             ~(DV_I_46_2_bit | DV_I_50_2_bit | DV_II_49_2_bit));
  714|   138k|    if (mask & (DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit))
  ------------------
  |  Branch (714:9): [True: 5.45k, False: 133k]
  ------------------
  715|  5.45k|        mask &= ((0 - (((W[39] ^ W[41]) >> 4) & 1)) |
  716|  5.45k|                 ~(DV_I_43_0_bit | DV_I_45_0_bit | DV_II_55_0_bit));
  717|   138k|    if (mask & (DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit))
  ------------------
  |  Branch (717:9): [True: 5.79k, False: 133k]
  ------------------
  718|  5.79k|        mask &= ((0 - (((W[38] ^ W[40]) >> 4) & 1)) |
  719|  5.79k|                 ~(DV_I_44_0_bit | DV_II_54_0_bit | DV_II_56_0_bit));
  720|   138k|    if (mask & (DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit))
  ------------------
  |  Branch (720:9): [True: 5.31k, False: 133k]
  ------------------
  721|  5.31k|        mask &= ((0 - (((W[37] ^ W[39]) >> 4) & 1)) |
  722|  5.31k|                 ~(DV_I_43_0_bit | DV_II_53_0_bit | DV_II_55_0_bit));
  723|   138k|    mask &= ((0 - ((W[36] ^ (W[37] >> 5)) & (1 << 1))) |
  724|   138k|             ~(DV_I_47_2_bit | DV_I_50_2_bit | DV_II_46_2_bit));
  725|   138k|    if (mask & (DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (725:9): [True: 1.04k, False: 137k]
  ------------------
  726|  1.04k|        mask &= (((((W[35] >> 4) ^ (W[39] >> 29)) & 1) - 1) |
  727|  1.04k|                 ~(DV_I_45_0_bit | DV_I_48_0_bit | DV_II_47_0_bit));
  728|   138k|    if (mask & (DV_I_48_0_bit | DV_II_48_0_bit))
  ------------------
  |  Branch (728:9): [True: 1.01k, False: 137k]
  ------------------
  729|  1.01k|        mask &=
  730|  1.01k|          ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 0))) | ~(DV_I_48_0_bit | DV_II_48_0_bit));
  731|   138k|    if (mask & (DV_I_45_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (731:9): [True: 1.26k, False: 137k]
  ------------------
  732|  1.26k|        mask &=
  733|  1.26k|          ((0 - ((W[63] ^ (W[64] >> 5)) & (1 << 1))) | ~(DV_I_45_0_bit | DV_II_45_0_bit));
  734|   138k|    if (mask & (DV_I_47_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (734:9): [True: 534, False: 138k]
  ------------------
  735|    534|        mask &=
  736|    534|          ((0 - ((W[62] ^ (W[63] >> 5)) & (1 << 0))) | ~(DV_I_47_0_bit | DV_II_47_0_bit));
  737|   138k|    if (mask & (DV_I_46_0_bit | DV_II_46_0_bit))
  ------------------
  |  Branch (737:9): [True: 843, False: 138k]
  ------------------
  738|    843|        mask &=
  739|    843|          ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 0))) | ~(DV_I_46_0_bit | DV_II_46_0_bit));
  740|   138k|    mask &= ((0 - ((W[61] ^ (W[62] >> 5)) & (1 << 2))) | ~(DV_I_46_2_bit | DV_II_46_2_bit));
  741|   138k|    if (mask & (DV_I_45_0_bit | DV_II_45_0_bit))
  ------------------
  |  Branch (741:9): [True: 676, False: 138k]
  ------------------
  742|    676|        mask &=
  743|    676|          ((0 - ((W[60] ^ (W[61] >> 5)) & (1 << 0))) | ~(DV_I_45_0_bit | DV_II_45_0_bit));
  744|   138k|    if (mask & (DV_II_51_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (744:9): [True: 4.67k, False: 134k]
  ------------------
  745|  4.67k|        mask &= (((((W[58] ^ W[59]) >> 29) & 1) - 1) | ~(DV_II_51_0_bit | DV_II_54_0_bit));
  746|   138k|    if (mask & (DV_II_50_0_bit | DV_II_53_0_bit))
  ------------------
  |  Branch (746:9): [True: 5.20k, False: 133k]
  ------------------
  747|  5.20k|        mask &= (((((W[57] ^ W[58]) >> 29) & 1) - 1) | ~(DV_II_50_0_bit | DV_II_53_0_bit));
  748|   138k|    if (mask & (DV_II_52_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (748:9): [True: 5.28k, False: 133k]
  ------------------
  749|  5.28k|        mask &= ((((W[56] ^ (W[59] >> 25)) & (1 << 4)) - (1 << 4)) |
  750|  5.28k|                 ~(DV_II_52_0_bit | DV_II_54_0_bit));
  751|   138k|    if (mask & (DV_II_51_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (751:9): [True: 4.29k, False: 134k]
  ------------------
  752|  4.29k|        mask &= ((0 - (((W[56] ^ W[59]) >> 29) & 1)) | ~(DV_II_51_0_bit | DV_II_52_0_bit));
  753|   138k|    if (mask & (DV_II_49_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (753:9): [True: 3.04k, False: 135k]
  ------------------
  754|  3.04k|        mask &= (((((W[56] ^ W[57]) >> 29) & 1) - 1) | ~(DV_II_49_0_bit | DV_II_52_0_bit));
  755|   138k|    if (mask & (DV_II_51_0_bit | DV_II_53_0_bit))
  ------------------
  |  Branch (755:9): [True: 2.27k, False: 136k]
  ------------------
  756|  2.27k|        mask &= ((((W[55] ^ (W[58] >> 25)) & (1 << 4)) - (1 << 4)) |
  757|  2.27k|                 ~(DV_II_51_0_bit | DV_II_53_0_bit));
  758|   138k|    if (mask & (DV_II_50_0_bit | DV_II_52_0_bit))
  ------------------
  |  Branch (758:9): [True: 4.91k, False: 134k]
  ------------------
  759|  4.91k|        mask &= ((((W[54] ^ (W[57] >> 25)) & (1 << 4)) - (1 << 4)) |
  760|  4.91k|                 ~(DV_II_50_0_bit | DV_II_52_0_bit));
  761|   138k|    if (mask & (DV_II_49_0_bit | DV_II_51_0_bit))
  ------------------
  |  Branch (761:9): [True: 1.93k, False: 136k]
  ------------------
  762|  1.93k|        mask &= ((((W[53] ^ (W[56] >> 25)) & (1 << 4)) - (1 << 4)) |
  763|  1.93k|                 ~(DV_II_49_0_bit | DV_II_51_0_bit));
  764|   138k|    mask &=
  765|   138k|      ((((W[51] ^ (W[50] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_50_2_bit | DV_II_46_2_bit));
  766|   138k|    mask &= ((((W[48] ^ W[50]) & (1 << 6)) - (1 << 6)) | ~(DV_I_50_2_bit | DV_II_46_2_bit));
  767|   138k|    if (mask & (DV_I_51_0_bit | DV_I_52_0_bit))
  ------------------
  |  Branch (767:9): [True: 682, False: 138k]
  ------------------
  768|    682|        mask &= ((0 - (((W[48] ^ W[55]) >> 29) & 1)) | ~(DV_I_51_0_bit | DV_I_52_0_bit));
  769|   138k|    mask &= ((((W[47] ^ W[49]) & (1 << 6)) - (1 << 6)) | ~(DV_I_49_2_bit | DV_I_51_2_bit));
  770|   138k|    mask &=
  771|   138k|      ((((W[48] ^ (W[47] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_47_2_bit | DV_II_51_2_bit));
  772|   138k|    mask &= ((((W[46] ^ W[48]) & (1 << 6)) - (1 << 6)) | ~(DV_I_48_2_bit | DV_I_50_2_bit));
  773|   138k|    mask &=
  774|   138k|      ((((W[47] ^ (W[46] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_46_2_bit | DV_II_50_2_bit));
  775|   138k|    mask &= ((0 - ((W[44] ^ (W[45] >> 5)) & (1 << 1))) | ~(DV_I_51_2_bit | DV_II_49_2_bit));
  776|   138k|    mask &= ((((W[43] ^ W[45]) & (1 << 6)) - (1 << 6)) | ~(DV_I_47_2_bit | DV_I_49_2_bit));
  777|   138k|    mask &= (((((W[42] ^ W[44]) >> 6) & 1) - 1) | ~(DV_I_46_2_bit | DV_I_48_2_bit));
  778|   138k|    mask &=
  779|   138k|      ((((W[43] ^ (W[42] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_II_46_2_bit | DV_II_51_2_bit));
  780|   138k|    mask &=
  781|   138k|      ((((W[42] ^ (W[41] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_51_2_bit | DV_II_50_2_bit));
  782|   138k|    mask &=
  783|   138k|      ((((W[41] ^ (W[40] >> 5)) & (1 << 1)) - (1 << 1)) | ~(DV_I_50_2_bit | DV_II_49_2_bit));
  784|   138k|    if (mask & (DV_I_52_0_bit | DV_II_51_0_bit))
  ------------------
  |  Branch (784:9): [True: 1.10k, False: 137k]
  ------------------
  785|  1.10k|        mask &= ((((W[39] ^ (W[43] >> 25)) & (1 << 4)) - (1 << 4)) |
  786|  1.10k|                 ~(DV_I_52_0_bit | DV_II_51_0_bit));
  787|   138k|    if (mask & (DV_I_51_0_bit | DV_II_50_0_bit))
  ------------------
  |  Branch (787:9): [True: 3.38k, False: 135k]
  ------------------
  788|  3.38k|        mask &= ((((W[38] ^ (W[42] >> 25)) & (1 << 4)) - (1 << 4)) |
  789|  3.38k|                 ~(DV_I_51_0_bit | DV_II_50_0_bit));
  790|   138k|    if (mask & (DV_I_48_2_bit | DV_I_51_2_bit))
  ------------------
  |  Branch (790:9): [True: 14.1k, False: 124k]
  ------------------
  791|  14.1k|        mask &= ((0 - ((W[37] ^ (W[38] >> 5)) & (1 << 1))) | ~(DV_I_48_2_bit | DV_I_51_2_bit));
  792|   138k|    if (mask & (DV_I_50_0_bit | DV_II_49_0_bit))
  ------------------
  |  Branch (792:9): [True: 1.08k, False: 137k]
  ------------------
  793|  1.08k|        mask &= ((((W[37] ^ (W[41] >> 25)) & (1 << 4)) - (1 << 4)) |
  794|  1.08k|                 ~(DV_I_50_0_bit | DV_II_49_0_bit));
  795|   138k|    if (mask & (DV_II_52_0_bit | DV_II_54_0_bit))
  ------------------
  |  Branch (795:9): [True: 2.56k, False: 136k]
  ------------------
  796|  2.56k|        mask &= ((0 - ((W[36] ^ W[38]) & (1 << 4))) | ~(DV_II_52_0_bit | DV_II_54_0_bit));
  797|   138k|    mask &= ((0 - ((W[35] ^ (W[36] >> 5)) & (1 << 1))) | ~(DV_I_46_2_bit | DV_I_49_2_bit));
  798|   138k|    if (mask & (DV_I_51_0_bit | DV_II_47_0_bit))
  ------------------
  |  Branch (798:9): [True: 401, False: 138k]
  ------------------
  799|    401|        mask &= ((((W[35] ^ (W[39] >> 25)) & (1 << 3)) - (1 << 3)) |
  800|    401|                 ~(DV_I_51_0_bit | DV_II_47_0_bit));
  801|   138k|    if (mask) {
  ------------------
  |  Branch (801:9): [True: 70.8k, False: 68.1k]
  ------------------
  802|  70.8k|        if (mask & DV_I_43_0_bit)
  ------------------
  |  Branch (802:13): [True: 1.24k, False: 69.5k]
  ------------------
  803|  1.24k|            if (!((W[61] ^ (W[62] >> 5)) & (1 << 1)) ||
  ------------------
  |  Branch (803:17): [True: 358, False: 883]
  ------------------
  804|    883|                !(!((W[59] ^ (W[63] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (804:17): [True: 272, False: 611]
  ------------------
  805|    611|                !((W[58] ^ (W[63] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (805:17): [True: 343, False: 268]
  ------------------
  806|    973|                mask &= ~DV_I_43_0_bit;
  807|  70.8k|        if (mask & DV_I_44_0_bit)
  ------------------
  |  Branch (807:13): [True: 1.54k, False: 69.2k]
  ------------------
  808|  1.54k|            if (!((W[62] ^ (W[63] >> 5)) & (1 << 1)) ||
  ------------------
  |  Branch (808:17): [True: 462, False: 1.07k]
  ------------------
  809|  1.07k|                !(!((W[60] ^ (W[64] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (809:17): [True: 467, False: 612]
  ------------------
  810|    612|                !((W[59] ^ (W[64] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (810:17): [True: 257, False: 355]
  ------------------
  811|  1.18k|                mask &= ~DV_I_44_0_bit;
  812|  70.8k|        if (mask & DV_I_46_2_bit)
  ------------------
  |  Branch (812:13): [True: 4.22k, False: 66.5k]
  ------------------
  813|  4.22k|            mask &= ((~((W[40] ^ W[42]) >> 2)) | ~DV_I_46_2_bit);
  814|  70.8k|        if (mask & DV_I_47_2_bit)
  ------------------
  |  Branch (814:13): [True: 6.95k, False: 63.8k]
  ------------------
  815|  6.95k|            if (!((W[62] ^ (W[63] >> 5)) & (1 << 2)) || !(!((W[41] ^ W[43]) & (1 << 6))))
  ------------------
  |  Branch (815:17): [True: 2.08k, False: 4.86k]
  |  Branch (815:57): [True: 2.93k, False: 1.93k]
  ------------------
  816|  5.02k|                mask &= ~DV_I_47_2_bit;
  817|  70.8k|        if (mask & DV_I_48_2_bit)
  ------------------
  |  Branch (817:13): [True: 5.60k, False: 65.2k]
  ------------------
  818|  5.60k|            if (!((W[63] ^ (W[64] >> 5)) & (1 << 2)) ||
  ------------------
  |  Branch (818:17): [True: 2.46k, False: 3.13k]
  ------------------
  819|  3.13k|                !(!((W[48] ^ (W[49] << 5)) & (1 << 6))))
  ------------------
  |  Branch (819:17): [True: 1.99k, False: 1.14k]
  ------------------
  820|  4.45k|                mask &= ~DV_I_48_2_bit;
  821|  70.8k|        if (mask & DV_I_49_2_bit)
  ------------------
  |  Branch (821:13): [True: 12.7k, False: 58.0k]
  ------------------
  822|  12.7k|            if (!(!((W[49] ^ (W[50] << 5)) & (1 << 6))) || !((W[42] ^ W[50]) & (1 << 1)) ||
  ------------------
  |  Branch (822:17): [True: 3.38k, False: 9.35k]
  |  Branch (822:60): [True: 5.14k, False: 4.21k]
  ------------------
  823|  4.21k|                !(!((W[39] ^ (W[40] << 5)) & (1 << 6))) || !((W[38] ^ W[40]) & (1 << 1)))
  ------------------
  |  Branch (823:17): [True: 2.37k, False: 1.84k]
  |  Branch (823:60): [True: 599, False: 1.24k]
  ------------------
  824|  11.4k|                mask &= ~DV_I_49_2_bit;
  825|  70.8k|        if (mask & DV_I_50_0_bit)
  ------------------
  |  Branch (825:13): [True: 270, False: 70.5k]
  ------------------
  826|    270|            mask &= ((((W[36] ^ W[37]) << 7)) | ~DV_I_50_0_bit);
  827|  70.8k|        if (mask & DV_I_50_2_bit)
  ------------------
  |  Branch (827:13): [True: 2.33k, False: 68.4k]
  ------------------
  828|  2.33k|            mask &= ((((W[43] ^ W[51]) << 11)) | ~DV_I_50_2_bit);
  829|  70.8k|        if (mask & DV_I_51_0_bit)
  ------------------
  |  Branch (829:13): [True: 224, False: 70.5k]
  ------------------
  830|    224|            mask &= ((((W[37] ^ W[38]) << 9)) | ~DV_I_51_0_bit);
  831|  70.8k|        if (mask & DV_I_51_2_bit)
  ------------------
  |  Branch (831:13): [True: 3.46k, False: 67.3k]
  ------------------
  832|  3.46k|            if (!(!((W[51] ^ (W[52] << 5)) & (1 << 6))) || !(!((W[49] ^ W[51]) & (1 << 6))) ||
  ------------------
  |  Branch (832:17): [True: 936, False: 2.52k]
  |  Branch (832:60): [True: 454, False: 2.07k]
  ------------------
  833|  2.07k|                !(!((W[37] ^ (W[37] >> 5)) & (1 << 1))) ||
  ------------------
  |  Branch (833:17): [True: 858, False: 1.21k]
  ------------------
  834|  1.21k|                !(!((W[35] ^ (W[39] >> 25)) & (1 << 5))))
  ------------------
  |  Branch (834:17): [True: 740, False: 476]
  ------------------
  835|  2.98k|                mask &= ~DV_I_51_2_bit;
  836|  70.8k|        if (mask & DV_I_52_0_bit)
  ------------------
  |  Branch (836:13): [True: 220, False: 70.5k]
  ------------------
  837|    220|            mask &= ((((W[38] ^ W[39]) << 11)) | ~DV_I_52_0_bit);
  838|  70.8k|        if (mask & DV_II_46_2_bit)
  ------------------
  |  Branch (838:13): [True: 3.59k, False: 67.2k]
  ------------------
  839|  3.59k|            mask &= ((((W[47] ^ W[51]) << 17)) | ~DV_II_46_2_bit);
  840|  70.8k|        if (mask & DV_II_48_0_bit)
  ------------------
  |  Branch (840:13): [True: 796, False: 70.0k]
  ------------------
  841|    796|            if (!(!((W[36] ^ (W[40] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (841:17): [True: 354, False: 442]
  ------------------
  842|    442|                !((W[35] ^ (W[40] << 2)) & (1 << 30)))
  ------------------
  |  Branch (842:17): [True: 222, False: 220]
  ------------------
  843|    576|                mask &= ~DV_II_48_0_bit;
  844|  70.8k|        if (mask & DV_II_49_0_bit)
  ------------------
  |  Branch (844:13): [True: 784, False: 70.0k]
  ------------------
  845|    784|            if (!(!((W[37] ^ (W[41] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (845:17): [True: 250, False: 534]
  ------------------
  846|    534|                !((W[36] ^ (W[41] << 2)) & (1 << 30)))
  ------------------
  |  Branch (846:17): [True: 220, False: 314]
  ------------------
  847|    470|                mask &= ~DV_II_49_0_bit;
  848|  70.8k|        if (mask & DV_II_49_2_bit)
  ------------------
  |  Branch (848:13): [True: 19.6k, False: 51.1k]
  ------------------
  849|  19.6k|            if (!(!((W[53] ^ (W[54] << 5)) & (1 << 6))) || !(!((W[51] ^ W[53]) & (1 << 6))) ||
  ------------------
  |  Branch (849:17): [True: 7.34k, False: 12.3k]
  |  Branch (849:60): [True: 5.00k, False: 7.32k]
  ------------------
  850|  7.32k|                !((W[50] ^ W[54]) & (1 << 1)) || !(!((W[45] ^ (W[46] << 5)) & (1 << 6))) ||
  ------------------
  |  Branch (850:17): [True: 3.06k, False: 4.26k]
  |  Branch (850:50): [True: 1.21k, False: 3.05k]
  ------------------
  851|  3.05k|                !(!((W[37] ^ (W[41] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (851:17): [True: 1.72k, False: 1.33k]
  ------------------
  852|  1.33k|                !((W[36] ^ (W[41] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (852:17): [True: 324, False: 1.00k]
  ------------------
  853|  18.6k|                mask &= ~DV_II_49_2_bit;
  854|  70.8k|        if (mask & DV_II_50_0_bit)
  ------------------
  |  Branch (854:13): [True: 3.06k, False: 67.7k]
  ------------------
  855|  3.06k|            if (!((W[55] ^ W[58]) & (1 << 29)) || !(!((W[38] ^ (W[42] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (855:17): [True: 1.13k, False: 1.92k]
  |  Branch (855:51): [True: 407, False: 1.51k]
  ------------------
  856|  1.51k|                !((W[37] ^ (W[42] << 2)) & (1 << 30)))
  ------------------
  |  Branch (856:17): [True: 215, False: 1.30k]
  ------------------
  857|  1.75k|                mask &= ~DV_II_50_0_bit;
  858|  70.8k|        if (mask & DV_II_50_2_bit)
  ------------------
  |  Branch (858:13): [True: 21.1k, False: 49.6k]
  ------------------
  859|  21.1k|            if (!(!((W[54] ^ (W[55] << 5)) & (1 << 6))) || !(!((W[52] ^ W[54]) & (1 << 6))) ||
  ------------------
  |  Branch (859:17): [True: 9.69k, False: 11.4k]
  |  Branch (859:60): [True: 3.55k, False: 7.87k]
  ------------------
  860|  7.87k|                !((W[51] ^ W[55]) & (1 << 1)) || !((W[45] ^ W[47]) & (1 << 1)) ||
  ------------------
  |  Branch (860:17): [True: 2.67k, False: 5.19k]
  |  Branch (860:50): [True: 2.07k, False: 3.11k]
  ------------------
  861|  3.11k|                !(!((W[38] ^ (W[42] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (861:17): [True: 2.24k, False: 870]
  ------------------
  862|    870|                !((W[37] ^ (W[42] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (862:17): [True: 365, False: 505]
  ------------------
  863|  20.6k|                mask &= ~DV_II_50_2_bit;
  864|  70.8k|        if (mask & DV_II_51_0_bit)
  ------------------
  |  Branch (864:13): [True: 789, False: 70.0k]
  ------------------
  865|    789|            if (!(!((W[39] ^ (W[43] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (865:17): [True: 308, False: 481]
  ------------------
  866|    481|                !((W[38] ^ (W[43] << 2)) & (1 << 30)))
  ------------------
  |  Branch (866:17): [True: 242, False: 239]
  ------------------
  867|    550|                mask &= ~DV_II_51_0_bit;
  868|  70.8k|        if (mask & DV_II_51_2_bit)
  ------------------
  |  Branch (868:13): [True: 18.1k, False: 52.6k]
  ------------------
  869|  18.1k|            if (!(!((W[55] ^ (W[56] << 5)) & (1 << 6))) || !(!((W[53] ^ W[55]) & (1 << 6))) ||
  ------------------
  |  Branch (869:17): [True: 7.82k, False: 10.3k]
  |  Branch (869:60): [True: 5.39k, False: 4.95k]
  ------------------
  870|  4.95k|                !((W[52] ^ W[56]) & (1 << 1)) || !((W[46] ^ W[48]) & (1 << 1)) ||
  ------------------
  |  Branch (870:17): [True: 2.31k, False: 2.63k]
  |  Branch (870:50): [True: 1.01k, False: 1.61k]
  ------------------
  871|  1.61k|                !(!((W[39] ^ (W[43] >> 25)) & (1 << 5))) ||
  ------------------
  |  Branch (871:17): [True: 701, False: 917]
  ------------------
  872|    917|                !((W[38] ^ (W[43] >> 30)) & (1 << 0)))
  ------------------
  |  Branch (872:17): [True: 283, False: 634]
  ------------------
  873|  17.5k|                mask &= ~DV_II_51_2_bit;
  874|  70.8k|        if (mask & DV_II_52_0_bit)
  ------------------
  |  Branch (874:13): [True: 1.25k, False: 69.5k]
  ------------------
  875|  1.25k|            if (!(!((W[59] ^ W[60]) & (1 << 29))) ||
  ------------------
  |  Branch (875:17): [True: 334, False: 924]
  ------------------
  876|    924|                !(!((W[40] ^ (W[44] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (876:17): [True: 220, False: 704]
  ------------------
  877|    704|                !(!((W[40] ^ (W[44] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (877:17): [True: 242, False: 462]
  ------------------
  878|    462|                !((W[39] ^ (W[44] << 2)) & (1 << 30)))
  ------------------
  |  Branch (878:17): [True: 226, False: 236]
  ------------------
  879|  1.02k|                mask &= ~DV_II_52_0_bit;
  880|  70.8k|        if (mask & DV_II_53_0_bit)
  ------------------
  |  Branch (880:13): [True: 1.19k, False: 69.6k]
  ------------------
  881|  1.19k|            if (!((W[58] ^ W[61]) & (1 << 29)) || !(!((W[57] ^ (W[61] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (881:17): [True: 246, False: 946]
  |  Branch (881:51): [True: 220, False: 726]
  ------------------
  882|    726|                !(!((W[41] ^ (W[45] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (882:17): [True: 220, False: 506]
  ------------------
  883|    506|                !(!((W[41] ^ (W[45] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (883:17): [True: 222, False: 284]
  ------------------
  884|    908|                mask &= ~DV_II_53_0_bit;
  885|  70.8k|        if (mask & DV_II_54_0_bit)
  ------------------
  |  Branch (885:13): [True: 908, False: 69.9k]
  ------------------
  886|    908|            if (!(!((W[58] ^ (W[62] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (886:17): [True: 230, False: 678]
  ------------------
  887|    678|                !(!((W[42] ^ (W[46] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (887:17): [True: 244, False: 434]
  ------------------
  888|    434|                !(!((W[42] ^ (W[46] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (888:17): [True: 218, False: 216]
  ------------------
  889|    692|                mask &= ~DV_II_54_0_bit;
  890|  70.8k|        if (mask & DV_II_55_0_bit)
  ------------------
  |  Branch (890:13): [True: 1.37k, False: 69.4k]
  ------------------
  891|  1.37k|            if (!(!((W[59] ^ (W[63] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (891:17): [True: 278, False: 1.09k]
  ------------------
  892|  1.09k|                !(!((W[57] ^ (W[59] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (892:17): [True: 242, False: 856]
  ------------------
  893|    856|                !(!((W[43] ^ (W[47] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (893:17): [True: 226, False: 630]
  ------------------
  894|    630|                !(!((W[43] ^ (W[47] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (894:17): [True: 284, False: 346]
  ------------------
  895|  1.03k|                mask &= ~DV_II_55_0_bit;
  896|  70.8k|        if (mask & DV_II_56_0_bit)
  ------------------
  |  Branch (896:13): [True: 951, False: 69.8k]
  ------------------
  897|    951|            if (!(!((W[60] ^ (W[64] >> 25)) & (1 << 4))) ||
  ------------------
  |  Branch (897:17): [True: 252, False: 699]
  ------------------
  898|    699|                !(!((W[44] ^ (W[48] >> 25)) & (1 << 3))) ||
  ------------------
  |  Branch (898:17): [True: 244, False: 455]
  ------------------
  899|    455|                !(!((W[44] ^ (W[48] >> 25)) & (1 << 4))))
  ------------------
  |  Branch (899:17): [True: 220, False: 235]
  ------------------
  900|    716|                mask &= ~DV_II_56_0_bit;
  901|  70.8k|    }
  902|       |
  903|   138k|    dvmask[0] = mask;
  904|   138k|}

_ZN28pgp_sphincsplus_public_key_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE23sphincsplus_parameter_t16pgp_pubkey_alg_t:
  118|  1.94k|    : key_encoded_(key_encoded), pk_alg_(alg), sphincsplus_param_(param),
  119|  1.94k|      sphincsplus_hash_func_(rnp_sphincsplus_alg_to_hashfunc(alg)), is_initialized_(true)
  120|  1.94k|{
  121|  1.94k|}
_Z23sphincsplus_pubkey_size23sphincsplus_parameter_t:
  289|  2.39k|{
  290|  2.39k|    switch (param) {
  291|     67|    case sphincsplus_simple_128s:
  ------------------
  |  Branch (291:5): [True: 67, False: 2.33k]
  ------------------
  292|     67|        return 32;
  293|    891|    case sphincsplus_simple_128f:
  ------------------
  |  Branch (293:5): [True: 891, False: 1.50k]
  ------------------
  294|    891|        return 32;
  295|     10|    case sphincsplus_simple_192s:
  ------------------
  |  Branch (295:5): [True: 10, False: 2.38k]
  ------------------
  296|     10|        return 48;
  297|    261|    case sphincsplus_simple_192f:
  ------------------
  |  Branch (297:5): [True: 261, False: 2.13k]
  ------------------
  298|    261|        return 48;
  299|     29|    case sphincsplus_simple_256s:
  ------------------
  |  Branch (299:5): [True: 29, False: 2.37k]
  ------------------
  300|     29|        return 64;
  301|    901|    case sphincsplus_simple_256f:
  ------------------
  |  Branch (301:5): [True: 901, False: 1.49k]
  ------------------
  302|    901|        return 64;
  303|    240|    default:
  ------------------
  |  Branch (303:5): [True: 240, False: 2.15k]
  ------------------
  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.39k|    }
  307|  2.39k|}
_Z26sphincsplus_signature_size23sphincsplus_parameter_t:
  311|    779|{
  312|    779|    switch (param) {
  313|      4|    case sphincsplus_simple_128s:
  ------------------
  |  Branch (313:5): [True: 4, False: 775]
  ------------------
  314|      4|        return 7856;
  315|      5|    case sphincsplus_simple_128f:
  ------------------
  |  Branch (315:5): [True: 5, False: 774]
  ------------------
  316|      5|        return 17088;
  317|     78|    case sphincsplus_simple_192s:
  ------------------
  |  Branch (317:5): [True: 78, False: 701]
  ------------------
  318|     78|        return 16224;
  319|      2|    case sphincsplus_simple_192f:
  ------------------
  |  Branch (319:5): [True: 2, False: 777]
  ------------------
  320|      2|        return 35664;
  321|    370|    case sphincsplus_simple_256s:
  ------------------
  |  Branch (321:5): [True: 370, False: 409]
  ------------------
  322|    370|        return 29792;
  323|      0|    case sphincsplus_simple_256f:
  ------------------
  |  Branch (323:5): [True: 0, False: 779]
  ------------------
  324|      0|        return 49856;
  325|    320|    default:
  ------------------
  |  Branch (325:5): [True: 320, False: 459]
  ------------------
  326|    320|        RNP_LOG("invalid SLH-DSA parameter identifier");
  ------------------
  |  |   76|    320|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    320|    do {                                                                                 \
  |  |  |  |   69|    320|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 320, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    320|            break;                                                                       \
  |  |  |  |   71|    320|        (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|    320|        return 0;
  328|    779|    }
  329|    779|}
sphincsplus.cpp:_ZN12_GLOBAL__N_131rnp_sphincsplus_alg_to_hashfuncE16pgp_pubkey_alg_t:
   70|  1.94k|{
   71|  1.94k|    switch (alg) {
   72|    590|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (72:5): [True: 590, False: 1.35k]
  ------------------
   73|    590|        return sphincsplus_sha256;
   74|  1.35k|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (74:5): [True: 1.35k, False: 590]
  ------------------
   75|  1.35k|        return sphinscplus_shake256;
   76|      0|    default:
  ------------------
  |  Branch (76:5): [True: 0, False: 1.94k]
  ------------------
   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.94k|    }
   80|  1.94k|}

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

_Z14pgp_block_size14pgp_symm_alg_t:
  210|  26.1k|{
  211|  26.1k|    switch (alg) {
  212|  4.51k|    case PGP_SA_IDEA:
  ------------------
  |  Branch (212:5): [True: 4.51k, False: 21.6k]
  ------------------
  213|  7.66k|    case PGP_SA_TRIPLEDES:
  ------------------
  |  Branch (213:5): [True: 3.14k, False: 22.9k]
  ------------------
  214|  12.3k|    case PGP_SA_CAST5:
  ------------------
  |  Branch (214:5): [True: 4.64k, False: 21.4k]
  ------------------
  215|  15.9k|    case PGP_SA_BLOWFISH:
  ------------------
  |  Branch (215:5): [True: 3.67k, False: 22.4k]
  ------------------
  216|  15.9k|        return 8;
  217|    286|    case PGP_SA_AES_128:
  ------------------
  |  Branch (217:5): [True: 286, False: 25.8k]
  ------------------
  218|    710|    case PGP_SA_AES_192:
  ------------------
  |  Branch (218:5): [True: 424, False: 25.6k]
  ------------------
  219|  1.07k|    case PGP_SA_AES_256:
  ------------------
  |  Branch (219:5): [True: 362, False: 25.7k]
  ------------------
  220|  2.00k|    case PGP_SA_TWOFISH:
  ------------------
  |  Branch (220:5): [True: 937, False: 25.1k]
  ------------------
  221|  4.75k|    case PGP_SA_CAMELLIA_128:
  ------------------
  |  Branch (221:5): [True: 2.74k, False: 23.3k]
  ------------------
  222|  6.76k|    case PGP_SA_CAMELLIA_192:
  ------------------
  |  Branch (222:5): [True: 2.00k, False: 24.1k]
  ------------------
  223|  7.52k|    case PGP_SA_CAMELLIA_256:
  ------------------
  |  Branch (223:5): [True: 760, False: 25.3k]
  ------------------
  224|  8.75k|    case PGP_SA_SM4:
  ------------------
  |  Branch (224:5): [True: 1.23k, False: 24.8k]
  ------------------
  225|  8.75k|        return 16;
  226|  1.38k|    default:
  ------------------
  |  Branch (226:5): [True: 1.38k, False: 24.7k]
  ------------------
  227|  1.38k|        return 0;
  228|  26.1k|    }
  229|  26.1k|}
_Z25pgp_cipher_aead_nonce_len14pgp_aead_alg_t:
  317|  2.53k|{
  318|  2.53k|    switch (aalg) {
  319|  1.25k|    case PGP_AEAD_EAX:
  ------------------
  |  Branch (319:5): [True: 1.25k, False: 1.27k]
  ------------------
  320|  1.25k|        return PGP_AEAD_EAX_NONCE_LEN;
  ------------------
  |  |   64|  1.25k|#define PGP_AEAD_EAX_NONCE_LEN 16
  ------------------
  321|    853|    case PGP_AEAD_OCB:
  ------------------
  |  Branch (321:5): [True: 853, False: 1.68k]
  ------------------
  322|    853|        return PGP_AEAD_OCB_NONCE_LEN;
  ------------------
  |  |   67|    853|#define PGP_AEAD_OCB_NONCE_LEN 15
  ------------------
  323|    424|    default:
  ------------------
  |  Branch (323:5): [True: 424, False: 2.10k]
  ------------------
  324|    424|        return 0;
  325|  2.53k|    }
  326|  2.53k|}
_Z23pgp_cipher_aead_tag_len14pgp_aead_alg_t:
  330|  1.95k|{
  331|  1.95k|    switch (aalg) {
  332|  1.17k|    case PGP_AEAD_EAX:
  ------------------
  |  Branch (332:5): [True: 1.17k, False: 779]
  ------------------
  333|  1.95k|    case PGP_AEAD_OCB:
  ------------------
  |  Branch (333:5): [True: 779, False: 1.17k]
  ------------------
  334|  1.95k|        return PGP_AEAD_EAX_OCB_TAG_LEN;
  ------------------
  |  |   79|  1.95k|#define PGP_AEAD_EAX_OCB_TAG_LEN 16
  ------------------
  335|      0|    default:
  ------------------
  |  Branch (335:5): [True: 0, False: 1.95k]
  ------------------
  336|      0|        return 0;
  337|  1.95k|    }
  338|  1.95k|}

_ZN3pgp11EncMaterial6createE16pgp_pubkey_alg_t:
   35|  18.6k|{
   36|  18.6k|    switch (alg) {
   37|  5.97k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (37:5): [True: 5.97k, False: 12.6k]
  ------------------
   38|  7.39k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (38:5): [True: 1.41k, False: 17.2k]
  ------------------
   39|  7.39k|        return std::unique_ptr<EncMaterial>(new RSAEncMaterial());
   40|  1.06k|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (40:5): [True: 1.06k, False: 17.5k]
  ------------------
   41|  2.39k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (41:5): [True: 1.33k, False: 17.3k]
  ------------------
   42|  2.39k|        return std::unique_ptr<EncMaterial>(new EGEncMaterial());
   43|  1.04k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (43:5): [True: 1.04k, False: 17.5k]
  ------------------
   44|  1.04k|        return std::unique_ptr<EncMaterial>(new SM2EncMaterial());
   45|  2.33k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (45:5): [True: 2.33k, False: 16.2k]
  ------------------
   46|  2.33k|        return std::unique_ptr<EncMaterial>(new ECDHEncMaterial());
   47|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   48|  2.66k|    case PGP_PKA_X25519:
  ------------------
  |  Branch (48:5): [True: 2.66k, False: 15.9k]
  ------------------
   49|  2.66k|        return std::unique_ptr<EncMaterial>(new X25519EncMaterial());
   50|      0|#endif
   51|      0|#if defined(ENABLE_PQC)
   52|    252|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (52:5): [True: 252, False: 18.3k]
  ------------------
   53|    252|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    252|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   54|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448 with FALLTHROUGH_STATEMENT;
   55|    769|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (55:5): [True: 517, False: 18.1k]
  ------------------
   56|    769|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    769|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   57|  1.56k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (57:5): [True: 794, False: 17.8k]
  ------------------
   58|  1.56k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.56k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   59|  1.98k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (59:5): [True: 418, False: 18.2k]
  ------------------
   60|  1.98k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.98k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   61|  2.33k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (61:5): [True: 352, False: 18.2k]
  ------------------
   62|  2.33k|        return std::unique_ptr<EncMaterial>(new MlkemEcdhEncMaterial(alg));
   63|      0|#endif
   64|    468|    default:
  ------------------
  |  Branch (64:5): [True: 468, False: 18.1k]
  ------------------
   65|    468|        RNP_LOG("unknown pk alg %d", alg);
  ------------------
  |  |   76|    468|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    468|    do {                                                                                 \
  |  |  |  |   69|    468|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 468, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    468|            break;                                                                       \
  |  |  |  |   71|    468|        (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|    468|        return nullptr;
   67|  18.6k|    }
   68|  18.6k|}
_ZN3pgp14RSAEncMaterial5parseER17pgp_packet_body_t:
   72|  7.39k|{
   73|  7.39k|    return pkt.get(enc.m);
   74|  7.39k|}
_ZN3pgp13EGEncMaterial5parseER17pgp_packet_body_t:
   84|  2.39k|{
   85|  2.39k|    return pkt.get(enc.g) && pkt.get(enc.m);
  ------------------
  |  Branch (85:12): [True: 1.99k, False: 404]
  |  Branch (85:30): [True: 1.85k, False: 142]
  ------------------
   86|  2.39k|}
_ZN3pgp14SM2EncMaterial5parseER17pgp_packet_body_t:
   97|  1.04k|{
   98|  1.04k|    return pkt.get(enc.m);
   99|  1.04k|}
_ZN3pgp15ECDHEncMaterial5parseER17pgp_packet_body_t:
  109|  2.33k|{
  110|  2.33k|    uint8_t sz = 0;
  111|       |    /* ECDH ephemeral point and m size */
  112|  2.33k|    if (!pkt.get(enc.p) || !pkt.get(sz)) {
  ------------------
  |  Branch (112:9): [True: 354, False: 1.98k]
  |  Branch (112:28): [True: 201, False: 1.78k]
  ------------------
  113|    555|        return false;
  114|    555|    }
  115|       |    /* ECDH m */
  116|  1.78k|    if (sz > ECDH_WRAPPED_KEY_SIZE) {
  ------------------
  |  |   38|  1.78k|#define ECDH_WRAPPED_KEY_SIZE 48
  ------------------
  |  Branch (116:9): [True: 214, False: 1.56k]
  ------------------
  117|    214|        RNP_LOG("wrong ecdh m len");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|    214|        return false;
  119|    214|    }
  120|  1.56k|    enc.m.resize(sz);
  121|  1.56k|    if (!pkt.get(enc.m.data(), sz)) {
  ------------------
  |  Branch (121:9): [True: 228, False: 1.34k]
  ------------------
  122|    228|        return false;
  123|    228|    }
  124|  1.34k|    return true;
  125|  1.56k|}
_ZN3pgp17X25519EncMaterial5parseER17pgp_packet_body_t:
  138|  2.66k|{
  139|  2.66k|    enc.eph_key.resize(32);
  140|  2.66k|    if (!pkt.get(enc.eph_key.data(), enc.eph_key.size())) {
  ------------------
  |  Branch (140:9): [True: 344, False: 2.32k]
  ------------------
  141|    344|        RNP_LOG("failed to parse X25519 PKESK (eph. pubkey)");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  142|    344|        return false;
  143|    344|    }
  144|  2.32k|    uint8_t sess_len = 0;
  145|  2.32k|    if (!pkt.get(sess_len) || !sess_len) {
  ------------------
  |  Branch (145:9): [True: 201, False: 2.12k]
  |  Branch (145:31): [True: 196, False: 1.92k]
  ------------------
  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.92k|    if (version == PGP_PKSK_V3) {
  ------------------
  |  Branch (150:9): [True: 1.71k, False: 213]
  ------------------
  151|  1.71k|        uint8_t bt = 0;
  152|  1.71k|        if (!pkt.get(bt)) {
  ------------------
  |  Branch (152:13): [True: 198, False: 1.51k]
  ------------------
  153|    198|            RNP_LOG("failed to get salg");
  ------------------
  |  |   76|    198|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    198|    do {                                                                                 \
  |  |  |  |   69|    198|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 198, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    198|            break;                                                                       \
  |  |  |  |   71|    198|        (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|    198|            return RNP_ERROR_BAD_FORMAT;
  155|    198|        }
  156|  1.51k|        sess_len--;
  157|  1.51k|        salg = (pgp_symm_alg_t) bt;
  158|  1.51k|    }
  159|  1.72k|    enc.enc_sess_key.resize(sess_len);
  160|  1.72k|    if (!pkt.get(enc.enc_sess_key.data(), sess_len)) {
  ------------------
  |  Branch (160:9): [True: 228, False: 1.50k]
  ------------------
  161|    228|        RNP_LOG("failed to parse X25519 PKESK (enc sesskey)");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  162|    228|        return false;
  163|    228|    }
  164|  1.50k|    return true;
  165|  1.72k|}
_ZN3pgp20MlkemEcdhEncMaterial5parseER17pgp_packet_body_t:
  183|  2.33k|{
  184|       |    /* Calculate ciphertext size */
  185|  2.33k|    auto csize =
  186|  2.33k|      kyber_ciphertext_size(pgp_kyber_ecdh_composite_key_t::pk_alg_to_kyber_id(alg_)) +
  187|  2.33k|      pgp_kyber_ecdh_composite_key_t::ecdh_curve_ephemeral_size(
  188|  2.33k|        pgp_kyber_ecdh_composite_key_t::pk_alg_to_curve_id(alg_));
  189|  2.33k|    enc.composite_ciphertext.resize(csize);
  190|       |    /* Read composite ciphertext */
  191|  2.33k|    if (!pkt.get(enc.composite_ciphertext.data(), enc.composite_ciphertext.size())) {
  ------------------
  |  Branch (191:9): [True: 1.03k, False: 1.29k]
  ------------------
  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.29k|    uint8_t wrapped_key_len = 0;
  196|  1.29k|    if (!pkt.get(wrapped_key_len) || !wrapped_key_len) {
  ------------------
  |  Branch (196:9): [True: 2, False: 1.29k]
  |  Branch (196:38): [True: 198, False: 1.09k]
  ------------------
  197|    200|        RNP_LOG("failed to get kyber-ecdh wrapped session key length");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  198|    200|        return false;
  199|    200|    }
  200|       |    /* get plaintext salg if PKESKv3 */
  201|  1.09k|    if (version == PGP_PKSK_V3) {
  ------------------
  |  Branch (201:9): [True: 382, False: 716]
  ------------------
  202|    382|        uint8_t balg = 0;
  203|    382|        if (!pkt.get(balg)) {
  ------------------
  |  Branch (203:13): [True: 4, False: 378]
  ------------------
  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|    378|        salg = (pgp_symm_alg_t) balg;
  208|    378|        wrapped_key_len--;
  209|    378|    }
  210|  1.09k|    enc.wrapped_sesskey.resize(wrapped_key_len);
  211|  1.09k|    if (!pkt.get(enc.wrapped_sesskey.data(), enc.wrapped_sesskey.size())) {
  ------------------
  |  Branch (211:9): [True: 122, False: 972]
  ------------------
  212|    122|        RNP_LOG("failed to get kyber-ecdh session key");
  ------------------
  |  |   76|    122|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    122|    do {                                                                                 \
  |  |  |  |   69|    122|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 122, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    122|            break;                                                                       \
  |  |  |  |   71|    122|        (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|    122|        return false;
  214|    122|    }
  215|    972|    return true;
  216|  1.09k|}

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

_ZN3pgp11FingerprintC2Ev:
   38|  59.3k|Fingerprint::Fingerprint() : keyid_({})
   39|  59.3k|{
   40|  59.3k|}
_ZN3pgp11FingerprintC2EPKhm:
   42|  9.28k|Fingerprint::Fingerprint(const uint8_t *data, size_t size) : Fingerprint()
   43|  9.28k|{
   44|  9.28k|    fp_.assign(data, data + size);
   45|  9.28k|}
_ZN3pgp11FingerprintC2ERK13pgp_key_pkt_t:
   48|  37.5k|{
   49|  37.5k|    switch (key.version) {
   50|  1.23k|    case PGP_V2:
  ------------------
  |  Branch (50:5): [True: 1.23k, False: 36.3k]
  ------------------
   51|  3.05k|    case PGP_V3: {
  ------------------
  |  Branch (51:5): [True: 1.82k, False: 35.7k]
  ------------------
   52|       |        /* v2/3 fingerprint is calculated from RSA public numbers */
   53|  3.05k|        if (!is_rsa_key_alg(key.alg)) {
  ------------------
  |  Branch (53:13): [True: 0, False: 3.05k]
  ------------------
   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.05k|        auto &rsa = dynamic_cast<const pgp::RSAKeyMaterial &>(*key.material);
   58|  3.05k|        auto  hash = rnp::Hash::create(PGP_HASH_MD5);
   59|  3.05k|        hash->add(rsa.n());
   60|  3.05k|        hash->add(rsa.e());
   61|  3.05k|        fp_ = hash->finish();
   62|       |        /* keyid just low bytes of RSA n */
   63|  3.05k|        size_t n = rsa.n().size();
   64|  3.05k|        size_t sz = std::min(rsa.n().size(), keyid_.size());
   65|  3.05k|        std::memcpy(keyid_.data(), rsa.n().data() + n - sz, sz);
   66|  3.05k|        return;
   67|  3.05k|    }
   68|  28.5k|    case PGP_V4:
  ------------------
  |  Branch (68:5): [True: 28.5k, False: 9.06k]
  ------------------
   69|  29.0k|    case PGP_V5:
  ------------------
  |  Branch (69:5): [True: 530, False: 37.0k]
  ------------------
   70|  29.0k|#if defined(ENABLE_CRYPTO_REFRESH)
   71|  34.5k|    case PGP_V6:
  ------------------
  |  Branch (71:5): [True: 5.47k, False: 32.0k]
  ------------------
   72|  34.5k|#endif
   73|  34.5k|    {
   74|  34.5k|        auto halg = key.version == PGP_V4 ? PGP_HASH_SHA1 : PGP_HASH_SHA256;
  ------------------
  |  Branch (74:21): [True: 28.5k, False: 6.00k]
  ------------------
   75|  34.5k|        auto hash = rnp::Hash::create(halg);
   76|  34.5k|        signature_hash_key(key, *hash, key.version);
   77|  34.5k|        fp_ = hash->finish();
   78|       |        /* keyid */
   79|  34.5k|        if (key.version == PGP_V4) {
  ------------------
  |  Branch (79:13): [True: 28.5k, False: 6.00k]
  ------------------
   80|  28.5k|            assert(fp_.size() == PGP_FINGERPRINT_V4_SIZE);
   81|  28.5k|            const size_t inc = PGP_FINGERPRINT_V4_SIZE - PGP_KEY_ID_SIZE;
  ------------------
  |  |   43|  28.5k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
                          const size_t inc = PGP_FINGERPRINT_V4_SIZE - PGP_KEY_ID_SIZE;
  ------------------
  |  |   39|  28.5k|#define PGP_KEY_ID_SIZE 8
  ------------------
   82|  28.5k|            memcpy(keyid_.data(), fp_.data() + inc, keyid_.size());
   83|  28.5k|        } else {
   84|  6.00k|            memcpy(keyid_.data(), fp_.data(), keyid_.size());
   85|  6.00k|        }
   86|  34.5k|        return;
   87|  29.0k|    }
   88|      0|    default:
  ------------------
  |  Branch (88:5): [True: 0, False: 37.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|  37.5k|    }
   92|  37.5k|}
_ZNK3pgp11Fingerprint5keyidEv:
  115|  37.5k|{
  116|  37.5k|    return keyid_;
  117|  37.5k|}
_ZNK3pgp11Fingerprint4dataEv:
  127|  5.99k|{
  128|  5.99k|    return fp_.data();
  129|  5.99k|}
_ZNK3pgp11Fingerprint4sizeEv:
  133|  5.99k|{
  134|  5.99k|    return fp_.size();
  135|  5.99k|}

_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|   397k|{
   58|   397k|    return json_add(obj, name, json_object_new_boolean(value));
   59|   397k|}
_Z8json_addP11json_objectPKci:
   63|   425k|{
   64|   425k|    return json_add(obj, name, json_object_new_int(value));
   65|   425k|}
_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.1k|{
   80|  11.1k|    return json_add(obj, name, json_object_new_string_len(value, len));
   81|  11.1k|}
_Z8json_addP11json_objectPKcRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   85|   422k|{
   86|   422k|    return json_add(obj, name, json_object_new_string_len(value.data(), value.size()));
   87|   422k|}
_Z12json_add_hexP11json_objectPKcPKhm:
   91|   415k|{
   92|   415k|    if (val_len > 1024 * 1024) {
  ------------------
  |  Branch (92:9): [True: 0, False: 415k]
  ------------------
   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|   415k|    return json_add(obj, name, bin_to_hex(val, val_len, rnp::HexFormat::Lowercase));
   98|   415k|}
_Z12json_add_hexP11json_objectPKcRKNSt3__16vectorIhNS3_9allocatorIhEEEE:
  102|  29.6k|{
  103|  29.6k|    return json_add_hex(obj, name, vec.data(), vec.size());
  104|  29.6k|}
_Z8json_addP11json_objectPKcRKNSt3__15arrayIhLm8EEE:
  108|  23.2k|{
  109|  23.2k|    return json_add_hex(obj, name, keyid.data(), keyid.size());
  110|  23.2k|}
_Z8json_addP11json_objectPKcRKN3pgp11FingerprintE:
  114|  2.30k|{
  115|  2.30k|    return json_add_hex(obj, name, fp.data(), fp.size());
  116|  2.30k|}
_Z14json_array_addP11json_objectPKc:
  120|  25.0k|{
  121|  25.0k|    return json_array_add(obj, json_object_new_string(val));
  122|  25.0k|}
_Z14json_array_addP11json_objectS0_:
  126|  46.3k|{
  127|  46.3k|    if (!val) {
  ------------------
  |  Branch (127:9): [True: 0, False: 46.3k]
  ------------------
  128|      0|        return false;
  129|      0|    }
  130|  46.3k|    if (json_object_array_add(obj, val)) {
  ------------------
  |  Branch (130:9): [True: 0, False: 46.3k]
  ------------------
  131|      0|        json_object_put(val);
  132|      0|        return false;
  133|      0|    }
  134|  46.3k|    return true;
  135|  46.3k|}

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

_ZN3pgp11KeyMaterialD2Ev:
  238|  57.1k|{
  239|  57.1k|}
_ZNK3pgp11KeyMaterial3algEv:
  243|  60.1k|{
  244|  60.1k|    return alg_;
  245|  60.1k|}
_ZN3pgp11KeyMaterial6createE16pgp_pubkey_alg_t:
  376|  57.6k|{
  377|  57.6k|    switch (alg) {
  378|  7.53k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (378:5): [True: 7.53k, False: 50.1k]
  ------------------
  379|  16.0k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (379:5): [True: 8.53k, False: 49.1k]
  ------------------
  380|  23.8k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (380:5): [True: 7.81k, False: 49.8k]
  ------------------
  381|  23.8k|        return std::unique_ptr<KeyMaterial>(new RSAKeyMaterial(alg));
  382|  2.15k|    case PGP_PKA_ELGAMAL:
  ------------------
  |  Branch (382:5): [True: 2.15k, False: 55.5k]
  ------------------
  383|  3.37k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (383:5): [True: 1.22k, False: 56.4k]
  ------------------
  384|  3.37k|        return std::unique_ptr<KeyMaterial>(new EGKeyMaterial(alg));
  385|  1.51k|    case PGP_PKA_DSA:
  ------------------
  |  Branch (385:5): [True: 1.51k, False: 56.1k]
  ------------------
  386|  1.51k|        return std::unique_ptr<KeyMaterial>(new DSAKeyMaterial());
  387|  3.63k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (387:5): [True: 3.63k, False: 54.0k]
  ------------------
  388|  3.63k|        return std::unique_ptr<KeyMaterial>(new ECDHKeyMaterial());
  389|  2.80k|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (389:5): [True: 2.80k, False: 54.8k]
  ------------------
  390|  2.80k|        return std::unique_ptr<KeyMaterial>(new ECDSAKeyMaterial());
  391|  2.21k|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (391:5): [True: 2.21k, False: 55.4k]
  ------------------
  392|  2.21k|        return std::unique_ptr<KeyMaterial>(new EDDSAKeyMaterial());
  393|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  394|  1.82k|    case PGP_PKA_ED25519:
  ------------------
  |  Branch (394:5): [True: 1.82k, False: 55.8k]
  ------------------
  395|  1.82k|        return std::unique_ptr<KeyMaterial>(new Ed25519KeyMaterial());
  396|  2.19k|    case PGP_PKA_X25519:
  ------------------
  |  Branch (396:5): [True: 2.19k, False: 55.4k]
  ------------------
  397|  2.19k|        return std::unique_ptr<KeyMaterial>(new X25519KeyMaterial());
  398|      0|#endif
  399|  1.77k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (399:5): [True: 1.77k, False: 55.8k]
  ------------------
  400|  1.77k|        return std::unique_ptr<KeyMaterial>(new SM2KeyMaterial());
  401|      0|#if defined(ENABLE_PQC)
  402|    715|    case PGP_PKA_KYBER768_X25519:
  ------------------
  |  Branch (402:5): [True: 715, False: 56.9k]
  ------------------
  403|    715|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    715|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  404|       |    // TODO: Add case for PGP_PKA_KYBER1024_X448
  405|  1.90k|    case PGP_PKA_KYBER768_P256:
  ------------------
  |  Branch (405:5): [True: 1.19k, False: 56.4k]
  ------------------
  406|  1.90k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.90k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  407|  3.33k|    case PGP_PKA_KYBER1024_P384:
  ------------------
  |  Branch (407:5): [True: 1.42k, False: 56.2k]
  ------------------
  408|  3.33k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.33k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  409|  4.42k|    case PGP_PKA_KYBER768_BP256:
  ------------------
  |  Branch (409:5): [True: 1.09k, False: 56.5k]
  ------------------
  410|  4.42k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.42k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  411|  5.45k|    case PGP_PKA_KYBER1024_BP384:
  ------------------
  |  Branch (411:5): [True: 1.03k, False: 56.6k]
  ------------------
  412|  5.45k|        return std::unique_ptr<KeyMaterial>(new MlkemEcdhKeyMaterial(alg));
  413|  2.01k|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (413:5): [True: 2.01k, False: 55.6k]
  ------------------
  414|  2.01k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  2.01k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  415|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448
  416|  3.20k|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (416:5): [True: 1.19k, False: 56.4k]
  ------------------
  417|  3.20k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.20k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  418|  3.85k|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (418:5): [True: 656, False: 57.0k]
  ------------------
  419|  3.85k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  3.85k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  420|  4.80k|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (420:5): [True: 946, False: 56.7k]
  ------------------
  421|  4.80k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.80k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  422|  5.64k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (422:5): [True: 840, False: 56.8k]
  ------------------
  423|  5.64k|        return std::unique_ptr<KeyMaterial>(new DilithiumEccKeyMaterial(alg));
  424|  1.10k|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (424:5): [True: 1.10k, False: 56.5k]
  ------------------
  425|  1.10k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.10k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  426|  2.79k|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (426:5): [True: 1.69k, False: 55.9k]
  ------------------
  427|  2.79k|        return std::unique_ptr<KeyMaterial>(new SlhdsaKeyMaterial(alg));
  428|      0|#endif
  429|    540|    default:
  ------------------
  |  Branch (429:5): [True: 540, False: 57.1k]
  ------------------
  430|    540|        return nullptr;
  431|  57.6k|    }
  432|  57.6k|}
_ZN3pgp14RSAKeyMaterial5parseER17pgp_packet_body_t:
  497|  23.6k|{
  498|  23.6k|    secret_ = false;
  499|  23.6k|    return pkt.get(key_.n) && pkt.get(key_.e);
  ------------------
  |  Branch (499:12): [True: 22.9k, False: 654]
  |  Branch (499:31): [True: 22.5k, False: 360]
  ------------------
  500|  23.6k|}
_ZNK3pgp14RSAKeyMaterial1nEv:
  614|  32.5k|{
  615|  32.5k|    return key_.n;
  616|  32.5k|}
_ZNK3pgp14RSAKeyMaterial1eEv:
  620|  23.4k|{
  621|  23.4k|    return key_.e;
  622|  23.4k|}
_ZN3pgp14DSAKeyMaterial5parseER17pgp_packet_body_t:
  678|  1.51k|{
  679|  1.51k|    secret_ = false;
  680|  1.51k|    return pkt.get(key_.p) && pkt.get(key_.q) && pkt.get(key_.g) && pkt.get(key_.y);
  ------------------
  |  Branch (680:12): [True: 1.15k, False: 362]
  |  Branch (680:31): [True: 880, False: 272]
  |  Branch (680:50): [True: 672, False: 208]
  |  Branch (680:69): [True: 672, False: 0]
  ------------------
  681|  1.51k|}
_ZNK3pgp14DSAKeyMaterial1pEv:
  775|    670|{
  776|    670|    return key_.p;
  777|    670|}
_ZNK3pgp14DSAKeyMaterial1qEv:
  781|    670|{
  782|    670|    return key_.q;
  783|    670|}
_ZNK3pgp14DSAKeyMaterial1gEv:
  787|    670|{
  788|    670|    return key_.g;
  789|    670|}
_ZNK3pgp14DSAKeyMaterial1yEv:
  793|    670|{
  794|    670|    return key_.y;
  795|    670|}
_ZN3pgp13EGKeyMaterial5parseER17pgp_packet_body_t:
  832|  3.12k|{
  833|  3.12k|    secret_ = false;
  834|  3.12k|    return pkt.get(key_.p) && pkt.get(key_.g) && pkt.get(key_.y);
  ------------------
  |  Branch (834:12): [True: 2.33k, False: 794]
  |  Branch (834:31): [True: 2.12k, False: 210]
  |  Branch (834:50): [True: 1.98k, False: 132]
  ------------------
  835|  3.12k|}
_ZNK3pgp13EGKeyMaterial1pEv:
  925|  1.84k|{
  926|  1.84k|    return key_.p;
  927|  1.84k|}
_ZNK3pgp13EGKeyMaterial1gEv:
  931|  1.84k|{
  932|  1.84k|    return key_.g;
  933|  1.84k|}
_ZNK3pgp13EGKeyMaterial1yEv:
  937|  1.84k|{
  938|  1.84k|    return key_.y;
  939|  1.84k|}
_ZN3pgp13ECKeyMaterial5parseER17pgp_packet_body_t:
  982|  9.79k|{
  983|  9.79k|    secret_ = false;
  984|  9.79k|    if (!pkt.get(key_.curve) || !pkt.get(key_.p)) {
  ------------------
  |  Branch (984:9): [True: 3.56k, False: 6.23k]
  |  Branch (984:33): [True: 1.55k, False: 4.68k]
  ------------------
  985|  5.11k|        return false;
  986|  5.11k|    }
  987|  4.68k|    return true;
  988|  9.79k|}
_ZNK3pgp13ECKeyMaterial5curveEv:
 1046|  3.39k|{
 1047|  3.39k|    return key_.curve;
 1048|  3.39k|}
_ZNK3pgp13ECKeyMaterial1pEv:
 1052|  3.39k|{
 1053|  3.39k|    return key_.p;
 1054|  3.39k|}
_ZN3pgp15ECDHKeyMaterial5parseER17pgp_packet_body_t:
 1140|  3.59k|{
 1141|  3.59k|    if (!ECKeyMaterial::parse(pkt)) {
  ------------------
  |  Branch (1141:9): [True: 1.43k, False: 2.16k]
  ------------------
 1142|  1.43k|        return false;
 1143|  1.43k|    }
 1144|       |    /* Additional ECDH fields */
 1145|       |    /* Read KDF parameters. At the moment should be 0x03 0x01 halg ealg */
 1146|  2.16k|    uint8_t len = 0, halg = 0, walg = 0;
 1147|  2.16k|    if (!pkt.get(len) || (len != 3)) {
  ------------------
  |  Branch (1147:9): [True: 208, False: 1.95k]
  |  Branch (1147:26): [True: 235, False: 1.72k]
  ------------------
 1148|    443|        return false;
 1149|    443|    }
 1150|  1.72k|    if (!pkt.get(len) || (len != 1)) {
  ------------------
  |  Branch (1150:9): [True: 211, False: 1.51k]
  |  Branch (1150:26): [True: 210, False: 1.30k]
  ------------------
 1151|    421|        return false;
 1152|    421|    }
 1153|  1.30k|    if (!pkt.get(halg) || !pkt.get(walg)) {
  ------------------
  |  Branch (1153:9): [True: 198, False: 1.10k]
  |  Branch (1153:27): [True: 194, False: 911]
  ------------------
 1154|    392|        return false;
 1155|    392|    }
 1156|    911|    key_.kdf_hash_alg = (pgp_hash_alg_t) halg;
 1157|    911|    key_.key_wrap_alg = (pgp_symm_alg_t) walg;
 1158|    911|    return true;
 1159|  1.30k|}
_ZNK3pgp15ECDHKeyMaterial12kdf_hash_algEv:
 1229|    893|{
 1230|    893|    return key_.kdf_hash_alg;
 1231|    893|}
_ZNK3pgp15ECDHKeyMaterial12key_wrap_algEv:
 1235|    893|{
 1236|    893|    return key_.key_wrap_alg;
 1237|    893|}
_ZN3pgp18Ed25519KeyMaterial5parseER17pgp_packet_body_t:
 1430|  1.69k|{
 1431|  1.69k|    secret_ = false;
 1432|  1.69k|    auto                 ec_desc = ec::Curve::get(PGP_CURVE_ED25519);
 1433|  1.69k|    std::vector<uint8_t> buf(ec_desc->bytes());
 1434|  1.69k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1434:9): [True: 338, False: 1.35k]
  ------------------
 1435|    338|        RNP_LOG("failed to parse Ed25519 public key 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1436|    338|        return false;
 1437|    338|    }
 1438|  1.35k|    key_.pub = buf;
 1439|  1.35k|    return true;
 1440|  1.69k|}
_ZNK3pgp18Ed25519KeyMaterial3pubEv:
 1517|    363|{
 1518|    363|    return key_.pub;
 1519|    363|}
_ZN3pgp17X25519KeyMaterial5parseER17pgp_packet_body_t:
 1555|  2.16k|{
 1556|  2.16k|    secret_ = false;
 1557|  2.16k|    auto                 ec_desc = ec::Curve::get(PGP_CURVE_25519);
 1558|  2.16k|    std::vector<uint8_t> buf(ec_desc->bytes());
 1559|  2.16k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1559:9): [True: 211, False: 1.95k]
  ------------------
 1560|    211|        RNP_LOG("failed to parse X25519 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1561|    211|        return false;
 1562|    211|    }
 1563|  1.95k|    key_.pub = buf;
 1564|  1.95k|    return true;
 1565|  2.16k|}
_ZNK3pgp17X25519KeyMaterial3pubEv:
 1647|    531|{
 1648|    531|    return key_.pub;
 1649|    531|}
_ZN3pgp20MlkemEcdhKeyMaterial5parseER17pgp_packet_body_t:
 1686|  5.09k|{
 1687|  5.09k|    secret_ = false;
 1688|  5.09k|    std::vector<uint8_t> buf(pgp_kyber_ecdh_composite_public_key_t::encoded_size(alg()));
 1689|  5.09k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1689:9): [True: 844, False: 4.25k]
  ------------------
 1690|    844|        RNP_LOG("failed to parse mlkem-ecdh public key data");
  ------------------
  |  |   76|    844|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    844|    do {                                                                                 \
  |  |  |  |   69|    844|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 844, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    844|            break;                                                                       \
  |  |  |  |   71|    844|        (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|    844|        return false;
 1692|    844|    }
 1693|  4.25k|    key_.pub = pgp_kyber_ecdh_composite_public_key_t(buf, alg());
 1694|  4.25k|    return true;
 1695|  5.09k|}
_ZNK3pgp20MlkemEcdhKeyMaterial3pubEv:
 1770|  1.71k|{
 1771|  1.71k|    return key_.pub;
 1772|  1.71k|}
_ZN3pgp23DilithiumEccKeyMaterial5parseER17pgp_packet_body_t:
 1807|  5.37k|{
 1808|  5.37k|    secret_ = false;
 1809|  5.37k|    std::vector<uint8_t> buf(pgp_dilithium_exdsa_composite_public_key_t::encoded_size(alg()));
 1810|  5.37k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1810:9): [True: 1.11k, False: 4.25k]
  ------------------
 1811|  1.11k|        RNP_LOG("failed to parse mldsa-ecdsa/eddsa public key data");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1812|  1.11k|        return false;
 1813|  1.11k|    }
 1814|  4.25k|    key_.pub = pgp_dilithium_exdsa_composite_public_key_t(buf, alg());
 1815|  4.25k|    return true;
 1816|  5.37k|}
_ZNK3pgp23DilithiumEccKeyMaterial3pubEv:
 1892|  2.05k|{
 1893|  2.05k|    return key_.pub;
 1894|  2.05k|}
_ZN3pgp17SlhdsaKeyMaterial5parseER17pgp_packet_body_t:
 1929|  2.62k|{
 1930|  2.62k|    secret_ = false;
 1931|  2.62k|    uint8_t bt = 0;
 1932|  2.62k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (1932:9): [True: 224, False: 2.39k]
  ------------------
 1933|    224|        RNP_LOG("failed to parse SLH-DSA public key 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1934|    224|        return false;
 1935|    224|    }
 1936|  2.39k|    sphincsplus_parameter_t param = (sphincsplus_parameter_t) bt;
 1937|  2.39k|    auto                    size = sphincsplus_pubkey_size(param);
 1938|  2.39k|    if (!size) {
  ------------------
  |  Branch (1938:9): [True: 240, False: 2.15k]
  ------------------
 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.15k|    std::vector<uint8_t> buf(size);
 1943|  2.15k|    if (!pkt.get(buf.data(), buf.size())) {
  ------------------
  |  Branch (1943:9): [True: 212, False: 1.94k]
  ------------------
 1944|    212|        RNP_LOG("failed to parse SLH-DSA 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1945|    212|        return false;
 1946|    212|    }
 1947|  1.94k|    key_.pub = pgp_sphincsplus_public_key_t(buf, param, alg());
 1948|  1.94k|    return true;
 1949|  2.15k|}
_ZNK3pgp17SlhdsaKeyMaterial3pubEv:
 2039|    958|{
 2040|    958|    return key_.pub;
 2041|    958|}

_ZN3pgp11KeyMaterialC2E16pgp_pubkey_alg_tb:
  193|  57.1k|        : validity_({}), alg_(kalg), secret_(secret){};
_ZN3pgp14RSAKeyMaterialC2E16pgp_pubkey_alg_t:
  245|  23.8k|    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.37k|    EGKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp13ECKeyMaterialC2E16pgp_pubkey_alg_t:
  363|  10.4k|    ECKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp16ECDSAKeyMaterialC2Ev:
  386|  2.80k|    ECDSAKeyMaterial() : ECKeyMaterial(PGP_PKA_ECDSA){};
_ZN3pgp15ECDHKeyMaterialC2Ev:
  405|  3.63k|    ECDHKeyMaterial() : ECKeyMaterial(PGP_PKA_ECDH){};
_ZN3pgp16EDDSAKeyMaterialC2Ev:
  431|  2.21k|    EDDSAKeyMaterial() : ECKeyMaterial(PGP_PKA_EDDSA){};
_ZN3pgp14SM2KeyMaterialC2Ev:
  450|  1.77k|    SM2KeyMaterial() : ECKeyMaterial(PGP_PKA_SM2){};
_ZN3pgp18Ed25519KeyMaterialC2Ev:
  479|  1.82k|    Ed25519KeyMaterial() : KeyMaterial(PGP_PKA_ED25519), key_{} {};
_ZN3pgp17X25519KeyMaterialC2Ev:
  509|  2.19k|    X25519KeyMaterial() : KeyMaterial(PGP_PKA_X25519), key_{} {};
_ZN3pgp20MlkemEcdhKeyMaterialC2E16pgp_pubkey_alg_t:
  541|  5.45k|    MlkemEcdhKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp23DilithiumEccKeyMaterialC2E16pgp_pubkey_alg_t:
  570|  5.64k|    DilithiumEccKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};
_ZN3pgp17SlhdsaKeyMaterialC2E16pgp_pubkey_alg_t:
  602|  2.79k|    SlhdsaKeyMaterial(pgp_pubkey_alg_t kalg) : KeyMaterial(kalg), key_{} {};

_Z14rnp_log_switchv:
   53|   358k|{
   54|   358k|    if (_rnp_log_switch < 0) {
  ------------------
  |  Branch (54:9): [True: 1, False: 358k]
  ------------------
   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|   358k|    return !_rnp_log_disable && !!_rnp_log_switch;
  ------------------
  |  Branch (58:12): [True: 358k, False: 0]
  |  Branch (58:33): [True: 0, False: 358k]
  ------------------
   59|   358k|}

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

_ZN3pgp11SigMaterial6createE16pgp_pubkey_alg_t14pgp_hash_alg_t:
   35|  47.7k|{
   36|  47.7k|    switch (palg) {
   37|  16.7k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (37:5): [True: 16.7k, False: 31.0k]
  ------------------
   38|  29.7k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (38:5): [True: 12.9k, False: 34.7k]
  ------------------
   39|  29.7k|        return std::unique_ptr<SigMaterial>(new RSASigMaterial(halg));
   40|  1.67k|    case PGP_PKA_DSA:
  ------------------
  |  Branch (40:5): [True: 1.67k, False: 46.0k]
  ------------------
   41|  1.67k|        return std::unique_ptr<SigMaterial>(new DSASigMaterial(halg));
   42|  2.78k|    case PGP_PKA_EDDSA:
  ------------------
  |  Branch (42:5): [True: 2.78k, False: 44.9k]
  ------------------
   43|  6.94k|    case PGP_PKA_ECDSA:
  ------------------
  |  Branch (43:5): [True: 4.16k, False: 43.5k]
  ------------------
   44|  7.97k|    case PGP_PKA_SM2:
  ------------------
  |  Branch (44:5): [True: 1.03k, False: 46.7k]
  ------------------
   45|  10.1k|    case PGP_PKA_ECDH:
  ------------------
  |  Branch (45:5): [True: 2.13k, False: 45.6k]
  ------------------
   46|  10.1k|        return std::unique_ptr<SigMaterial>(new ECSigMaterial(halg));
   47|  1.40k|    case PGP_PKA_ELGAMAL: /* we support reading it but will not validate */
  ------------------
  |  Branch (47:5): [True: 1.40k, False: 46.3k]
  ------------------
   48|  3.13k|    case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
  ------------------
  |  Branch (48:5): [True: 1.72k, False: 46.0k]
  ------------------
   49|  3.13k|        return std::unique_ptr<SigMaterial>(new EGSigMaterial(halg));
   50|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   51|    548|    case PGP_PKA_ED25519: {
  ------------------
  |  Branch (51:5): [True: 548, False: 47.2k]
  ------------------
   52|    548|        return std::unique_ptr<SigMaterial>(new Ed25519SigMaterial(halg));
   53|  1.40k|    }
   54|      0|#endif
   55|      0|#if defined(ENABLE_PQC)
   56|    214|    case PGP_PKA_DILITHIUM3_ED25519:
  ------------------
  |  Branch (56:5): [True: 214, False: 47.5k]
  ------------------
   57|    214|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    214|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   58|       |    // TODO: Add case for PGP_PKA_DILITHIUM5_ED448 with FALLTHROUGH_STATEMENT;
   59|    426|    case PGP_PKA_DILITHIUM3_P256:
  ------------------
  |  Branch (59:5): [True: 212, False: 47.5k]
  ------------------
   60|    426|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    426|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   61|    649|    case PGP_PKA_DILITHIUM5_P384:
  ------------------
  |  Branch (61:5): [True: 223, False: 47.5k]
  ------------------
   62|    649|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    649|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   63|    859|    case PGP_PKA_DILITHIUM3_BP256:
  ------------------
  |  Branch (63:5): [True: 210, False: 47.5k]
  ------------------
   64|    859|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    859|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   65|  1.09k|    case PGP_PKA_DILITHIUM5_BP384:
  ------------------
  |  Branch (65:5): [True: 231, False: 47.5k]
  ------------------
   66|  1.09k|        return std::unique_ptr<SigMaterial>(new DilithiumSigMaterial(palg, halg));
   67|    732|    case PGP_PKA_SPHINCSPLUS_SHA2:
  ------------------
  |  Branch (67:5): [True: 732, False: 47.0k]
  ------------------
   68|    732|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|    732|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   69|  1.03k|    case PGP_PKA_SPHINCSPLUS_SHAKE:
  ------------------
  |  Branch (69:5): [True: 305, False: 47.4k]
  ------------------
   70|  1.03k|        return std::unique_ptr<SigMaterial>(new SlhdsaSigMaterial(halg));
   71|      0|#endif
   72|    438|    default:
  ------------------
  |  Branch (72:5): [True: 438, False: 47.3k]
  ------------------
   73|    438|        RNP_LOG("Unknown pk algorithm : %d", (int) palg);
  ------------------
  |  |   76|    438|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    438|    do {                                                                                 \
  |  |  |  |   69|    438|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 438, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    438|            break;                                                                       \
  |  |  |  |   71|    438|        (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|    438|        return nullptr;
   75|  47.7k|    }
   76|  47.7k|}
_ZN3pgp14RSASigMaterial5parseER17pgp_packet_body_t:
   80|  29.7k|{
   81|  29.7k|    return pkt.get(sig.s);
   82|  29.7k|}
_ZN3pgp14DSASigMaterial5parseER17pgp_packet_body_t:
   92|  1.67k|{
   93|  1.67k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (93:12): [True: 1.45k, False: 224]
  |  Branch (93:30): [True: 1.41k, False: 44]
  ------------------
   94|  1.67k|}
_ZN3pgp13EGSigMaterial5parseER17pgp_packet_body_t:
  105|  3.13k|{
  106|  3.13k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (106:12): [True: 2.67k, False: 459]
  |  Branch (106:30): [True: 2.59k, False: 75]
  ------------------
  107|  3.13k|}
_ZN3pgp13ECSigMaterial5parseER17pgp_packet_body_t:
  119|  10.1k|{
  120|  10.1k|    return pkt.get(sig.r) && pkt.get(sig.s);
  ------------------
  |  Branch (120:12): [True: 8.78k, False: 1.32k]
  |  Branch (120:30): [True: 8.52k, False: 253]
  ------------------
  121|  10.1k|}
_ZN3pgp18Ed25519SigMaterial5parseER17pgp_packet_body_t:
  133|    548|{
  134|    548|    auto ec_desc = pgp::ec::Curve::get(PGP_CURVE_25519);
  135|    548|    if (!pkt.get(sig.sig, 2 * ec_desc->bytes())) {
  ------------------
  |  Branch (135:9): [True: 228, False: 320]
  ------------------
  136|    228|        RNP_LOG("failed to parse ED25519 signature data");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  137|    228|        return false;
  138|    228|    }
  139|    320|    return true;
  140|    548|}
_ZN3pgp20DilithiumSigMaterial5parseER17pgp_packet_body_t:
  152|  1.09k|{
  153|  1.09k|    if (!pkt.get(sig.sig, pgp_dilithium_exdsa_signature_t::composite_signature_size(palg))) {
  ------------------
  |  Branch (153:9): [True: 1.07k, False: 20]
  ------------------
  154|  1.07k|        RNP_LOG("failed to get mldsa-ecdsa/eddsa signature");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  155|  1.07k|        return false;
  156|  1.07k|    }
  157|     20|    return true;
  158|  1.09k|}
_ZN3pgp17SlhdsaSigMaterial5parseER17pgp_packet_body_t:
  168|  1.03k|{
  169|  1.03k|    uint8_t param = 0;
  170|  1.03k|    if (!pkt.get(param)) {
  ------------------
  |  Branch (170:9): [True: 258, False: 779]
  ------------------
  171|    258|        RNP_LOG("failed to parse SLH-DSA signature data");
  ------------------
  |  |   76|    258|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    258|    do {                                                                                 \
  |  |  |  |   69|    258|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 258, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    258|            break;                                                                       \
  |  |  |  |   71|    258|        (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|    258|        return false;
  173|    258|    }
  174|    779|    auto sig_size = sphincsplus_signature_size((sphincsplus_parameter_t) param);
  175|    779|    if (!sig_size) {
  ------------------
  |  Branch (175:9): [True: 320, False: 459]
  ------------------
  176|    320|        RNP_LOG("invalid SLH-DSA param value");
  ------------------
  |  |   76|    320|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    320|    do {                                                                                 \
  |  |  |  |   69|    320|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 320, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    320|            break;                                                                       \
  |  |  |  |   71|    320|        (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|    320|        return false;
  178|    320|    }
  179|    459|    sig.param = (sphincsplus_parameter_t) param;
  180|    459|    if (!pkt.get(sig.sig, sig_size)) {
  ------------------
  |  Branch (180:9): [True: 441, False: 18]
  ------------------
  181|    441|        RNP_LOG("failed to parse SLH-DSA signature data");
  ------------------
  |  |   76|    441|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    441|    do {                                                                                 \
  |  |  |  |   69|    441|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 441, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    441|            break;                                                                       \
  |  |  |  |   71|    441|        (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|    441|        return false;
  183|    441|    }
  184|     18|    return true;
  185|    459|}

_ZN3pgp11SigMaterialC2E14pgp_hash_alg_t:
   40|  47.3k|    SigMaterial(pgp_hash_alg_t ahalg) : halg(ahalg){};
_ZN3pgp11SigMaterialD2Ev:
   41|  47.3k|    virtual ~SigMaterial(){};
_ZN3pgp14RSASigMaterialC2E14pgp_hash_alg_t:
   52|  29.7k|    RSASigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp14DSASigMaterialC2E14pgp_hash_alg_t:
   61|  1.67k|    DSASigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp13EGSigMaterialC2E14pgp_hash_alg_t:
   70|  3.13k|    EGSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp13ECSigMaterialC2E14pgp_hash_alg_t:
   79|  10.1k|    ECSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp18Ed25519SigMaterialC2E14pgp_hash_alg_t:
   89|    548|    Ed25519SigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};
_ZN3pgp20DilithiumSigMaterialC2E16pgp_pubkey_alg_t14pgp_hash_alg_t:
  103|  1.09k|        : SigMaterial(ahalg), palg(apalg){};
_ZN3pgp17SlhdsaSigMaterialC2E14pgp_hash_alg_t:
  112|  1.03k|    SlhdsaSigMaterial(pgp_hash_alg_t ahalg) : SigMaterial(ahalg){};

_ZN3pgp3pkt6sigsub3RawC2Ehbb:
   43|  32.8k|    : hashed_(hashed), raw_type_(rawtype), critical_(critical), type_(Type::Unknown)
   44|  32.8k|{
   45|  32.8k|}
_ZN3pgp3pkt6sigsub3RawC2ENS1_4TypeEbb:
   48|   105k|    : hashed_(hashed), raw_type_(static_cast<uint8_t>(type)), critical_(critical), type_(type)
   49|   105k|{
   50|   105k|}
_ZN3pgp3pkt6sigsub3RawD2Ev:
   53|   146k|{
   54|   146k|}
_ZNK3pgp3pkt6sigsub3Raw10check_sizeEm:
   58|  40.2k|{
   59|  40.2k|    return true;
   60|  40.2k|};
_ZN3pgp3pkt6sigsub3Raw10parse_dataEPKhm:
   64|  24.6k|{
   65|  24.6k|    return true;
   66|  24.6k|};
_ZN3pgp3pkt6sigsub3Raw5parseEPKhm:
   70|   129k|{
   71|   129k|    if (!check_size(size)) {
  ------------------
  |  Branch (71:9): [True: 37.7k, False: 91.9k]
  ------------------
   72|  37.7k|        RNP_LOG("wrong len %zu of subpacket type %" PRIu8, size, raw_type_);
  ------------------
  |  |   76|  37.7k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  37.7k|    do {                                                                                 \
  |  |  |  |   69|  37.7k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 37.7k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  37.7k|            break;                                                                       \
  |  |  |  |   71|  37.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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   73|  37.7k|        return false;
   74|  37.7k|    }
   75|  91.9k|    if (!parse_data(data, size)) {
  ------------------
  |  Branch (75:9): [True: 1.57k, False: 90.4k]
  ------------------
   76|  1.57k|        return false;
   77|  1.57k|    }
   78|  90.4k|    data_.assign(data, data + size);
   79|  90.4k|    return true;
   80|  91.9k|}
_ZN3pgp3pkt6sigsub3Raw6createEhbb:
  128|   138k|{
  129|   138k|    switch (type) {
  130|  2.40k|    case (uint8_t) Type::CreationTime:
  ------------------
  |  Branch (130:5): [True: 2.40k, False: 135k]
  ------------------
  131|  2.40k|        return RawPtr(new CreationTime(hashed, critical));
  132|  1.96k|    case (uint8_t) Type::ExpirationTime:
  ------------------
  |  Branch (132:5): [True: 1.96k, False: 136k]
  ------------------
  133|  1.96k|        return RawPtr(new ExpirationTime(hashed, critical));
  134|  3.69k|    case (uint8_t) Type::ExportableCert:
  ------------------
  |  Branch (134:5): [True: 3.69k, False: 134k]
  ------------------
  135|  3.69k|        return RawPtr(new ExportableCert(hashed, critical));
  136|  1.42k|    case (uint8_t) Type::Trust:
  ------------------
  |  Branch (136:5): [True: 1.42k, False: 136k]
  ------------------
  137|  1.42k|        return RawPtr(new Trust(hashed, critical));
  138|  2.74k|    case (uint8_t) Type::RegExp:
  ------------------
  |  Branch (138:5): [True: 2.74k, False: 135k]
  ------------------
  139|  2.74k|        return RawPtr(new RegExp(hashed, critical));
  140|    923|    case (uint8_t) Type::Revocable:
  ------------------
  |  Branch (140:5): [True: 923, False: 137k]
  ------------------
  141|    923|        return RawPtr(new Revocable(hashed, critical));
  142|  7.42k|    case (uint8_t) Type::KeyExpirationTime:
  ------------------
  |  Branch (142:5): [True: 7.42k, False: 130k]
  ------------------
  143|  7.42k|        return RawPtr(new KeyExpirationTime(hashed, critical));
  144|  3.91k|    case (uint8_t) Type::PreferredSymmetric:
  ------------------
  |  Branch (144:5): [True: 3.91k, False: 134k]
  ------------------
  145|  3.91k|        return RawPtr(new PreferredSymmetric(hashed, critical));
  146|  29.1k|    case (uint8_t) Type::RevocationKey:
  ------------------
  |  Branch (146:5): [True: 29.1k, False: 108k]
  ------------------
  147|  29.1k|        return RawPtr(new RevocationKey(hashed, critical));
  148|  2.79k|    case (uint8_t) Type::IssuerKeyID:
  ------------------
  |  Branch (148:5): [True: 2.79k, False: 135k]
  ------------------
  149|  2.79k|        return RawPtr(new IssuerKeyID(hashed, critical));
  150|  3.76k|    case (uint8_t) Type::NotationData:
  ------------------
  |  Branch (150:5): [True: 3.76k, False: 134k]
  ------------------
  151|  3.76k|        return RawPtr(new NotationData(hashed, critical));
  152|  7.37k|    case (uint8_t) Type::PreferredHash:
  ------------------
  |  Branch (152:5): [True: 7.37k, False: 130k]
  ------------------
  153|  7.37k|        return RawPtr(new PreferredHash(hashed, critical));
  154|  1.77k|    case (uint8_t) Type::PreferredCompress:
  ------------------
  |  Branch (154:5): [True: 1.77k, False: 136k]
  ------------------
  155|  1.77k|        return RawPtr(new PreferredCompress(hashed, critical));
  156|  1.40k|    case (uint8_t) Type::KeyserverPrefs:
  ------------------
  |  Branch (156:5): [True: 1.40k, False: 136k]
  ------------------
  157|  1.40k|        return RawPtr(new KeyserverPrefs(hashed, critical));
  158|  3.41k|    case (uint8_t) Type::PreferredKeyserver:
  ------------------
  |  Branch (158:5): [True: 3.41k, False: 134k]
  ------------------
  159|  3.41k|        return RawPtr(new PreferredKeyserver(hashed, critical));
  160|    978|    case (uint8_t) Type::PrimaryUserID:
  ------------------
  |  Branch (160:5): [True: 978, False: 137k]
  ------------------
  161|    978|        return RawPtr(new PrimaryUserID(hashed, critical));
  162|  2.79k|    case (uint8_t) Type::PolicyURI:
  ------------------
  |  Branch (162:5): [True: 2.79k, False: 135k]
  ------------------
  163|  2.79k|        return RawPtr(new PolicyURI(hashed, critical));
  164|  4.48k|    case (uint8_t) Type::KeyFlags:
  ------------------
  |  Branch (164:5): [True: 4.48k, False: 133k]
  ------------------
  165|  4.48k|        return RawPtr(new KeyFlags(hashed, critical));
  166|  6.65k|    case (uint8_t) Type::SignersUserID:
  ------------------
  |  Branch (166:5): [True: 6.65k, False: 131k]
  ------------------
  167|  6.65k|        return RawPtr(new SignersUserID(hashed, critical));
  168|  3.18k|    case (uint8_t) Type::RevocationReason:
  ------------------
  |  Branch (168:5): [True: 3.18k, False: 134k]
  ------------------
  169|  3.18k|        return RawPtr(new RevocationReason(hashed, critical));
  170|  2.10k|    case (uint8_t) Type::Features:
  ------------------
  |  Branch (170:5): [True: 2.10k, False: 135k]
  ------------------
  171|  2.10k|        return RawPtr(new Features(hashed, critical));
  172|  3.99k|    case (uint8_t) Type::EmbeddedSignature:
  ------------------
  |  Branch (172:5): [True: 3.99k, False: 134k]
  ------------------
  173|  3.99k|        return RawPtr(new EmbeddedSignature(hashed, critical));
  174|  3.95k|    case (uint8_t) Type::IssuerFingerprint:
  ------------------
  |  Branch (174:5): [True: 3.95k, False: 134k]
  ------------------
  175|  3.95k|        return RawPtr(new IssuerFingerprint(hashed, critical));
  176|  1.35k|    case (uint8_t) Type::PreferredAEAD:
  ------------------
  |  Branch (176:5): [True: 1.35k, False: 136k]
  ------------------
  177|  1.35k|        return RawPtr(new PreferredAEAD(hashed, critical));
  178|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  179|  1.50k|    case (uint8_t) Type::PreferredAEADv6:
  ------------------
  |  Branch (179:5): [True: 1.50k, False: 136k]
  ------------------
  180|  1.50k|        return RawPtr(new PreferredAEADv6(hashed, critical));
  181|      0|#endif
  182|  32.8k|    default:
  ------------------
  |  Branch (182:5): [True: 32.8k, False: 105k]
  ------------------
  183|  32.8k|        report_unknown(type, critical);
  184|  32.8k|        return RawPtr(new Raw(type, hashed, critical));
  185|   138k|    }
  186|   138k|}
_ZN3pgp3pkt6sigsub3Raw6createEPKhmb:
  196|   138k|{
  197|   138k|    if (!size) {
  ------------------
  |  Branch (197:9): [True: 0, False: 138k]
  ------------------
  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|   138k|    bool    critical = data[0] & 0x80;
  202|   138k|    uint8_t type = data[0] & 0x7f;
  203|   138k|    auto    sub = create(type, hashed, critical);
  204|   138k|    if (!sub || ((sub->type() == Type::Unknown) && critical) ||
  ------------------
  |  Branch (204:9): [True: 0, False: 138k]
  |  Branch (204:18): [True: 32.8k, False: 105k]
  |  Branch (204:52): [True: 8.25k, False: 24.6k]
  ------------------
  205|   129k|        !sub->parse(data + 1, size - 1)) {
  ------------------
  |  Branch (205:9): [True: 39.3k, False: 90.4k]
  ------------------
  206|  47.6k|        return nullptr;
  207|  47.6k|    }
  208|  90.4k|    return sub;
  209|   138k|}
_ZNK3pgp3pkt6sigsub3Raw5cloneEv:
  213|  1.49k|{
  214|  1.49k|    return RawPtr(new Raw(*this));
  215|  1.49k|}
_ZNK3pgp3pkt6sigsub4Time10check_sizeEm:
  227|  11.7k|{
  228|  11.7k|    return size == 4;
  229|  11.7k|}
_ZN3pgp3pkt6sigsub4Time10parse_dataEPKhm:
  233|  7.99k|{
  234|  7.99k|    time_ = read_uint32(data);
  235|  7.99k|    return true;
  236|  7.99k|}
_ZNK3pgp3pkt6sigsub12CreationTime5cloneEv:
  241|    154|{
  242|    154|    return RawPtr(new CreationTime(*this));
  243|    154|}
_ZNK3pgp3pkt6sigsub14ExpirationTime5cloneEv:
  248|     68|{
  249|     68|    return RawPtr(new ExpirationTime(*this));
  250|     68|}
_ZNK3pgp3pkt6sigsub17KeyExpirationTime5cloneEv:
  255|     66|{
  256|     66|    return RawPtr(new KeyExpirationTime(*this));
  257|     66|}
_ZNK3pgp3pkt6sigsub4Bool10check_sizeEm:
  269|  5.59k|{
  270|  5.59k|    return size == 1;
  271|  5.59k|}
_ZN3pgp3pkt6sigsub4Bool10parse_dataEPKhm:
  275|  1.47k|{
  276|  1.47k|    value_ = data[0];
  277|  1.47k|    return true;
  278|  1.47k|}
_ZNK3pgp3pkt6sigsub14ExportableCert5cloneEv:
  283|    109|{
  284|    109|    return RawPtr(new ExportableCert(*this));
  285|    109|}
_ZNK3pgp3pkt6sigsub5Trust10check_sizeEm:
  298|  1.42k|{
  299|  1.42k|    return size == 2;
  300|  1.42k|}
_ZN3pgp3pkt6sigsub5Trust10parse_dataEPKhm:
  304|  1.04k|{
  305|  1.04k|    level_ = data[0];
  306|  1.04k|    amount_ = data[1];
  307|  1.04k|    return true;
  308|  1.04k|}
_ZNK3pgp3pkt6sigsub5Trust5cloneEv:
  312|    136|{
  313|    136|    return RawPtr(new Trust(*this));
  314|    136|}
_ZN3pgp3pkt6sigsub6String10parse_dataEPKhm:
  325|  15.6k|{
  326|  15.6k|    value_.assign(data, data + size);
  327|  15.6k|    return true;
  328|  15.6k|}
_ZNK3pgp3pkt6sigsub6RegExp5cloneEv:
  333|    670|{
  334|    670|    return RawPtr(new RegExp(*this));
  335|    670|}
_ZNK3pgp3pkt6sigsub9Revocable5cloneEv:
  340|    100|{
  341|    100|    return RawPtr(new Revocable(*this));
  342|    100|}
_ZNK3pgp3pkt6sigsub9Preferred10check_sizeEm:
  353|  15.6k|{
  354|       |    /* No reason to have more then 256 bytes */
  355|  15.6k|    return size < 256;
  356|  15.6k|}
_ZN3pgp3pkt6sigsub9Preferred10parse_dataEPKhm:
  360|  15.2k|{
  361|  15.2k|    algs_.assign(data, data + size);
  362|  15.2k|    return true;
  363|  15.2k|}
_ZNK3pgp3pkt6sigsub18PreferredSymmetric5cloneEv:
  368|    116|{
  369|    116|    return RawPtr(new PreferredSymmetric(*this));
  370|    116|}
_ZNK3pgp3pkt6sigsub13PreferredHash5cloneEv:
  375|    248|{
  376|    248|    return RawPtr(new PreferredHash(*this));
  377|    248|}
_ZNK3pgp3pkt6sigsub17PreferredCompress5cloneEv:
  382|    253|{
  383|    253|    return RawPtr(new PreferredCompress(*this));
  384|    253|}
_ZNK3pgp3pkt6sigsub13PreferredAEAD5cloneEv:
  389|    268|{
  390|    268|    return RawPtr(new PreferredAEAD(*this));
  391|    268|}
_ZNK3pgp3pkt6sigsub15PreferredAEADv610check_sizeEm:
  397|  1.50k|{
  398|  1.50k|    if (size % 2) {
  ------------------
  |  Branch (398:9): [True: 277, False: 1.22k]
  ------------------
  399|    277|        RNP_LOG("v6 AEAD Ciphersuite Preferences must contain an even number of bytes");
  ------------------
  |  |   76|    277|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    277|    do {                                                                                 \
  |  |  |  |   69|    277|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 277, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    277|            break;                                                                       \
  |  |  |  |   71|    277|        (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|    277|        return false;
  401|    277|    }
  402|  1.22k|    return Preferred::check_size(size);
  403|  1.50k|}
_ZNK3pgp3pkt6sigsub15PreferredAEADv65cloneEv:
  407|    748|{
  408|    748|    return RawPtr(new PreferredAEADv6(*this));
  409|    748|}
_ZNK3pgp3pkt6sigsub13RevocationKey10check_sizeEm:
  424|  29.1k|{
  425|  29.1k|    return (size == 2 + PGP_FINGERPRINT_V4_SIZE) || (size == 2 + PGP_FINGERPRINT_V5_SIZE);
  ------------------
  |  |   43|  29.1k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
                  return (size == 2 + PGP_FINGERPRINT_V4_SIZE) || (size == 2 + PGP_FINGERPRINT_V5_SIZE);
  ------------------
  |  |   44|  28.7k|#define PGP_FINGERPRINT_V5_SIZE 32
  ------------------
  |  Branch (425:12): [True: 340, False: 28.7k]
  |  Branch (425:53): [True: 2.03k, False: 26.7k]
  ------------------
  426|  29.1k|}
_ZN3pgp3pkt6sigsub13RevocationKey10parse_dataEPKhm:
  430|  2.37k|{
  431|  2.37k|    rev_class_ = data[0];
  432|  2.37k|    alg_ = static_cast<pgp_pubkey_alg_t>(data[1]);
  433|  2.37k|    fp_ = pgp::Fingerprint(data + 2, size - 2);
  434|  2.37k|    return true;
  435|  2.37k|}
_ZNK3pgp3pkt6sigsub13RevocationKey5cloneEv:
  439|     66|{
  440|     66|    return RawPtr(new RevocationKey(*this));
  441|     66|}
_ZNK3pgp3pkt6sigsub11IssuerKeyID10check_sizeEm:
  452|  2.79k|{
  453|  2.79k|    return size == PGP_KEY_ID_SIZE;
  ------------------
  |  |   39|  2.79k|#define PGP_KEY_ID_SIZE 8
  ------------------
  454|  2.79k|}
_ZN3pgp3pkt6sigsub11IssuerKeyID10parse_dataEPKhm:
  458|  2.46k|{
  459|  2.46k|    memcpy(keyid_.data(), data, keyid_.size());
  460|  2.46k|    return true;
  461|  2.46k|}
_ZNK3pgp3pkt6sigsub11IssuerKeyID5cloneEv:
  465|    207|{
  466|    207|    return RawPtr(new IssuerKeyID(*this));
  467|    207|}
_ZNK3pgp3pkt6sigsub12NotationData10check_sizeEm:
  487|  3.76k|{
  488|  3.76k|    return size >= 8;
  489|  3.76k|}
_ZN3pgp3pkt6sigsub12NotationData10parse_dataEPKhm:
  493|  3.57k|{
  494|  3.57k|    size_t nlen = read_uint16(data + 4);
  495|  3.57k|    size_t vlen = read_uint16(data + 6);
  496|  3.57k|    if (size != nlen + vlen + 8) {
  ------------------
  |  Branch (496:9): [True: 890, False: 2.68k]
  ------------------
  497|    890|        return false;
  498|    890|    }
  499|  2.68k|    memcpy(flags_.data(), data, 4);
  500|  2.68k|    name_.assign(data + 8, data + 8 + nlen);
  501|  2.68k|    value_.assign(data + 8 + nlen, data + 8 + nlen + vlen);
  502|  2.68k|    return true;
  503|  3.57k|}
_ZNK3pgp3pkt6sigsub12NotationData5cloneEv:
  537|    133|{
  538|    133|    return RawPtr(new NotationData(*this));
  539|    133|}
_ZNK3pgp3pkt6sigsub5Flags10check_sizeEm:
  551|  7.99k|{
  552|  7.99k|    return size >= 1;
  553|  7.99k|}
_ZN3pgp3pkt6sigsub5Flags10parse_dataEPKhm:
  557|  7.26k|{
  558|  7.26k|    flags_ = data[0];
  559|  7.26k|    return true;
  560|  7.26k|}
_ZNK3pgp3pkt6sigsub14KeyserverPrefs5cloneEv:
  565|    310|{
  566|    310|    return RawPtr(new KeyserverPrefs(*this));
  567|    310|}
_ZNK3pgp3pkt6sigsub18PreferredKeyserver5cloneEv:
  572|    479|{
  573|    479|    return RawPtr(new PreferredKeyserver(*this));
  574|    479|}
_ZNK3pgp3pkt6sigsub13PrimaryUserID5cloneEv:
  579|    196|{
  580|    196|    return RawPtr(new PrimaryUserID(*this));
  581|    196|}
_ZNK3pgp3pkt6sigsub9PolicyURI5cloneEv:
  586|    845|{
  587|    845|    return RawPtr(new PolicyURI(*this));
  588|    845|}
_ZNK3pgp3pkt6sigsub8KeyFlags5cloneEv:
  593|     91|{
  594|     91|    return RawPtr(new KeyFlags(*this));
  595|     91|}
_ZNK3pgp3pkt6sigsub13SignersUserID5cloneEv:
  600|    426|{
  601|    426|    return RawPtr(new SignersUserID(*this));
  602|    426|}
_ZNK3pgp3pkt6sigsub16RevocationReason10check_sizeEm:
  615|  3.18k|{
  616|  3.18k|    return size >= 1;
  617|  3.18k|}
_ZN3pgp3pkt6sigsub16RevocationReason10parse_dataEPKhm:
  621|  3.04k|{
  622|  3.04k|    code_ = static_cast<pgp_revocation_type_t>(data[0]);
  623|  3.04k|    reason_.assign(data + 1, data + size);
  624|  3.04k|    return true;
  625|  3.04k|}
_ZNK3pgp3pkt6sigsub16RevocationReason5cloneEv:
  629|    793|{
  630|    793|    return RawPtr(new RevocationReason(*this));
  631|    793|}
_ZNK3pgp3pkt6sigsub8Features5cloneEv:
  636|    348|{
  637|    348|    return RawPtr(new Features(*this));
  638|    348|}
_ZN3pgp3pkt6sigsub17EmbeddedSignatureC2ERKS2_:
  641|    254|EmbeddedSignature::EmbeddedSignature(const EmbeddedSignature &src) : Raw(src)
  642|    254|{
  643|    254|    signature_ = std::unique_ptr<Signature>(new Signature(*src.signature_));
  644|    254|}
_ZN3pgp3pkt6sigsub17EmbeddedSignatureC2Ebb:
  647|  3.99k|    : Raw(Type::EmbeddedSignature, hashed, critical)
  648|  3.99k|{
  649|  3.99k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature10check_sizeEm:
  666|  3.99k|{
  667|  3.99k|    return size > 6;
  668|  3.99k|}
_ZN3pgp3pkt6sigsub17EmbeddedSignature10parse_dataEPKhm:
  672|  3.82k|{
  673|  3.82k|    pgp_packet_body_t pkt(data, size);
  674|  3.82k|    Signature         sig;
  675|  3.82k|    if (sig.parse(pkt)) {
  ------------------
  |  Branch (675:9): [True: 688, False: 3.13k]
  ------------------
  676|    688|        return false;
  677|    688|    }
  678|  3.13k|    signature_ = std::unique_ptr<Signature>(new Signature(std::move(sig)));
  679|  3.13k|    return true;
  680|  3.82k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature9signatureEv:
  684|  1.44k|{
  685|  1.44k|    return signature_.get();
  686|  1.44k|}
_ZNK3pgp3pkt6sigsub17EmbeddedSignature5cloneEv:
  703|    254|{
  704|    254|    return RawPtr(new EmbeddedSignature(*this));
  705|    254|}
_ZNK3pgp3pkt6sigsub17IssuerFingerprint10check_sizeEm:
  718|  3.95k|{
  719|  3.95k|    return (size >= 21) && (size <= PGP_MAX_FINGERPRINT_SIZE + 1);
  ------------------
  |  |   45|  3.70k|#define PGP_MAX_FINGERPRINT_SIZE 32
  ------------------
  |  Branch (719:12): [True: 3.70k, False: 258]
  |  Branch (719:28): [True: 3.42k, False: 280]
  ------------------
  720|  3.95k|}
_ZN3pgp3pkt6sigsub17IssuerFingerprint10parse_dataEPKhm:
  724|  3.42k|{
  725|  3.42k|    version_ = data[0];
  726|  3.42k|    fp_ = pgp::Fingerprint(data + 1, size - 1);
  727|  3.42k|    return true;
  728|  3.42k|}
_ZNK3pgp3pkt6sigsub17IssuerFingerprint5cloneEv:
  732|    140|{
  733|    140|    return RawPtr(new IssuerFingerprint(*this));
  734|    140|}
_ZN3pgp3pkt6sigsub4ListC2ERKS2_:
  737|  3.87k|{
  738|  3.87k|    items.reserve(src.items.size());
  739|  8.71k|    for (auto &item : src.items) {
  ------------------
  |  Branch (739:21): [True: 8.71k, False: 3.87k]
  ------------------
  740|  8.71k|        items.push_back(item->clone());
  741|  8.71k|    }
  742|  3.87k|}
sig_subpacket.cpp:_ZN3pgp3pkt6sigsubL14report_unknownEhb:
   93|  32.8k|{
   94|  32.8k|    switch (type) {
   95|    430|    case (uint8_t) Type::Private_100:
  ------------------
  |  Branch (95:5): [True: 430, False: 32.4k]
  ------------------
   96|    886|    case (uint8_t) Type::Private_101:
  ------------------
  |  Branch (96:5): [True: 456, False: 32.4k]
  ------------------
   97|  1.16k|    case (uint8_t) Type::Private_102:
  ------------------
  |  Branch (97:5): [True: 274, False: 32.5k]
  ------------------
   98|  1.52k|    case (uint8_t) Type::Private_103:
  ------------------
  |  Branch (98:5): [True: 360, False: 32.5k]
  ------------------
   99|  2.17k|    case (uint8_t) Type::Private_104:
  ------------------
  |  Branch (99:5): [True: 656, False: 32.2k]
  ------------------
  100|  2.64k|    case (uint8_t) Type::Private_105:
  ------------------
  |  Branch (100:5): [True: 472, False: 32.3k]
  ------------------
  101|  3.05k|    case (uint8_t) Type::Private_106:
  ------------------
  |  Branch (101:5): [True: 408, False: 32.4k]
  ------------------
  102|  3.52k|    case (uint8_t) Type::Private_107:
  ------------------
  |  Branch (102:5): [True: 465, False: 32.4k]
  ------------------
  103|  3.76k|    case (uint8_t) Type::Private_108:
  ------------------
  |  Branch (103:5): [True: 240, False: 32.6k]
  ------------------
  104|  4.00k|    case (uint8_t) Type::Private_109:
  ------------------
  |  Branch (104:5): [True: 248, False: 32.6k]
  ------------------
  105|  4.75k|    case (uint8_t) Type::Private_110:
  ------------------
  |  Branch (105:5): [True: 745, False: 32.1k]
  ------------------
  106|  4.75k|        if (critical) {
  ------------------
  |  Branch (106:13): [True: 753, False: 4.00k]
  ------------------
  107|    753|            RNP_LOG("unknown critical private subpacket %" PRIu8, type);
  ------------------
  |  |   76|    753|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    753|    do {                                                                                 \
  |  |  |  |   69|    753|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 753, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    753|            break;                                                                       \
  |  |  |  |   71|    753|        (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|    753|        }
  109|  4.75k|        return;
  110|  2.94k|    case (uint8_t) Type::Reserved_1:
  ------------------
  |  Branch (110:5): [True: 2.94k, False: 29.9k]
  ------------------
  111|  4.35k|    case (uint8_t) Type::Reserved_8:
  ------------------
  |  Branch (111:5): [True: 1.41k, False: 31.4k]
  ------------------
  112|  4.94k|    case (uint8_t) Type::Placeholder:
  ------------------
  |  Branch (112:5): [True: 594, False: 32.2k]
  ------------------
  113|  5.49k|    case (uint8_t) Type::Reserved_13:
  ------------------
  |  Branch (113:5): [True: 546, False: 32.3k]
  ------------------
  114|  5.76k|    case (uint8_t) Type::Reserved_14:
  ------------------
  |  Branch (114:5): [True: 271, False: 32.5k]
  ------------------
  115|  6.03k|    case (uint8_t) Type::Reserved_15:
  ------------------
  |  Branch (115:5): [True: 269, False: 32.6k]
  ------------------
  116|  6.83k|    case (uint8_t) Type::Reserved_17:
  ------------------
  |  Branch (116:5): [True: 804, False: 32.0k]
  ------------------
  117|  7.76k|    case (uint8_t) Type::Reserved_18:
  ------------------
  |  Branch (117:5): [True: 932, False: 31.9k]
  ------------------
  118|  8.06k|    case (uint8_t) Type::Reserved_19:
  ------------------
  |  Branch (118:5): [True: 296, False: 32.5k]
  ------------------
  119|       |        /* do not report reserved/placeholder subpacket */
  120|  8.06k|        return;
  121|  20.0k|    default:
  ------------------
  |  Branch (121:5): [True: 20.0k, False: 12.8k]
  ------------------
  122|  20.0k|        RNP_LOG("unknown subpacket : %" PRIu8, type);
  ------------------
  |  |   76|  20.0k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  20.0k|    do {                                                                                 \
  |  |  |  |   69|  20.0k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 20.0k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  20.0k|            break;                                                                       \
  |  |  |  |   71|  20.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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  123|  32.8k|    }
  124|  32.8k|}

_ZNK3pgp3pkt6sigsub3Raw8raw_typeEv:
  125|  79.2k|    {
  126|  79.2k|        return raw_type_;
  127|  79.2k|    }
_ZNK3pgp3pkt6sigsub3Raw4dataEv:
  131|   105k|    {
  132|   105k|        return data_;
  133|   105k|    }
_ZNK3pgp3pkt6sigsub3Raw4typeEv:
  137|   190k|    {
  138|   190k|        return type_;
  139|   190k|    }
_ZNK3pgp3pkt6sigsub3Raw8criticalEv:
  143|  52.7k|    {
  144|  52.7k|        return critical_;
  145|  52.7k|    }
_ZNK3pgp3pkt6sigsub3Raw6hashedEv:
  155|  79.2k|    {
  156|  79.2k|        return hashed_;
  157|  79.2k|    }
_ZN3pgp3pkt6sigsub4TimeC2ENS1_4TypeEbb:
  183|  11.7k|    Time(Type type, bool hashed, bool critical) : Raw(type, hashed, critical), time_(0)
  184|  11.7k|    {
  185|  11.7k|    }
_ZNK3pgp3pkt6sigsub4Time4timeEv:
  189|  6.72k|    {
  190|  6.72k|        return time_;
  191|  6.72k|    }
_ZN3pgp3pkt6sigsub12CreationTimeC2Ebb:
  207|  2.40k|        : Time(Type::CreationTime, hashed, critical)
  208|  2.40k|    {
  209|  2.40k|    }
_ZN3pgp3pkt6sigsub14ExpirationTimeC2Ebb:
  218|  1.96k|        : Time(Type::ExpirationTime, hashed, critical)
  219|  1.96k|    {
  220|  1.96k|    }
_ZN3pgp3pkt6sigsub17KeyExpirationTimeC2Ebb:
  229|  7.42k|        : Time(Type::KeyExpirationTime, hashed, critical)
  230|  7.42k|    {
  231|  7.42k|    }
_ZN3pgp3pkt6sigsub4BoolC2ENS1_4TypeEbb:
  246|  5.59k|    Bool(Type type, bool hashed, bool critical) : Raw(type, hashed, critical), value_(false)
  247|  5.59k|    {
  248|  5.59k|    }
_ZN3pgp3pkt6sigsub14ExportableCertC2Ebb:
  257|  3.69k|        : Bool(Type::ExportableCert, hashed, critical)
  258|  3.69k|    {
  259|  3.69k|        value_ = true;
  260|  3.69k|    }
_ZNK3pgp3pkt6sigsub14ExportableCert10exportableEv:
  264|    209|    {
  265|    209|        return value_;
  266|    209|    }
_ZN3pgp3pkt6sigsub5TrustC2Ebb:
  291|  1.42k|        : Raw(Type::Trust, hashed, critical), level_(0), amount_(0)
  292|  1.42k|    {
  293|  1.42k|    }
_ZNK3pgp3pkt6sigsub5Trust5levelEv:
  297|    426|    {
  298|    426|        return level_;
  299|    426|    }
_ZNK3pgp3pkt6sigsub5Trust6amountEv:
  303|    426|    {
  304|    426|        return amount_;
  305|    426|    }
_ZN3pgp3pkt6sigsub6StringC2ENS1_4TypeEbb:
  334|  15.6k|    String(Type type, bool hashed, bool critical) : Raw(type, hashed, critical)
  335|  15.6k|    {
  336|  15.6k|    }
_ZN3pgp3pkt6sigsub6RegExpC2Ebb:
  344|  2.74k|    RegExp(bool hashed = true, bool critical = false) : String(Type::RegExp, hashed, critical)
  345|  2.74k|    {
  346|  2.74k|    }
_ZNK3pgp3pkt6sigsub6RegExp6regexpEv:
  350|  1.22k|    {
  351|  1.22k|        return value_;
  352|  1.22k|    }
_ZN3pgp3pkt6sigsub9RevocableC2Ebb:
  361|    923|        : Bool(Type::Revocable, hashed, critical)
  362|    923|    {
  363|    923|        value_ = true;
  364|    923|    }
_ZNK3pgp3pkt6sigsub9Revocable9revocableEv:
  368|    164|    {
  369|    164|        return value_;
  370|    164|    }
_ZN3pgp3pkt6sigsub9PreferredC2ENS1_4TypeEbb:
  393|  15.9k|    Preferred(Type type, bool hashed, bool critical) : Raw(type, hashed, critical){};
_ZNK3pgp3pkt6sigsub9Preferred4algsEv:
  397|  5.95k|    {
  398|  5.95k|        return algs_;
  399|  5.95k|    }
_ZN3pgp3pkt6sigsub18PreferredSymmetricC2Ebb:
  415|  3.91k|        : Preferred(Type::PreferredSymmetric, hashed, critical){};
_ZN3pgp3pkt6sigsub13PreferredHashC2Ebb:
  424|  7.37k|        : Preferred(Type::PreferredHash, hashed, critical){};
_ZN3pgp3pkt6sigsub17PreferredCompressC2Ebb:
  433|  1.77k|        : Preferred(Type::PreferredCompress, hashed, critical){};
_ZN3pgp3pkt6sigsub13PreferredAEADC2Ebb:
  442|  1.35k|        : Preferred(Type::PreferredAEAD, hashed, critical){};
_ZN3pgp3pkt6sigsub15PreferredAEADv6C2Ebb:
  455|  1.50k|        : Preferred(Type::PreferredAEADv6, hashed, critical){};
_ZN3pgp3pkt6sigsub13RevocationKeyC2Ebb:
  475|  29.1k|        : Raw(Type::RevocationKey, hashed, critical), rev_class_(0),
  476|  29.1k|          alg_(PGP_PKA_NOTHING), fp_{} {};
_ZNK3pgp3pkt6sigsub13RevocationKey9rev_classEv:
  480|  2.07k|    {
  481|  2.07k|        return rev_class_;
  482|  2.07k|    }
_ZNK3pgp3pkt6sigsub13RevocationKey3algEv:
  493|  2.07k|    {
  494|  2.07k|        return alg_;
  495|  2.07k|    }
_ZNK3pgp3pkt6sigsub13RevocationKey2fpEv:
  506|  2.07k|    {
  507|  2.07k|        return fp_;
  508|  2.07k|    }
_ZN3pgp3pkt6sigsub11IssuerKeyIDC2Ebb:
  532|  2.79k|        : Raw(Type::IssuerKeyID, hashed, critical)
  533|  2.79k|    {
  534|  2.79k|    }
_ZNK3pgp3pkt6sigsub11IssuerKeyID5keyidEv:
  538|  1.14k|    {
  539|  1.14k|        return keyid_;
  540|  1.14k|    }
_ZN3pgp3pkt6sigsub12NotationDataC2Ebb:
  566|  3.76k|        : Raw(Type::NotationData, hashed, critical)
  567|  3.76k|    {
  568|  3.76k|    }
_ZNK3pgp3pkt6sigsub12NotationData14human_readableEv:
  572|  3.57k|    {
  573|  3.57k|        return flags_[0] & 0x80;
  574|  3.57k|    }
_ZNK3pgp3pkt6sigsub12NotationData4nameEv:
  580|  2.38k|    {
  581|  2.38k|        return name_;
  582|  2.38k|    }
_ZNK3pgp3pkt6sigsub12NotationData5valueEv:
  588|  4.77k|    {
  589|  4.77k|        return value_;
  590|  4.77k|    }
_ZN3pgp3pkt6sigsub5FlagsC2ENS1_4TypeEbb:
  608|  7.99k|        : Raw(type, hashed, critical), flags_(0)
  609|  7.99k|    {
  610|  7.99k|    }
_ZN3pgp3pkt6sigsub14KeyserverPrefsC2Ebb:
  619|  1.40k|        : Flags(Type::KeyserverPrefs, hashed, critical)
  620|  1.40k|    {
  621|  1.40k|    }
_ZNK3pgp3pkt6sigsub14KeyserverPrefs9no_modifyEv:
  625|    500|    {
  626|    500|        return flags_ & 0x80;
  627|    500|    }
_ZN3pgp3pkt6sigsub18PreferredKeyserverC2Ebb:
  656|  3.41k|        : String(Type::PreferredKeyserver, hashed, critical)
  657|  3.41k|    {
  658|  3.41k|    }
_ZNK3pgp3pkt6sigsub18PreferredKeyserver9keyserverEv:
  662|  1.10k|    {
  663|  1.10k|        return value_;
  664|  1.10k|    }
_ZN3pgp3pkt6sigsub13PrimaryUserIDC2Ebb:
  680|    978|        : Bool(Type::PrimaryUserID, hashed, critical)
  681|    978|    {
  682|    978|    }
_ZNK3pgp3pkt6sigsub13PrimaryUserID7primaryEv:
  686|    426|    {
  687|    426|        return value_;
  688|    426|    }
_ZN3pgp3pkt6sigsub9PolicyURIC2Ebb:
  704|  2.79k|        : String(Type::PolicyURI, hashed, critical)
  705|  2.79k|    {
  706|  2.79k|    }
_ZNK3pgp3pkt6sigsub9PolicyURI3URIEv:
  710|  1.24k|    {
  711|  1.24k|        return value_;
  712|  1.24k|    }
_ZN3pgp3pkt6sigsub8KeyFlagsC2Ebb:
  721|  4.48k|        : Flags(Type::KeyFlags, hashed, critical)
  722|  4.48k|    {
  723|  4.48k|    }
_ZNK3pgp3pkt6sigsub8KeyFlags5flagsEv:
  727|  3.13k|    {
  728|  3.13k|        return flags_;
  729|  3.13k|    }
_ZN3pgp3pkt6sigsub13SignersUserIDC2Ebb:
  745|  6.65k|        : String(Type::SignersUserID, hashed, critical)
  746|  6.65k|    {
  747|  6.65k|    }
_ZNK3pgp3pkt6sigsub13SignersUserID6signerEv:
  751|  5.37k|    {
  752|  5.37k|        return value_;
  753|  5.37k|    }
_ZN3pgp3pkt6sigsub16RevocationReasonC2Ebb:
  778|  3.18k|        : Raw(Type::RevocationReason, hashed, critical), code_(PGP_REVOCATION_NO_REASON)
  779|  3.18k|    {
  780|  3.18k|    }
_ZNK3pgp3pkt6sigsub16RevocationReason4codeEv:
  784|  1.97k|    {
  785|  1.97k|        return code_;
  786|  1.97k|    }
_ZNK3pgp3pkt6sigsub16RevocationReason6reasonEv:
  797|  1.31k|    {
  798|  1.31k|        return reason_;
  799|  1.31k|    }
_ZN3pgp3pkt6sigsub8FeaturesC2Ebb:
  815|  2.10k|        : Flags(Type::Features, hashed, critical)
  816|  2.10k|    {
  817|  2.10k|    }
_ZNK3pgp3pkt6sigsub8Features8featuresEv:
  821|  5.82k|    {
  822|  5.82k|        return flags_;
  823|  5.82k|    }
_ZN3pgp3pkt6sigsub17IssuerFingerprintC2Ebb:
  871|  3.95k|        : Raw(Type::IssuerFingerprint, hashed, critical), version_(0), fp_{}
  872|  3.95k|    {
  873|  3.95k|    }
_ZNK3pgp3pkt6sigsub17IssuerFingerprint2fpEv:
  890|  2.53k|    {
  891|  2.53k|        return fp_;
  892|  2.53k|    }
_ZN3pgp3pkt6sigsub4ListC2Ev:
  909|  52.2k|    {
  910|  52.2k|    }
_ZNK3pgp3pkt6sigsub4List5beginEv:
  928|  27.6k|    {
  929|  27.6k|        return items.begin();
  930|  27.6k|    }
_ZNK3pgp3pkt6sigsub4List3endEv:
  934|  27.6k|    {
  935|  27.6k|        return items.end();
  936|  27.6k|    }
_ZNK3pgp3pkt6sigsub4List4sizeEv:
  940|   140k|    {
  941|   140k|        return items.size();
  942|   140k|    }

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

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

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

_Z16init_armored_srcP12pgp_source_tS0_b:
  705|  1.81k|{
  706|  1.81k|    if (!init_src_common(src, 0)) {
  ------------------
  |  Branch (706:9): [True: 0, False: 1.81k]
  ------------------
  707|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  708|      0|    }
  709|  1.81k|    pgp_source_armored_param_t *param = new (std::nothrow) pgp_source_armored_param_t();
  710|  1.81k|    if (!param) {
  ------------------
  |  Branch (710:9): [True: 0, False: 1.81k]
  ------------------
  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.81k|    param->readsrc = readsrc;
  716|  1.81k|    param->noheaders = noheaders;
  717|  1.81k|    src->param = param;
  718|  1.81k|    src->raw_read = armored_src_read;
  719|  1.81k|    src->raw_close = armored_src_close;
  720|  1.81k|    src->type = PGP_STREAM_ARMORED;
  721|       |
  722|       |    /* base64 data only */
  723|  1.81k|    if (noheaders) {
  ------------------
  |  Branch (723:9): [True: 0, False: 1.81k]
  ------------------
  724|      0|        return RNP_SUCCESS;
  725|      0|    }
  726|       |
  727|       |    /* initialize crc context */
  728|  1.81k|    param->crc_ctx = rnp::CRC24::create();
  729|       |    /* parsing armored header */
  730|  1.81k|    rnp_result_t errcode = RNP_ERROR_GENERIC;
  731|  1.81k|    if (!armor_parse_header(param)) {
  ------------------
  |  Branch (731:9): [True: 462, False: 1.34k]
  ------------------
  732|    462|        errcode = RNP_ERROR_BAD_FORMAT;
  733|    462|        goto finish;
  734|    462|    }
  735|       |    /* eol */
  736|  1.34k|    if (!param->readsrc->skip_eol()) {
  ------------------
  |  Branch (736:9): [True: 68, False: 1.28k]
  ------------------
  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.28k|    if (!armor_parse_headers(param)) {
  ------------------
  |  Branch (742:9): [True: 472, False: 808]
  ------------------
  743|    472|        RNP_LOG("failed to parse headers");
  ------------------
  |  |   76|    472|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    472|    do {                                                                                 \
  |  |  |  |   69|    472|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 472, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    472|            break;                                                                       \
  |  |  |  |   71|    472|        (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|    472|        errcode = RNP_ERROR_BAD_FORMAT;
  745|    472|        goto finish;
  746|    472|    }
  747|       |
  748|       |    /* now we are good to go with base64-encoded data */
  749|    808|    errcode = RNP_SUCCESS;
  750|  1.81k|finish:
  751|  1.81k|    if (errcode) {
  ------------------
  |  Branch (751:9): [True: 1.00k, False: 808]
  ------------------
  752|  1.00k|        src->close();
  753|  1.00k|    }
  754|  1.81k|    return errcode;
  755|    808|}
_ZN12pgp_source_t10is_armoredEv:
 1050|  15.5k|{
 1051|  15.5k|    char   buf[ARMORED_PEEK_BUF_SIZE] = {0};
 1052|  15.5k|    size_t read = 0;
 1053|       |
 1054|  15.5k|    if (!peek(buf, sizeof(buf) - 1, &read) || (read < strlen(ST_ARMOR_BEGIN) + 1)) {
  ------------------
  |  |   46|  15.5k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  |  Branch (1054:9): [True: 0, False: 15.5k]
  |  Branch (1054:47): [True: 6.48k, False: 9.07k]
  ------------------
 1055|  6.48k|        return false;
 1056|  6.48k|    }
 1057|  9.07k|    buf[read] = 0;
 1058|  9.07k|    if (!!strstr(buf, ST_CLEAR_BEGIN)) {
  ------------------
  |  |   48|  9.07k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
  |  Branch (1058:9): [True: 2, False: 9.06k]
  ------------------
 1059|      2|        return false;
 1060|      2|    }
 1061|  9.06k|    return !!strstr(buf, ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  9.06k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
 1062|  9.07k|}
_ZN12pgp_source_t12is_cleartextEv:
 1066|  15.5k|{
 1067|  15.5k|    char   buf[ARMORED_PEEK_BUF_SIZE] = {0};
 1068|  15.5k|    size_t read = 0;
 1069|       |
 1070|  15.5k|    if (!peek(buf, sizeof(buf) - 1, &read) || (read < strlen(ST_CLEAR_BEGIN))) {
  ------------------
  |  |   48|  15.5k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
  |  Branch (1070:9): [True: 0, False: 15.5k]
  |  Branch (1070:47): [True: 10.8k, False: 4.70k]
  ------------------
 1071|  10.8k|        return false;
 1072|  10.8k|    }
 1073|  4.70k|    buf[read] = 0;
 1074|  4.70k|    return !!strstr(buf, ST_CLEAR_BEGIN);
  ------------------
  |  |   48|  4.70k|#define ST_CLEAR_BEGIN ("-----BEGIN PGP SIGNED MESSAGE-----")
  ------------------
 1075|  15.5k|}
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.17k, False: 494]
  |  Branch (482:31): [True: 4, False: 490]
  ------------------
  483|  1.18k|        return PGP_ARMORED_MESSAGE;
  484|  1.18k|    }
  485|    490|    if ((str == "PUBLIC KEY BLOCK") || (str == "PUBLIC KEY")) {
  ------------------
  |  Branch (485:9): [True: 110, False: 380]
  |  Branch (485:40): [True: 6, False: 374]
  ------------------
  486|    116|        return PGP_ARMORED_PUBLIC_KEY;
  487|    116|    }
  488|    374|    if ((str == "SECRET KEY BLOCK") || (str == "SECRET KEY") || (str == "PRIVATE KEY BLOCK") ||
  ------------------
  |  Branch (488:9): [True: 2, False: 372]
  |  Branch (488:40): [True: 2, False: 370]
  |  Branch (488:65): [True: 6, False: 364]
  ------------------
  489|    364|        (str == "PRIVATE KEY")) {
  ------------------
  |  Branch (489:9): [True: 2, False: 362]
  ------------------
  490|     12|        return PGP_ARMORED_SECRET_KEY;
  491|     12|    }
  492|    362|    if (str == "SIGNATURE") {
  ------------------
  |  Branch (492:9): [True: 38, False: 324]
  ------------------
  493|     38|        return PGP_ARMORED_SIGNATURE;
  494|     38|    }
  495|    324|    return PGP_ARMORED_UNKNOWN;
  496|    362|}
stream-armor.cpp:_ZL17peek_armor_headerR12pgp_source_tPmb:
  563|  1.81k|{
  564|  1.81k|    std::string hdr(ARMORED_PEEK_BUF_SIZE, '\0');
  ------------------
  |  |   46|  1.81k|#define ARMORED_PEEK_BUF_SIZE 1024
  ------------------
  565|  1.81k|    size_t      read = 0;
  566|  1.81k|    if (skip) {
  ------------------
  |  Branch (566:9): [True: 1.81k, False: 0]
  ------------------
  567|  1.81k|        *skip = 0;
  568|  1.81k|    }
  569|  1.81k|    if (!src.peek(&hdr.front(), hdr.size(), &read) || (read < 20)) {
  ------------------
  |  Branch (569:9): [True: 0, False: 1.81k]
  |  Branch (569:55): [True: 4, False: 1.80k]
  ------------------
  570|      4|        return "";
  571|      4|    }
  572|  1.80k|    hdr.resize(read);
  573|       |
  574|  1.80k|    std::string type;
  575|  1.80k|    size_t      armhdrlen = 0;
  576|  1.80k|    size_t      pos = find_armor_header(hdr, armhdrlen, type);
  577|  1.80k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (577:9): [True: 108, False: 1.69k]
  ------------------
  578|    108|        return "";
  579|    108|    }
  580|       |
  581|       |    /* if there are non-whitespaces before the armor header then issue warning */
  582|  2.07k|    for (size_t idx = 0; check && (idx < pos); idx++) {
  ------------------
  |  Branch (582:26): [True: 2.07k, False: 0]
  |  Branch (582:35): [True: 674, False: 1.40k]
  ------------------
  583|    674|        if (B64DEC[(uint8_t) hdr[idx]] != 0xfd) {
  ------------------
  |  Branch (583:13): [True: 298, False: 376]
  ------------------
  584|    298|            RNP_LOG("extra data before the header line");
  ------------------
  |  |   76|    298|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    298|    do {                                                                                 \
  |  |  |  |   69|    298|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 298, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    298|            break;                                                                       \
  |  |  |  |   71|    298|        (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|    298|            break;
  586|    298|        }
  587|    674|    }
  588|       |
  589|  1.69k|    if (skip) {
  ------------------
  |  Branch (589:9): [True: 1.69k, False: 0]
  ------------------
  590|  1.69k|        *skip = armhdrlen;
  591|  1.69k|    }
  592|  1.69k|    return type;
  593|  1.80k|}
stream-armor.cpp:_ZL17find_armor_headerRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERmRS5_:
  464|  1.80k|{
  465|  1.80k|    size_t bg_len = strlen(ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  1.80k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  466|  1.80k|    size_t pos = str.find(ST_ARMOR_BEGIN);
  ------------------
  |  |   46|  1.80k|#define ST_ARMOR_BEGIN ("-----BEGIN PGP ")
  ------------------
  467|  1.80k|    if (pos == std::string::npos) {
  ------------------
  |  Branch (467:9): [True: 0, False: 1.80k]
  ------------------
  468|      0|        return pos;
  469|      0|    }
  470|  1.80k|    size_t end = str.find(ST_DASHES, pos + bg_len);
  ------------------
  |  |   45|  1.80k|#define ST_DASHES ("-----")
  ------------------
  471|  1.80k|    if (end == std::string::npos) {
  ------------------
  |  Branch (471:9): [True: 108, False: 1.69k]
  ------------------
  472|    108|        return end;
  473|    108|    }
  474|  1.69k|    hdrlen = end + 5;
  475|  1.69k|    type.assign(str.begin() + pos + bg_len, str.begin() + end);
  476|  1.69k|    return pos;
  477|  1.80k|}
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: 971, False: 1.61k]
  ------------------
  262|    971|        if (param->restlen - param->restpos >= len) {
  ------------------
  |  Branch (262:13): [True: 0, False: 971]
  ------------------
  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|    971|        } else {
  274|    971|            left = len - (param->restlen - param->restpos);
  275|    971|            memcpy(bufptr, &param->rest[param->restpos], len - left);
  276|    971|            param->restpos = param->restlen = 0;
  277|    971|            bufptr += len - left;
  278|    971|        }
  279|    971|    }
  280|       |
  281|  2.58k|    if (param->eofb64) {
  ------------------
  |  Branch (281:9): [True: 745, False: 1.84k]
  ------------------
  282|    745|        *readres = len - left;
  283|    745|        return true;
  284|    745|    }
  285|       |
  286|  1.84k|    memcpy(decbuf, param->brest, param->brestlen);
  287|  1.84k|    dend = decbuf + param->brestlen;
  288|       |
  289|  14.8k|    do {
  290|  14.8k|        if (!param->readsrc->peek(b64buf, sizeof(b64buf), &read)) {
  ------------------
  |  Branch (290:13): [True: 0, False: 14.8k]
  ------------------
  291|      0|            return false;
  292|      0|        }
  293|  14.8k|        if (!read) {
  ------------------
  |  Branch (293:13): [True: 135, False: 14.7k]
  ------------------
  294|    135|            RNP_LOG("premature end of armored input");
  ------------------
  |  |   76|    135|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    135|    do {                                                                                 \
  |  |  |  |   69|    135|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 135, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    135|            break;                                                                       \
  |  |  |  |   71|    135|        (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|    135|            return false;
  296|    135|        }
  297|       |
  298|  14.7k|        dptr = dend;
  299|  14.7k|        bptr = b64buf;
  300|  14.7k|        bend = b64buf + read;
  301|       |        /* checking input data, stripping away whitespaces, checking for end of the b64 data */
  302|  57.9M|        while (bptr < bend) {
  ------------------
  |  Branch (302:16): [True: 57.9M, False: 14.1k]
  ------------------
  303|  57.9M|            if ((bval = B64DEC[*(bptr++)]) < 64) {
  ------------------
  |  Branch (303:17): [True: 56.2M, False: 1.64M]
  ------------------
  304|  56.2M|                *(dptr++) = bval;
  305|  56.2M|            } else if (bval == 0xfe) {
  ------------------
  |  Branch (305:24): [True: 423, False: 1.64M]
  ------------------
  306|       |                /* '=' means the base64 padding or the beginning of checksum */
  307|    423|                param->eofb64 = true;
  308|    423|                break;
  309|  1.64M|            } else if (bval == 0xff) {
  ------------------
  |  Branch (309:24): [True: 178, False: 1.64M]
  ------------------
  310|    178|                auto ch = *(bptr - 1);
  311|       |                /* OpenPGP message headers without the crc and without trailing = */
  312|    178|                if ((ch == CH_DASH) && !param->noheaders) {
  ------------------
  |  |   34|    178|#define CH_DASH ('-')
  ------------------
  |  Branch (312:21): [True: 128, False: 50]
  |  Branch (312:40): [True: 128, False: 0]
  ------------------
  313|    128|                    param->eofb64 = true;
  314|    128|                    break;
  315|    128|                }
  316|     50|                RNP_LOG("wrong base64 character 0x%02hhX", ch);
  ------------------
  |  |   76|     50|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     50|    do {                                                                                 \
  |  |  |  |   69|     50|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 50, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     50|            break;                                                                       \
  |  |  |  |   71|     50|        (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|     50|                return false;
  318|    178|            }
  319|  57.9M|        }
  320|       |
  321|  14.7k|        dend = dptr;
  322|  14.7k|        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.7k|        if ((size_t)(dend - dptr) / 4 * 3 < left) {
  ------------------
  |  Branch (325:13): [True: 13.6k, False: 1.10k]
  ------------------
  326|  13.6k|            pend = decbuf + (dend - dptr) / 4 * 4;
  327|  13.6k|            left -= (dend - dptr) / 4 * 3;
  328|  13.6k|        } else {
  329|  1.10k|            pend = decbuf + (left / 3) * 4;
  330|  1.10k|            left -= left / 3 * 3;
  331|  1.10k|        }
  332|       |
  333|       |        /* this one would the most performance-consuming part for large chunks */
  334|  13.5M|        while (dptr < pend) {
  ------------------
  |  Branch (334:16): [True: 13.5M, False: 14.7k]
  ------------------
  335|  13.5M|            b24 = *dptr++ << 18;
  336|  13.5M|            b24 |= *dptr++ << 12;
  337|  13.5M|            b24 |= *dptr++ << 6;
  338|  13.5M|            b24 |= *dptr++;
  339|  13.5M|            *bufptr++ = b24 >> 16;
  340|  13.5M|            *bufptr++ = b24 >> 8;
  341|  13.5M|            *bufptr++ = b24 & 0xff;
  342|  13.5M|        }
  343|       |
  344|       |        /* moving rest to the beginning of decbuf */
  345|  14.7k|        memmove(decbuf, dptr, dend - dptr);
  346|  14.7k|        dend = decbuf + (dend - dptr);
  347|       |
  348|       |        /* skip already processed data */
  349|  14.7k|        if (!param->eofb64) {
  ------------------
  |  Branch (349:13): [True: 14.1k, False: 551]
  ------------------
  350|       |            /* all input is base64 data or eol/spaces, so skipping it */
  351|  14.1k|            param->readsrc->skip(read);
  352|       |            /* check for eof for base64-encoded data without headers */
  353|  14.1k|            if (param->noheaders && param->readsrc->eof()) {
  ------------------
  |  Branch (353:17): [True: 0, False: 14.1k]
  |  Branch (353:37): [True: 0, False: 0]
  ------------------
  354|      0|                param->readsrc->skip(read);
  355|      0|                param->eofb64 = true;
  356|  14.1k|            } else {
  357|  14.1k|                continue;
  358|  14.1k|            }
  359|  14.1k|        } else {
  360|       |            /* '=' reached, bptr points on it */
  361|    551|            param->readsrc->skip(bptr - b64buf - 1);
  362|    551|        }
  363|       |
  364|       |        /* end of base64 data */
  365|    551|        if (param->noheaders) {
  ------------------
  |  Branch (365:13): [True: 0, False: 551]
  ------------------
  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|    551|        if (!armor_read_padding(*param->readsrc, &eqcount)) {
  ------------------
  |  Branch (372:13): [True: 64, False: 487]
  ------------------
  373|     64|            RNP_LOG("wrong padding");
  ------------------
  |  |   76|     64|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     64|    do {                                                                                 \
  |  |  |  |   69|     64|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     64|            break;                                                                       \
  |  |  |  |   71|     64|        (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|     64|            return false;
  375|     64|        }
  376|       |        /* reading crc */
  377|    487|        if (!armor_read_crc(param)) {
  ------------------
  |  Branch (377:13): [True: 346, False: 141]
  ------------------
  378|    346|            RNP_LOG("Warning: missing or malformed CRC line");
  ------------------
  |  |   76|    346|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    346|    do {                                                                                 \
  |  |  |  |   69|    346|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 346, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    346|            break;                                                                       \
  |  |  |  |   71|    346|        (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|    346|        }
  380|       |        /* reading armor trailing line */
  381|    487|        if (!armor_read_trailer(param)) {
  ------------------
  |  Branch (381:13): [True: 144, False: 343]
  ------------------
  382|    144|            RNP_LOG("wrong armor trailer");
  ------------------
  |  |   76|    144|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    144|    do {                                                                                 \
  |  |  |  |   69|    144|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 144, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    144|            break;                                                                       \
  |  |  |  |   71|    144|        (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|    144|            return false;
  384|    144|        }
  385|    343|        break;
  386|  14.1k|    } while (left >= 3);
  ------------------
  |  Branch (386:14): [True: 13.0k, False: 1.10k]
  ------------------
  387|       |
  388|       |    /* process bytes left in decbuf */
  389|       |
  390|  1.44k|    dptr = decbuf;
  391|  1.44k|    pend = decbuf + (dend - decbuf) / 4 * 4;
  392|  1.44k|    bptr = param->rest;
  393|   523k|    while (dptr < pend) {
  ------------------
  |  Branch (393:12): [True: 522k, False: 1.44k]
  ------------------
  394|   522k|        b24 = *dptr++ << 18;
  395|   522k|        b24 |= *dptr++ << 12;
  396|   522k|        b24 |= *dptr++ << 6;
  397|   522k|        b24 |= *dptr++;
  398|   522k|        *bptr++ = b24 >> 16;
  399|   522k|        *bptr++ = b24 >> 8;
  400|   522k|        *bptr++ = b24 & 0xff;
  401|   522k|    }
  402|       |
  403|  1.44k|    if (!armored_update_crc(param, buf, bufptr - (uint8_t *) buf)) {
  ------------------
  |  Branch (403:9): [True: 0, False: 1.44k]
  ------------------
  404|      0|        return false;
  405|      0|    }
  406|       |
  407|  1.44k|    if (param->eofb64) {
  ------------------
  |  Branch (407:9): [True: 343, False: 1.10k]
  ------------------
  408|    343|        if ((dend - dptr + eqcount) % 4 != 0) {
  ------------------
  |  Branch (408:13): [True: 72, False: 271]
  ------------------
  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|    271|        if (eqcount == 1) {
  ------------------
  |  Branch (413:13): [True: 99, False: 172]
  ------------------
  414|     99|            b24 = (*dptr << 10) | (*(dptr + 1) << 4) | (*(dptr + 2) >> 2);
  415|     99|            *bptr++ = b24 >> 8;
  416|     99|            *bptr++ = b24 & 0xff;
  417|    172|        } else if (eqcount == 2) {
  ------------------
  |  Branch (417:20): [True: 31, False: 141]
  ------------------
  418|     31|            *bptr++ = (*dptr << 2) | (*(dptr + 1) >> 4);
  419|     31|        }
  420|       |
  421|       |        /* Calculate CRC after reading whole input stream */
  422|    271|        if (!armored_update_crc(param, param->rest, bptr - param->rest, true)) {
  ------------------
  |  Branch (422:13): [True: 0, False: 271]
  ------------------
  423|      0|            return false;
  424|      0|        }
  425|  1.10k|    } else {
  426|       |        /* few bytes which do not fit to 4 boundary */
  427|  2.82k|        for (int i = 0; i < dend - dptr; i++) {
  ------------------
  |  Branch (427:25): [True: 1.71k, False: 1.10k]
  ------------------
  428|  1.71k|            param->brest[i] = *(dptr + i);
  429|  1.71k|        }
  430|  1.10k|        param->brestlen = dend - dptr;
  431|  1.10k|    }
  432|       |
  433|  1.37k|    param->restlen = bptr - param->rest;
  434|       |
  435|       |    /* check whether we have some bytes to add */
  436|  1.37k|    if ((left > 0) && (param->restlen > 0)) {
  ------------------
  |  Branch (436:9): [True: 1.07k, False: 299]
  |  Branch (436:23): [True: 915, False: 162]
  ------------------
  437|    915|        read = left > param->restlen ? param->restlen : left;
  ------------------
  |  Branch (437:16): [True: 117, False: 798]
  ------------------
  438|    915|        memcpy(bufptr, param->rest, read);
  439|    915|        if (!param->eofb64 && !armored_update_crc(param, bufptr, read)) {
  ------------------
  |  Branch (439:13): [True: 783, False: 132]
  |  Branch (439:31): [True: 0, False: 783]
  ------------------
  440|      0|            return false;
  441|      0|        }
  442|    915|        left -= read;
  443|    915|        param->restpos += read;
  444|    915|    }
  445|       |
  446|  1.37k|    *readres = len - left;
  447|  1.37k|    return true;
  448|  1.37k|}
stream-armor.cpp:_ZL18armor_read_paddingR12pgp_source_tPm:
  106|    551|{
  107|    551|    char   st[64];
  108|    551|    size_t stlen = 0;
  109|       |
  110|    551|    if (!src.peek_line(st, 64, &stlen)) {
  ------------------
  |  Branch (110:9): [True: 10, False: 541]
  ------------------
  111|     10|        return false;
  112|     10|    }
  113|       |
  114|    541|    if ((stlen == 1) || (stlen == 2)) {
  ------------------
  |  Branch (114:9): [True: 203, False: 338]
  |  Branch (114:25): [True: 68, False: 270]
  ------------------
  115|    271|        if ((st[0] != CH_EQ) || ((stlen == 2) && (st[1] != CH_EQ))) {
  ------------------
  |  |   33|    271|#define CH_EQ ('=')
  ------------------
                      if ((st[0] != CH_EQ) || ((stlen == 2) && (st[1] != CH_EQ))) {
  ------------------
  |  |   33|     65|#define CH_EQ ('=')
  ------------------
  |  Branch (115:13): [True: 6, False: 265]
  |  Branch (115:34): [True: 65, False: 200]
  |  Branch (115:50): [True: 17, False: 48]
  ------------------
  116|     23|            return false;
  117|     23|        }
  118|       |
  119|    248|        *read = stlen;
  120|    248|        src.skip(stlen);
  121|    248|        return src.skip_eol();
  122|    271|    } else if (stlen == 5) {
  ------------------
  |  Branch (122:16): [True: 141, False: 129]
  ------------------
  123|    141|        *read = 0;
  124|    141|        return true;
  125|    141|    } else if ((stlen > 5) && !memcmp(st, ST_DASHES, 5)) {
  ------------------
  |  |   45|    121|#define ST_DASHES ("-----")
  ------------------
  |  Branch (125:16): [True: 121, False: 8]
  |  Branch (125:31): [True: 98, False: 23]
  ------------------
  126|       |        /* case with absent crc and 3-byte last chunk */
  127|     98|        *read = 0;
  128|     98|        return true;
  129|     98|    }
  130|     31|    return false;
  131|    541|}
stream-armor.cpp:_ZL14armor_read_crcP26pgp_source_armored_param_t:
  167|    487|{
  168|    487|    uint8_t dec[4] = {0};
  169|    487|    char    crc[8] = {0};
  170|    487|    size_t  clen = 0;
  171|       |
  172|    487|    if (!param->readsrc->peek_line(crc, sizeof(crc), &clen)) {
  ------------------
  |  Branch (172:9): [True: 308, False: 179]
  ------------------
  173|    308|        return false;
  174|    308|    }
  175|       |
  176|    179|    if ((clen != 5) || (crc[0] != CH_EQ)) {
  ------------------
  |  |   33|    165|#define CH_EQ ('=')
  ------------------
  |  Branch (176:9): [True: 14, False: 165]
  |  Branch (176:24): [True: 7, False: 158]
  ------------------
  177|     21|        return false;
  178|     21|    }
  179|       |
  180|    746|    for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (180:21): [True: 605, False: 141]
  ------------------
  181|    605|        if ((dec[i] = B64DEC[(uint8_t) crc[i + 1]]) >= 64) {
  ------------------
  |  Branch (181:13): [True: 17, False: 588]
  ------------------
  182|     17|            return false;
  183|     17|        }
  184|    605|    }
  185|       |
  186|    141|    param->readcrc[0] = (dec[0] << 2) | ((dec[1] >> 4) & 0x0F);
  187|    141|    param->readcrc[1] = (dec[1] << 4) | ((dec[2] >> 2) & 0x0F);
  188|    141|    param->readcrc[2] = (dec[2] << 6) | dec[3];
  189|       |
  190|    141|    param->has_crc = true;
  191|       |
  192|    141|    param->readsrc->skip(5);
  193|    141|    return param->readsrc->skip_eol();
  194|    158|}
stream-armor.cpp:_ZL18armor_read_trailerP26pgp_source_armored_param_t:
  198|    487|{
  199|       |    /* Space or tab could get between armor and trailer, see issue #2199 */
  200|    487|    if (!param->readsrc->skip_chars("\r\n \t")) {
  ------------------
  |  Branch (200:9): [True: 0, False: 487]
  ------------------
  201|      0|        return false;
  202|      0|    }
  203|       |
  204|    487|    std::string st = ST_ARMOR_END + param->armorhdr + ST_DASHES;
  ------------------
  |  |   47|  1.46k|#define ST_ARMOR_END ("-----END PGP ")
  ------------------
                  std::string st = ST_ARMOR_END + param->armorhdr + ST_DASHES;
  ------------------
  |  |   45|    487|#define ST_DASHES ("-----")
  ------------------
  205|    487|    std::string str(st.size(), 0);
  206|    487|    if (!param->readsrc->peek_eq(&str.front(), str.size()) || (st != str)) {
  ------------------
  |  Branch (206:9): [True: 91, False: 396]
  |  Branch (206:63): [True: 53, False: 343]
  ------------------
  207|    144|        return false;
  208|    144|    }
  209|    343|    param->readsrc->skip(st.size());
  210|    343|    (void) param->readsrc->skip_chars("\t ");
  211|    343|    (void) param->readsrc->skip_eol();
  212|    343|    return true;
  213|    487|}
stream-armor.cpp:_ZL18armored_update_crcP26pgp_source_armored_param_tPKvmb:
  220|  2.50k|{
  221|  2.50k|    if (param->noheaders) {
  ------------------
  |  Branch (221:9): [True: 0, False: 2.50k]
  ------------------
  222|      0|        return true;
  223|      0|    }
  224|  2.50k|    try {
  225|  2.50k|        param->crc_ctx->add(buf, len);
  226|  2.50k|        if (!finish) {
  ------------------
  |  Branch (226:13): [True: 2.23k, False: 271]
  ------------------
  227|  2.23k|            return true;
  228|  2.23k|        }
  229|    271|        auto crc = param->crc_ctx->finish();
  230|    271|        if (param->has_crc && memcmp(param->readcrc, crc.data(), 3)) {
  ------------------
  |  Branch (230:13): [True: 123, False: 148]
  |  Branch (230:31): [True: 121, False: 2]
  ------------------
  231|    121|            RNP_LOG("Warning: CRC mismatch");
  ------------------
  |  |   76|    121|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    121|    do {                                                                                 \
  |  |  |  |   69|    121|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 121, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    121|            break;                                                                       \
  |  |  |  |   71|    121|        (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|    121|        }
  233|    271|        return true;
  234|  2.50k|    } 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.50k|}
stream-armor.cpp:_ZL17armored_src_closeP12pgp_source_t:
  452|  2.81k|{
  453|  2.81k|    auto param = (pgp_source_armored_param_t *) src->param;
  454|  2.81k|    delete param;
  455|       |    src->param = NULL;
  456|  2.81k|}
stream-armor.cpp:_ZL18armor_parse_headerP26pgp_source_armored_param_t:
  607|  1.81k|{
  608|  1.81k|    size_t      skip = 0;
  609|  1.81k|    std::string hdr = peek_armor_header(*param->readsrc, &skip, true);
  610|  1.81k|    if (hdr.empty()) {
  ------------------
  |  Branch (610:9): [True: 138, False: 1.67k]
  ------------------
  611|    138|        RNP_LOG("no armor header");
  ------------------
  |  |   76|    138|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    138|    do {                                                                                 \
  |  |  |  |   69|    138|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 138, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    138|            break;                                                                       \
  |  |  |  |   71|    138|        (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|    138|        return false;
  613|    138|    }
  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: 324, False: 1.34k]
  ------------------
  617|    324|        RNP_LOG("unknown armor header");
  ------------------
  |  |   76|    324|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    324|    do {                                                                                 \
  |  |  |  |   69|    324|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 324, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    324|            break;                                                                       \
  |  |  |  |   71|    324|        (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|    324|        return false;
  619|    324|    }
  620|       |
  621|  1.34k|    param->armorhdr = std::move(hdr);
  622|  1.34k|    param->readsrc->skip(skip);
  623|  1.34k|    param->readsrc->skip_chars("\t ");
  624|  1.34k|    return true;
  625|  1.67k|}
stream-armor.cpp:_ZL19armor_parse_headersP26pgp_source_armored_param_t:
  662|  1.28k|{
  663|  1.28k|    std::vector<char> header(ARMORED_PEEK_BUF_SIZE, '\0');
  ------------------
  |  |   46|  1.28k|#define ARMORED_PEEK_BUF_SIZE 1024
  ------------------
  664|       |
  665|  11.7k|    do {
  666|  11.7k|        size_t hdrlen = 0;
  667|  11.7k|        if (!param->readsrc->peek_line(header.data(), header.size(), &hdrlen)) {
  ------------------
  |  Branch (667:13): [True: 1.35k, False: 10.4k]
  ------------------
  668|       |            /* if line is too long let's cut it to the reasonable size */
  669|  1.35k|            param->readsrc->skip(hdrlen);
  670|  1.35k|            if ((hdrlen != header.size() - 1) || !armor_skip_line(*param->readsrc)) {
  ------------------
  |  Branch (670:17): [True: 438, False: 920]
  |  Branch (670:50): [True: 34, False: 886]
  ------------------
  671|    472|                RNP_LOG("failed to peek line: unexpected end of data");
  ------------------
  |  |   76|    472|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    472|    do {                                                                                 \
  |  |  |  |   69|    472|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 472, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    472|            break;                                                                       \
  |  |  |  |   71|    472|        (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|    472|                return false;
  673|    472|            }
  674|    886|            RNP_LOG("Too long armor header - truncated.");
  ------------------
  |  |   76|    886|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    886|    do {                                                                                 \
  |  |  |  |   69|    886|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 886, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    886|            break;                                                                       \
  |  |  |  |   71|    886|        (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|  10.4k|        } else if (hdrlen) {
  ------------------
  |  Branch (675:20): [True: 10.0k, False: 426]
  ------------------
  676|  10.0k|            if (is_base64_line(header.data(), hdrlen)) {
  ------------------
  |  Branch (676:17): [True: 382, False: 9.63k]
  ------------------
  677|    382|                RNP_LOG("Warning: no empty line after the base64 headers");
  ------------------
  |  |   76|    382|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    382|    do {                                                                                 \
  |  |  |  |   69|    382|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 382, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    382|            break;                                                                       \
  |  |  |  |   71|    382|        (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|    382|                return true;
  679|    382|            }
  680|  9.63k|            param->readsrc->skip(hdrlen);
  681|  9.63k|            if (rnp::is_blank_line(header.data(), hdrlen)) {
  ------------------
  |  Branch (681:17): [True: 0, False: 9.63k]
  ------------------
  682|      0|                return param->readsrc->skip_eol();
  683|      0|            }
  684|  9.63k|        } else {
  685|       |            /* empty line - end of the headers */
  686|    426|            return param->readsrc->skip_eol();
  687|    426|        }
  688|       |
  689|  10.5k|        std::string hdrst(header.begin(), header.begin() + hdrlen);
  690|  10.5k|        size_t      pos = hdrst.find(": ");
  691|  10.5k|        if ((pos != std::string::npos) && armor_header_known(hdrst.substr(0, pos + 2))) {
  ------------------
  |  Branch (691:13): [True: 5.51k, False: 4.99k]
  |  Branch (691:13): [True: 2.23k, False: 8.28k]
  |  Branch (691:43): [True: 2.23k, False: 3.28k]
  ------------------
  692|       |            // do nothing at the moment, just check whether header is known
  693|  8.28k|        } else {
  694|  8.28k|            RNP_LOG("unknown header '%s'", hdrst.c_str());
  ------------------
  |  |   76|  8.28k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  8.28k|    do {                                                                                 \
  |  |  |  |   69|  8.28k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 8.28k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  8.28k|            break;                                                                       \
  |  |  |  |   71|  8.28k|        (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|  8.28k|        }
  696|       |
  697|  10.5k|        if (!param->readsrc->skip_eol()) {
  ------------------
  |  Branch (697:13): [True: 0, False: 10.5k]
  ------------------
  698|      0|            return false;
  699|      0|        }
  700|  10.5k|    } while (1);
  ------------------
  |  Branch (700:14): [True: 10.5k, Folded]
  ------------------
  701|  1.28k|}
stream-armor.cpp:_ZL15armor_skip_lineR12pgp_source_t:
  629|    920|{
  630|    920|    char header[ARMORED_PEEK_BUF_SIZE] = {0};
  631|  2.04k|    do {
  632|  2.04k|        size_t hdrlen = 0;
  633|  2.04k|        bool   res = src.peek_line(header, sizeof(header), &hdrlen);
  634|  2.04k|        if (hdrlen) {
  ------------------
  |  Branch (634:13): [True: 1.50k, False: 540]
  ------------------
  635|  1.50k|            src.skip(hdrlen);
  636|  1.50k|        }
  637|  2.04k|        if (res || (hdrlen < sizeof(header) - 1)) {
  ------------------
  |  Branch (637:13): [True: 886, False: 1.15k]
  |  Branch (637:20): [True: 34, False: 1.12k]
  ------------------
  638|    920|            return res;
  639|    920|        }
  640|  2.04k|    } while (1);
  ------------------
  |  Branch (640:14): [True: 1.12k, Folded]
  ------------------
  641|    920|}
stream-armor.cpp:_ZL18armor_header_knownRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  655|  5.51k|{
  656|  5.51k|    return (name == ST_HEADER_VERSION) || (name == ST_HEADER_COMMENT) ||
  ------------------
  |  |   50|  5.51k|#define ST_HEADER_VERSION ("Version: ")
  ------------------
                  return (name == ST_HEADER_VERSION) || (name == ST_HEADER_COMMENT) ||
  ------------------
  |  |   51|  4.81k|#define ST_HEADER_COMMENT ("Comment: ")
  ------------------
  |  Branch (656:12): [True: 708, False: 4.81k]
  |  Branch (656:43): [True: 560, False: 4.25k]
  ------------------
  657|  4.25k|           (name == ST_HEADER_CHARSET) || (name == ST_HEADER_HASH);
  ------------------
  |  |   53|  4.25k|#define ST_HEADER_CHARSET ("Charset: ")
  ------------------
                         (name == ST_HEADER_CHARSET) || (name == ST_HEADER_HASH);
  ------------------
  |  |   52|  3.66k|#define ST_HEADER_HASH ("Hash: ")
  ------------------
  |  Branch (657:12): [True: 590, False: 3.66k]
  |  Branch (657:43): [True: 376, False: 3.28k]
  ------------------
  658|  5.51k|}
stream-armor.cpp:_ZL14is_base64_linePKcm:
  645|  10.0k|{
  646|  69.4k|    for (size_t i = 0; i < len && line[i]; i++) {
  ------------------
  |  Branch (646:24): [True: 69.0k, False: 344]
  |  Branch (646:35): [True: 69.0k, False: 38]
  ------------------
  647|  69.0k|        if (B64DEC[(uint8_t) line[i]] == 0xff)
  ------------------
  |  Branch (647:13): [True: 9.63k, False: 59.4k]
  ------------------
  648|  9.63k|            return false;
  649|  69.0k|    }
  650|    382|    return true;
  651|  10.0k|}

_ZN12pgp_source_t4readEPvmPm:
   57|  49.0M|{
   58|  49.0M|    size_t left = len;
   59|  49.0M|    size_t read;
   60|  49.0M|    bool   readahead = cache ? cache->readahead : false;
  ------------------
  |  Branch (60:24): [True: 49.0M, False: 0]
  ------------------
   61|       |
   62|  49.0M|    if (error_) {
  ------------------
  |  Branch (62:9): [True: 80, False: 49.0M]
  ------------------
   63|     80|        return false;
   64|     80|    }
   65|       |
   66|  49.0M|    if (eof_ || (len == 0)) {
  ------------------
  |  Branch (66:9): [True: 49.3k, False: 48.9M]
  |  Branch (66:17): [True: 0, False: 48.9M]
  ------------------
   67|  49.3k|        *readres = 0;
   68|  49.3k|        return true;
   69|  49.3k|    }
   70|       |
   71|       |    // Do not read more then available if source size is known
   72|  48.9M|    if (knownsize && (readb + len > size)) {
  ------------------
  |  Branch (72:9): [True: 135k, False: 48.8M]
  |  Branch (72:22): [True: 10.2k, False: 125k]
  ------------------
   73|  10.2k|        len = size - readb;
   74|  10.2k|        left = len;
   75|  10.2k|        readahead = false;
   76|  10.2k|    }
   77|       |
   78|       |    // Check whether we have cache and there is data inside
   79|  48.9M|    if (cache && (cache->len > cache->pos)) {
  ------------------
  |  Branch (79:9): [True: 48.9M, False: 0]
  |  Branch (79:18): [True: 48.9M, False: 12.4k]
  ------------------
   80|  48.9M|        read = cache->len - cache->pos;
   81|  48.9M|        if (read >= len) {
  ------------------
  |  Branch (81:13): [True: 47.5M, False: 1.35M]
  ------------------
   82|  47.5M|            memcpy(buf, &cache->buf[cache->pos], len);
   83|  47.5M|            cache->pos += len;
   84|  47.5M|            goto finish;
   85|  47.5M|        } else {
   86|  1.35M|            memcpy(buf, &cache->buf[cache->pos], read);
   87|  1.35M|            cache->pos += read;
   88|  1.35M|            buf = (uint8_t *) buf + read;
   89|  1.35M|            left = len - read;
   90|  1.35M|        }
   91|  48.9M|    }
   92|       |
   93|       |    // If we got here then we have empty cache or no cache at all
   94|  1.36M|    while (left > 0) {
  ------------------
  |  Branch (94:12): [True: 1.36M, False: 917]
  ------------------
   95|  1.36M|        if (left > sizeof(cache->buf) || !readahead || !cache) {
  ------------------
  |  Branch (95:13): [True: 1.19k, False: 1.36M]
  |  Branch (95:42): [True: 173, False: 1.36M]
  |  Branch (95:56): [True: 0, False: 1.36M]
  ------------------
   96|       |            // If there is no cache or chunk is larger then read directly
   97|  1.36k|            if (!raw_read(this, buf, left, &read)) {
  ------------------
  |  Branch (97:17): [True: 84, False: 1.28k]
  ------------------
   98|     84|                error_ = 1;
   99|     84|                return false;
  100|     84|            }
  101|  1.28k|            if (!read) {
  ------------------
  |  Branch (101:17): [True: 375, False: 909]
  ------------------
  102|    375|                eof_ = true;
  103|    375|                len = len - left;
  104|    375|                goto finish;
  105|    375|            }
  106|    909|            left -= read;
  107|    909|            buf = (uint8_t *) buf + read;
  108|  1.36M|        } else {
  109|       |            // Try to fill the cache to avoid small reads
  110|  1.36M|            if (!raw_read(this, &cache->buf[0], sizeof(cache->buf), &read)) {
  ------------------
  |  Branch (110:17): [True: 1.17k, False: 1.36M]
  ------------------
  111|  1.17k|                error_ = true;
  112|  1.17k|                return false;
  113|  1.17k|            }
  114|  1.36M|            if (!read) {
  ------------------
  |  Branch (114:17): [True: 18.3k, False: 1.34M]
  ------------------
  115|  18.3k|                eof_ = true;
  116|  18.3k|                len = len - left;
  117|  18.3k|                goto finish;
  118|  1.34M|            } else if (read < left) {
  ------------------
  |  Branch (118:24): [True: 106, False: 1.34M]
  ------------------
  119|    106|                memcpy(buf, &cache->buf[0], read);
  120|    106|                left -= read;
  121|    106|                buf = (uint8_t *) buf + read;
  122|  1.34M|            } else {
  123|  1.34M|                memcpy(buf, &cache->buf[0], left);
  124|  1.34M|                cache->pos = left;
  125|  1.34M|                cache->len = read;
  126|  1.34M|                goto finish;
  127|  1.34M|            }
  128|  1.36M|        }
  129|  1.36M|    }
  130|       |
  131|  48.9M|finish:
  132|  48.9M|    readb += len;
  133|  48.9M|    if (knownsize && (readb == size)) {
  ------------------
  |  Branch (133:9): [True: 135k, False: 48.8M]
  |  Branch (133:22): [True: 13.0k, False: 122k]
  ------------------
  134|  13.0k|        eof_ = true;
  135|  13.0k|    }
  136|  48.9M|    *readres = len;
  137|  48.9M|    return true;
  138|  1.36M|}
_ZN12pgp_source_t7read_eqEPvm:
  142|  22.7M|{
  143|  22.7M|    size_t res = 0;
  144|  22.7M|    return read(buf, len, &res) && (res == len);
  ------------------
  |  Branch (144:12): [True: 22.7M, False: 251]
  |  Branch (144:36): [True: 22.7M, False: 1.54k]
  ------------------
  145|  22.7M|}
_ZN12pgp_source_t4peekEPvmPm:
  149|  5.28M|{
  150|  5.28M|    if (error_) {
  ------------------
  |  Branch (150:9): [True: 6.30k, False: 5.27M]
  ------------------
  151|  6.30k|        return false;
  152|  6.30k|    }
  153|  5.27M|    if (!cache || (len > sizeof(cache->buf))) {
  ------------------
  |  Branch (153:9): [True: 0, False: 5.27M]
  |  Branch (153:19): [True: 0, False: 5.27M]
  ------------------
  154|      0|        return false;
  155|      0|    }
  156|  5.27M|    if (eof_) {
  ------------------
  |  Branch (156:9): [True: 0, False: 5.27M]
  ------------------
  157|      0|        *peeked = 0;
  158|      0|        return true;
  159|      0|    }
  160|       |
  161|  5.27M|    size_t read = 0;
  162|  5.27M|    bool   readahead = cache->readahead;
  163|       |    // Do not read more then available if source size is known
  164|  5.27M|    if (knownsize && (readb + len > size)) {
  ------------------
  |  Branch (164:9): [True: 458k, False: 4.82M]
  |  Branch (164:22): [True: 51.6k, False: 406k]
  ------------------
  165|  51.6k|        len = size - readb;
  166|  51.6k|        readahead = false;
  167|  51.6k|    }
  168|       |
  169|  5.27M|    if (cache->len - cache->pos >= len) {
  ------------------
  |  Branch (169:9): [True: 4.54M, False: 734k]
  ------------------
  170|  4.54M|        if (buf) {
  ------------------
  |  Branch (170:13): [True: 4.54M, False: 0]
  ------------------
  171|  4.54M|            memcpy(buf, &cache->buf[cache->pos], len);
  172|  4.54M|        }
  173|  4.54M|        *peeked = len;
  174|  4.54M|        return true;
  175|  4.54M|    }
  176|       |
  177|   734k|    if (cache->pos > 0) {
  ------------------
  |  Branch (177:9): [True: 688k, False: 45.8k]
  ------------------
  178|   688k|        memmove(&cache->buf[0], &cache->buf[cache->pos], cache->len - cache->pos);
  179|   688k|        cache->len -= cache->pos;
  180|   688k|        cache->pos = 0;
  181|   688k|    }
  182|       |
  183|   734k|    while (cache->len < len) {
  ------------------
  |  Branch (183:12): [True: 734k, False: 0]
  ------------------
  184|   734k|        read = readahead ? sizeof(cache->buf) - cache->len : len - cache->len;
  ------------------
  |  Branch (184:16): [True: 719k, False: 14.5k]
  ------------------
  185|   734k|        if (knownsize && (readb + read > size)) {
  ------------------
  |  Branch (185:13): [True: 19.6k, False: 714k]
  |  Branch (185:26): [True: 1.14k, False: 18.5k]
  ------------------
  186|  1.14k|            read = size - readb;
  187|  1.14k|        }
  188|   734k|        if (!raw_read(this, &cache->buf[cache->len], read, &read)) {
  ------------------
  |  Branch (188:13): [True: 1.67k, False: 732k]
  ------------------
  189|  1.67k|            error_ = true;
  190|  1.67k|            return false;
  191|  1.67k|        }
  192|   732k|        if (!read) {
  ------------------
  |  Branch (192:13): [True: 135k, False: 597k]
  ------------------
  193|   135k|            if (buf) {
  ------------------
  |  Branch (193:17): [True: 135k, False: 0]
  ------------------
  194|   135k|                memcpy(buf, &cache->buf[0], cache->len);
  195|   135k|            }
  196|   135k|            *peeked = cache->len;
  197|   135k|            return true;
  198|   135k|        }
  199|   597k|        cache->len += read;
  200|   597k|        if (cache->len >= len) {
  ------------------
  |  Branch (200:13): [True: 597k, False: 46]
  ------------------
  201|   597k|            if (buf) {
  ------------------
  |  Branch (201:17): [True: 597k, False: 0]
  ------------------
  202|   597k|                memcpy(buf, cache->buf, len);
  203|   597k|            }
  204|   597k|            *peeked = len;
  205|   597k|            return true;
  206|   597k|        }
  207|   597k|    }
  208|      0|    return false;
  209|   734k|}
_ZN12pgp_source_t7peek_eqEPvm:
  213|  3.18M|{
  214|  3.18M|    size_t res = 0;
  215|  3.18M|    return peek(buf, len, &res) && (res == len);
  ------------------
  |  Branch (215:12): [True: 3.17M, False: 3.81k]
  |  Branch (215:36): [True: 3.17M, False: 2.91k]
  ------------------
  216|  3.18M|}
_ZN12pgp_source_t4skipEm:
  220|  65.6k|{
  221|  65.6k|    if (cache && (cache->len - cache->pos >= len)) {
  ------------------
  |  Branch (221:9): [True: 65.6k, False: 0]
  |  Branch (221:18): [True: 65.6k, False: 0]
  ------------------
  222|  65.6k|        readb += len;
  223|  65.6k|        cache->pos += len;
  224|  65.6k|        return;
  225|  65.6k|    }
  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.69M|{
  270|  1.69M|    if (eof_) {
  ------------------
  |  Branch (270:9): [True: 19.9k, False: 1.67M]
  ------------------
  271|  19.9k|        return true;
  272|  19.9k|    }
  273|       |    /* Error on stream read is NOT considered as eof. See error(). */
  274|  1.67M|    uint8_t check;
  275|  1.67M|    size_t  read = 0;
  276|  1.67M|    return peek(&check, 1, &read) && (read == 0);
  ------------------
  |  Branch (276:12): [True: 1.66M, False: 3.70k]
  |  Branch (276:38): [True: 759, False: 1.66M]
  ------------------
  277|  1.69M|}
_ZN12pgp_source_t5closeEv:
  281|  52.6k|{
  282|  52.6k|    if (raw_close) {
  ------------------
  |  Branch (282:9): [True: 52.6k, False: 0]
  ------------------
  283|  52.6k|        raw_close(this);
  284|  52.6k|    }
  285|       |
  286|  52.6k|    if (cache) {
  ------------------
  |  Branch (286:9): [True: 49.6k, False: 3.02k]
  ------------------
  287|  49.6k|        free(cache);
  288|       |        cache = NULL;
  289|  49.6k|    }
  290|  52.6k|}
_ZN12pgp_source_t8skip_eolEv:
  294|  13.0k|{
  295|  13.0k|    uint8_t eol[2];
  296|  13.0k|    size_t  read;
  297|       |
  298|  13.0k|    if (!peek(eol, 2, &read) || !read) {
  ------------------
  |  Branch (298:9): [True: 0, False: 13.0k]
  |  Branch (298:33): [True: 225, False: 12.7k]
  ------------------
  299|    225|        return false;
  300|    225|    }
  301|  12.7k|    if (eol[0] == '\n') {
  ------------------
  |  Branch (301:9): [True: 11.6k, False: 1.17k]
  ------------------
  302|  11.6k|        skip(1);
  303|  11.6k|        return true;
  304|  11.6k|    }
  305|  1.17k|    if ((read == 2) && (eol[0] == '\r') && (eol[1] == '\n')) {
  ------------------
  |  Branch (305:9): [True: 1.15k, False: 15]
  |  Branch (305:24): [True: 1.07k, False: 84]
  |  Branch (305:44): [True: 1.03k, False: 35]
  ------------------
  306|  1.03k|        skip(2);
  307|  1.03k|        return true;
  308|  1.03k|    }
  309|    134|    return false;
  310|  1.17k|}
_ZN12pgp_source_t10skip_charsERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  314|  2.17k|{
  315|  2.93k|    do {
  316|  2.93k|        char   ch = 0;
  317|  2.93k|        size_t read = 0;
  318|  2.93k|        if (!peek(&ch, 1, &read)) {
  ------------------
  |  Branch (318:13): [True: 0, False: 2.93k]
  ------------------
  319|      0|            return false;
  320|      0|        }
  321|  2.93k|        if (!read) {
  ------------------
  |  Branch (321:13): [True: 264, False: 2.67k]
  ------------------
  322|       |            /* return true only if there is no underlying read error */
  323|    264|            return true;
  324|    264|        }
  325|  2.67k|        if (chars.find(ch) == std::string::npos) {
  ------------------
  |  Branch (325:13): [True: 1.91k, False: 760]
  ------------------
  326|  1.91k|            return true;
  327|  1.91k|        }
  328|    760|        skip(1);
  329|    760|    } while (1);
  ------------------
  |  Branch (329:14): [True: 760, Folded]
  ------------------
  330|  2.17k|}
_ZN12pgp_source_t9peek_lineEPcmPm:
  334|  14.8k|{
  335|  14.8k|    size_t scan_pos = 0;
  336|  14.8k|    size_t inc = 64;
  337|  14.8k|    len = len - 1;
  338|       |
  339|  25.6k|    do {
  340|  25.6k|        size_t to_peek = scan_pos + inc;
  341|  25.6k|        to_peek = to_peek > len ? len : to_peek;
  ------------------
  |  Branch (341:19): [True: 3.12k, False: 22.4k]
  ------------------
  342|  25.6k|        inc = inc * 2;
  343|       |
  344|       |        /* inefficient, each time we again read from the beginning */
  345|  25.6k|        if (!peek(buf, to_peek, readres)) {
  ------------------
  |  Branch (345:13): [True: 0, False: 25.6k]
  ------------------
  346|      0|            return false;
  347|      0|        }
  348|       |
  349|       |        /* we continue scanning where we stopped previously */
  350|  2.68M|        for (; scan_pos < *readres; scan_pos++) {
  ------------------
  |  Branch (350:16): [True: 2.66M, False: 13.5k]
  ------------------
  351|  2.66M|            if (buf[scan_pos] == '\n') {
  ------------------
  |  Branch (351:17): [True: 12.0k, False: 2.65M]
  ------------------
  352|  12.0k|                if ((scan_pos > 0) && (buf[scan_pos - 1] == '\r')) {
  ------------------
  |  Branch (352:21): [True: 11.1k, False: 861]
  |  Branch (352:39): [True: 935, False: 10.2k]
  ------------------
  353|    935|                    scan_pos--;
  354|    935|                }
  355|  12.0k|                buf[scan_pos] = '\0';
  356|  12.0k|                *readres = scan_pos;
  357|  12.0k|                return true;
  358|  12.0k|            }
  359|  2.66M|        }
  360|  13.5k|        if (*readres < to_peek) {
  ------------------
  |  Branch (360:13): [True: 511, False: 13.0k]
  ------------------
  361|    511|            return false;
  362|    511|        }
  363|  13.5k|    } while (scan_pos < len);
  ------------------
  |  Branch (363:14): [True: 10.7k, False: 2.32k]
  ------------------
  364|  2.32k|    return false;
  365|  14.8k|}
_Z15init_src_commonP12pgp_source_tm:
  369|  49.6k|{
  370|  49.6k|    memset(src, 0, sizeof(*src));
  371|  49.6k|    src->cache = (pgp_source_cache_t *) calloc(1, sizeof(*src->cache));
  372|  49.6k|    if (!src->cache) {
  ------------------
  |  Branch (372:9): [True: 0, False: 49.6k]
  ------------------
  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.6k|    src->cache->readahead = true;
  377|  49.6k|    if (!paramsize) {
  ------------------
  |  Branch (377:9): [True: 1.81k, False: 47.8k]
  ------------------
  378|  1.81k|        return true;
  379|  1.81k|    }
  380|  47.8k|    src->param = calloc(1, paramsize);
  381|  47.8k|    if (!src->param) {
  ------------------
  |  Branch (381:9): [True: 0, False: 47.8k]
  ------------------
  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|  47.8k|    return true;
  388|  47.8k|}
_Z12init_mem_srcP12pgp_source_tPKvmb:
  546|  16.3k|{
  547|  16.3k|    if (!mem && len) {
  ------------------
  |  Branch (547:9): [True: 0, False: 16.3k]
  |  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.3k|    if (!init_src_common(src, sizeof(pgp_source_mem_param_t))) {
  ------------------
  |  Branch (551:9): [True: 0, False: 16.3k]
  ------------------
  552|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  553|      0|    }
  554|       |
  555|  16.3k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  556|  16.3k|    param->memory = mem;
  557|  16.3k|    param->len = len;
  558|  16.3k|    param->pos = 0;
  559|  16.3k|    param->free = free;
  560|  16.3k|    src->raw_read = mem_src_read;
  561|  16.3k|    src->raw_close = mem_src_close;
  562|  16.3k|    src->raw_finish = NULL;
  563|  16.3k|    src->size = len;
  564|  16.3k|    src->knownsize = 1;
  565|  16.3k|    src->type = PGP_STREAM_MEMORY;
  566|       |
  567|  16.3k|    return RNP_SUCCESS;
  568|  16.3k|}
_Z15init_dst_commonP10pgp_dest_tm:
  629|  19.5k|{
  630|  19.5k|    memset(dst, 0, sizeof(*dst));
  631|  19.5k|    dst->werr = RNP_SUCCESS;
  632|  19.5k|    if (!paramsize) {
  ------------------
  |  Branch (632:9): [True: 0, False: 19.5k]
  ------------------
  633|      0|        return true;
  634|      0|    }
  635|       |    /* allocate param */
  636|  19.5k|    dst->param = calloc(1, paramsize);
  637|  19.5k|    if (!dst->param) {
  ------------------
  |  Branch (637:9): [True: 0, False: 19.5k]
  ------------------
  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.5k|    return dst->param;
  641|  19.5k|}
_Z9dst_writeP10pgp_dest_tPKvm:
  645|   171M|{
  646|       |    /* we call write function only if all previous calls succeeded */
  647|   171M|    if ((len > 0) && (dst->write) && (dst->werr == RNP_SUCCESS)) {
  ------------------
  |  Branch (647:9): [True: 171M, False: 13.0k]
  |  Branch (647:22): [True: 171M, False: 0]
  |  Branch (647:38): [True: 171M, False: 0]
  ------------------
  648|       |        /* if cache non-empty and len will overflow it then fill it and write out */
  649|   171M|        if ((dst->clen > 0) && (dst->clen + len > sizeof(dst->cache))) {
  ------------------
  |  Branch (649:13): [True: 0, False: 171M]
  |  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|   171M|        if (dst->no_cache || (len > sizeof(dst->cache))) {
  ------------------
  |  Branch (662:13): [True: 171M, False: 0]
  |  Branch (662:30): [True: 0, False: 0]
  ------------------
  663|   171M|            dst->werr = dst->write(dst, buf, len);
  664|   171M|            if (!dst->werr) {
  ------------------
  |  Branch (664:17): [True: 171M, False: 0]
  ------------------
  665|   171M|                dst->writeb += len;
  666|   171M|            }
  667|   171M|        } else {
  668|      0|            memcpy(dst->cache + dst->clen, buf, len);
  669|      0|            dst->clen += len;
  670|      0|        }
  671|   171M|    }
  672|   171M|}
_Z9dst_writeR10pgp_dest_tRKNSt3__16vectorIhNS1_9allocatorIhEEEE:
  676|  10.0k|{
  677|  10.0k|    dst_write(&dst, buf.data(), buf.size());
  678|  10.0k|}
_Z10dst_printfR10pgp_dest_tPKcz:
  682|  40.5M|{
  683|  40.5M|    char    buf[2048];
  684|  40.5M|    size_t  len;
  685|  40.5M|    va_list ap;
  686|       |
  687|  40.5M|    va_start(ap, format);
  688|  40.5M|    len = vsnprintf(buf, sizeof(buf), format, ap);
  689|  40.5M|    va_end(ap);
  690|       |
  691|  40.5M|    if (len >= sizeof(buf)) {
  ------------------
  |  Branch (691:9): [True: 0, False: 40.5M]
  ------------------
  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.5M|    dst_write(&dst, buf, len);
  696|  40.5M|}
_Z9dst_flushP10pgp_dest_t:
  700|  26.1k|{
  701|  26.1k|    if ((dst->clen > 0) && (dst->write) && (dst->werr == RNP_SUCCESS)) {
  ------------------
  |  Branch (701:9): [True: 0, False: 26.1k]
  |  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.1k|}
_Z10dst_finishP10pgp_dest_t:
  710|  26.1k|{
  711|  26.1k|    rnp_result_t res = RNP_SUCCESS;
  712|       |
  713|  26.1k|    if (!dst->finished) {
  ------------------
  |  Branch (713:9): [True: 26.1k, False: 0]
  ------------------
  714|       |        /* flush write cache in the dst */
  715|  26.1k|        dst_flush(dst);
  716|  26.1k|        if (dst->finish) {
  ------------------
  |  Branch (716:13): [True: 0, False: 26.1k]
  ------------------
  717|      0|            res = dst->finish(dst);
  718|      0|        }
  719|  26.1k|        dst->finished = true;
  720|  26.1k|    }
  721|       |
  722|  26.1k|    return res;
  723|  26.1k|}
_Z9dst_closeP10pgp_dest_tb:
  727|  27.3k|{
  728|  27.3k|    if (!discard && !dst->finished) {
  ------------------
  |  Branch (728:9): [True: 26.1k, False: 1.21k]
  |  Branch (728:21): [True: 26.1k, False: 0]
  ------------------
  729|  26.1k|        dst_finish(dst);
  730|  26.1k|    }
  731|       |
  732|  27.3k|    if (dst->close) {
  ------------------
  |  Branch (732:9): [True: 27.3k, False: 0]
  ------------------
  733|  27.3k|        dst->close(dst, discard);
  734|  27.3k|    }
  735|  27.3k|}
_Z13init_mem_destP10pgp_dest_tPvj:
 1035|  1.21k|{
 1036|  1.21k|    pgp_dest_mem_param_t *param;
 1037|       |
 1038|  1.21k|    if (!init_dst_common(dst, sizeof(*param))) {
  ------------------
  |  Branch (1038:9): [True: 0, False: 1.21k]
  ------------------
 1039|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1040|      0|    }
 1041|       |
 1042|  1.21k|    param = (pgp_dest_mem_param_t *) dst->param;
 1043|       |
 1044|  1.21k|    param->maxalloc = len;
 1045|  1.21k|    param->allocated = mem ? len : 0;
  ------------------
  |  Branch (1045:24): [True: 1.21k, False: 0]
  ------------------
 1046|  1.21k|    param->memory = mem;
 1047|  1.21k|    param->free = !mem;
 1048|  1.21k|    param->secure = false;
 1049|       |
 1050|  1.21k|    dst->write = mem_dst_write;
 1051|  1.21k|    dst->close = mem_dst_close;
 1052|  1.21k|    dst->type = PGP_STREAM_MEMORY;
 1053|  1.21k|    dst->werr = RNP_SUCCESS;
 1054|  1.21k|    dst->no_cache = true;
 1055|       |
 1056|  1.21k|    return RNP_SUCCESS;
 1057|  1.21k|}
_Z25mem_dest_discard_overflowP10pgp_dest_tb:
 1061|  1.21k|{
 1062|  1.21k|    if (dst->type != PGP_STREAM_MEMORY) {
  ------------------
  |  Branch (1062:9): [True: 0, False: 1.21k]
  ------------------
 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.21k|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
 1068|  1.21k|    if (param) {
  ------------------
  |  Branch (1068:9): [True: 1.21k, False: 0]
  ------------------
 1069|  1.21k|        param->discard_overflow = discard;
 1070|  1.21k|    }
 1071|  1.21k|}
_Z14init_null_destP10pgp_dest_t:
 1159|  7.79k|{
 1160|  7.79k|    dst->param = NULL;
 1161|  7.79k|    dst->write = null_dst_write;
 1162|  7.79k|    dst->close = null_dst_close;
 1163|  7.79k|    dst->type = PGP_STREAM_NULL;
 1164|  7.79k|    dst->writeb = 0;
 1165|  7.79k|    dst->clen = 0;
 1166|  7.79k|    dst->werr = RNP_SUCCESS;
 1167|  7.79k|    dst->no_cache = true;
 1168|       |
 1169|  7.79k|    return RNP_SUCCESS;
 1170|  7.79k|}
_Z13dst_write_srcP12pgp_source_tP10pgp_dest_tm:
 1174|    233|{
 1175|    233|    const size_t bufsize = PGP_INPUT_CACHE_SIZE;
  ------------------
  |  |   35|    233|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
 1176|    233|    uint8_t *    readbuf = (uint8_t *) malloc(bufsize);
 1177|    233|    if (!readbuf) {
  ------------------
  |  Branch (1177:9): [True: 0, False: 233]
  ------------------
 1178|      0|        return RNP_ERROR_OUT_OF_MEMORY;
 1179|      0|    }
 1180|    233|    rnp_result_t res = RNP_SUCCESS;
 1181|    233|    try {
 1182|    233|        size_t   read;
 1183|    233|        uint64_t totalread = 0;
 1184|       |
 1185|   167k|        while (!src->eof_) {
  ------------------
  |  Branch (1185:16): [True: 167k, False: 184]
  ------------------
 1186|   167k|            if (!src->read(readbuf, bufsize, &read)) {
  ------------------
  |  Branch (1186:17): [True: 44, False: 167k]
  ------------------
 1187|     44|                res = RNP_ERROR_GENERIC;
 1188|     44|                break;
 1189|     44|            }
 1190|   167k|            if (!read) {
  ------------------
  |  Branch (1190:17): [True: 31, False: 167k]
  ------------------
 1191|     31|                continue;
 1192|     31|            }
 1193|   167k|            totalread += read;
 1194|   167k|            if (limit && totalread > limit) {
  ------------------
  |  Branch (1194:17): [True: 167k, False: 0]
  |  Branch (1194:26): [True: 5, False: 167k]
  ------------------
 1195|      5|                res = RNP_ERROR_GENERIC;
 1196|      5|                break;
 1197|      5|            }
 1198|   167k|            if (dst) {
  ------------------
  |  Branch (1198:17): [True: 0, False: 167k]
  ------------------
 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|   167k|        }
 1207|    233|    } catch (...) {
 1208|      0|        free(readbuf);
 1209|      0|        throw;
 1210|      0|    }
 1211|    233|    free(readbuf);
 1212|    233|    if (res || !dst) {
  ------------------
  |  Branch (1212:9): [True: 49, False: 184]
  |  Branch (1212:16): [True: 184, False: 0]
  ------------------
 1213|    233|        return res;
 1214|    233|    }
 1215|      0|    dst_flush(dst);
 1216|      0|    return dst->werr;
 1217|    233|}
stream-common.cpp:_ZL12mem_src_readP12pgp_source_tPvmPm:
  516|  18.2k|{
  517|  18.2k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  518|  18.2k|    if (!param) {
  ------------------
  |  Branch (518:9): [True: 0, False: 18.2k]
  ------------------
  519|      0|        return false;
  520|      0|    }
  521|       |
  522|  18.2k|    if (len > param->len - param->pos) {
  ------------------
  |  Branch (522:9): [True: 852, False: 17.3k]
  ------------------
  523|    852|        len = param->len - param->pos;
  524|    852|    }
  525|  18.2k|    memcpy(buf, (uint8_t *) param->memory + param->pos, len);
  526|  18.2k|    param->pos += len;
  527|  18.2k|    *read = len;
  528|  18.2k|    return true;
  529|  18.2k|}
stream-common.cpp:_ZL13mem_src_closeP12pgp_source_t:
  533|  16.3k|{
  534|  16.3k|    pgp_source_mem_param_t *param = (pgp_source_mem_param_t *) src->param;
  535|  16.3k|    if (param) {
  ------------------
  |  Branch (535:9): [True: 16.3k, False: 0]
  ------------------
  536|  16.3k|        if (param->free) {
  ------------------
  |  Branch (536:13): [True: 0, False: 16.3k]
  ------------------
  537|      0|            free((void *) param->memory);
  538|      0|        }
  539|  16.3k|        free(src->param);
  540|       |        src->param = NULL;
  541|  16.3k|    }
  542|  16.3k|}
stream-common.cpp:_ZL13mem_dst_writeP10pgp_dest_tPKvm:
  972|  14.0M|{
  973|  14.0M|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
  974|  14.0M|    if (!param) {
  ------------------
  |  Branch (974:9): [True: 0, False: 14.0M]
  ------------------
  975|      0|        return RNP_ERROR_BAD_PARAMETERS;
  976|      0|    }
  977|       |
  978|       |    /* checking whether we need to realloc or discard extra bytes */
  979|  14.0M|    if (param->discard_overflow && (dst->writeb >= param->allocated)) {
  ------------------
  |  Branch (979:9): [True: 14.0M, False: 0]
  |  Branch (979:36): [True: 14.0M, False: 2.19k]
  ------------------
  980|  14.0M|        return RNP_SUCCESS;
  981|  14.0M|    }
  982|  2.19k|    if (param->discard_overflow && (dst->writeb + len > param->allocated)) {
  ------------------
  |  Branch (982:9): [True: 2.19k, False: 0]
  |  Branch (982:36): [True: 292, False: 1.90k]
  ------------------
  983|    292|        len = param->allocated - dst->writeb;
  984|    292|    }
  985|       |
  986|  2.19k|    if (dst->writeb + len > param->allocated) {
  ------------------
  |  Branch (986:9): [True: 0, False: 2.19k]
  ------------------
  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.19k|    memcpy((uint8_t *) param->memory + dst->writeb, buf, len);
 1012|  2.19k|    return RNP_SUCCESS;
 1013|  2.19k|}
stream-common.cpp:_ZL13mem_dst_closeP10pgp_dest_tb:
 1017|  1.21k|{
 1018|  1.21k|    pgp_dest_mem_param_t *param = (pgp_dest_mem_param_t *) dst->param;
 1019|  1.21k|    if (!param) {
  ------------------
  |  Branch (1019:9): [True: 0, False: 1.21k]
  ------------------
 1020|      0|        return;
 1021|      0|    }
 1022|       |
 1023|  1.21k|    if (param->free) {
  ------------------
  |  Branch (1023:9): [True: 0, False: 1.21k]
  ------------------
 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.21k|    free(param);
 1030|       |    dst->param = NULL;
 1031|  1.21k|}
stream-common.cpp:_ZL14null_dst_writeP10pgp_dest_tPKvm:
 1147|  48.1M|{
 1148|  48.1M|    return RNP_SUCCESS;
 1149|  48.1M|}
stream-common.cpp:_ZL14null_dst_closeP10pgp_dest_tb:
 1153|  7.79k|{
 1154|  7.79k|    ;
 1155|  7.79k|}

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

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

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

_ZN16pgp_userid_pkt_t5parseER12pgp_source_t:
  673|  30.1k|{
  674|       |    /* check the tag */
  675|  30.1k|    int stag = stream_pkt_type(src);
  676|  30.1k|    if ((stag != PGP_PKT_USER_ID) && (stag != PGP_PKT_USER_ATTR)) {
  ------------------
  |  Branch (676:9): [True: 9.22k, False: 20.8k]
  |  Branch (676:38): [True: 14, False: 9.21k]
  ------------------
  677|     14|        RNP_LOG("wrong userid tag: %d", stag);
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  678|     14|        return RNP_ERROR_BAD_FORMAT;
  679|     14|    }
  680|       |
  681|  30.1k|    pgp_packet_body_t pkt(PGP_PKT_RESERVED);
  682|  30.1k|    rnp_result_t      res = pkt.read(src);
  683|  30.1k|    if (res) {
  ------------------
  |  Branch (683:9): [True: 1.08k, False: 29.0k]
  ------------------
  684|  1.08k|        return res;
  685|  1.08k|    }
  686|       |
  687|       |    /* userid type, i.e. tag */
  688|  29.0k|    tag = (pgp_pkt_type_t) stag;
  689|  29.0k|    uid.resize(pkt.size());
  690|  29.0k|    if (pkt.size()) {
  ------------------
  |  Branch (690:9): [True: 24.9k, False: 4.03k]
  ------------------
  691|  24.9k|        std::memcpy(uid.data(), pkt.data(), pkt.size());
  692|  24.9k|    }
  693|  29.0k|    return RNP_SUCCESS;
  694|  30.1k|}
_ZN13pgp_key_pkt_tD2Ev:
  781|  65.1k|{
  782|  65.1k|    secure_clear(sec_data.data(), sec_data.size());
  783|  65.1k|}
_ZN13pgp_key_pkt_t5parseER12pgp_source_t:
  886|  65.1k|{
  887|       |    /* check the key tag */
  888|  65.1k|    int atag = stream_pkt_type(src);
  889|  65.1k|    if (!is_key_pkt(atag)) {
  ------------------
  |  Branch (889:9): [True: 75, False: 65.0k]
  ------------------
  890|     75|        RNP_LOG("wrong key packet tag: %d", atag);
  ------------------
  |  |   76|     75|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     75|    do {                                                                                 \
  |  |  |  |   69|     75|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 75, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     75|            break;                                                                       \
  |  |  |  |   71|     75|        (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|     75|        return RNP_ERROR_BAD_FORMAT;
  892|     75|    }
  893|       |
  894|  65.0k|#if defined(ENABLE_CRYPTO_REFRESH) || defined(ENABLE_PQC)
  895|  65.0k|    std::vector<uint8_t> tmpbuf;
  896|  65.0k|#endif
  897|       |
  898|  65.0k|    pgp_packet_body_t pkt((pgp_pkt_type_t) atag);
  899|       |    /* Read the packet into memory */
  900|  65.0k|    rnp_result_t res = pkt.read(src);
  901|  65.0k|    if (res) {
  ------------------
  |  Branch (901:9): [True: 4.91k, False: 60.1k]
  ------------------
  902|  4.91k|        return res;
  903|  4.91k|    }
  904|       |    /* key type, i.e. tag */
  905|  60.1k|    tag = (pgp_pkt_type_t) atag;
  906|       |    /* version */
  907|  60.1k|    uint8_t ver = 0;
  908|  60.1k|    if (!pkt.get(ver)) {
  ------------------
  |  Branch (908:9): [True: 396, False: 59.7k]
  ------------------
  909|    396|        RNP_LOG("unable to retrieve key packet version");
  ------------------
  |  |   76|    396|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    396|    do {                                                                                 \
  |  |  |  |   69|    396|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 396, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    396|            break;                                                                       \
  |  |  |  |   71|    396|        (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|    396|        return RNP_ERROR_BAD_FORMAT;
  911|    396|    }
  912|  59.7k|    switch (ver) {
  913|  1.84k|    case PGP_V2:
  ------------------
  |  Branch (913:5): [True: 1.84k, False: 57.9k]
  ------------------
  914|  1.84k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.84k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  915|  4.59k|    case PGP_V3:
  ------------------
  |  Branch (915:5): [True: 2.75k, False: 57.0k]
  ------------------
  916|  4.59k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  4.59k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  917|  46.7k|    case PGP_V4:
  ------------------
  |  Branch (917:5): [True: 42.1k, False: 17.5k]
  ------------------
  918|  46.7k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  46.7k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  919|  49.9k|    case PGP_V5:
  ------------------
  |  Branch (919:5): [True: 3.16k, False: 56.5k]
  ------------------
  920|  49.9k|        break;
  921|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  922|  8.48k|    case PGP_V6:
  ------------------
  |  Branch (922:5): [True: 8.48k, False: 51.2k]
  ------------------
  923|  8.48k|        break;
  924|      0|#endif
  925|  1.35k|    default:
  ------------------
  |  Branch (925:5): [True: 1.35k, False: 58.4k]
  ------------------
  926|  1.35k|        RNP_LOG("wrong key packet version");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  927|  1.35k|        return RNP_ERROR_BAD_FORMAT;
  928|  59.7k|    }
  929|  58.4k|    version = (pgp_version_t) ver;
  930|       |    /* creation time */
  931|  58.4k|    if (!pkt.get(creation_time)) {
  ------------------
  |  Branch (931:9): [True: 268, False: 58.1k]
  ------------------
  932|    268|        return RNP_ERROR_BAD_FORMAT;
  933|    268|    }
  934|       |    /* v3: validity days */
  935|  58.1k|    if ((version < PGP_V4) && !pkt.get(v3_days)) {
  ------------------
  |  Branch (935:9): [True: 4.45k, False: 53.6k]
  |  Branch (935:31): [True: 232, False: 4.22k]
  ------------------
  936|    232|        return RNP_ERROR_BAD_FORMAT;
  937|    232|    }
  938|       |    /* key algorithm */
  939|  57.9k|    uint8_t analg = 0;
  940|  57.9k|    if (!pkt.get(analg)) {
  ------------------
  |  Branch (940:9): [True: 234, False: 57.6k]
  ------------------
  941|    234|        return RNP_ERROR_BAD_FORMAT;
  942|    234|    }
  943|  57.6k|    alg = (pgp_pubkey_alg_t) analg;
  944|  57.6k|    material = pgp::KeyMaterial::create(alg);
  945|  57.6k|    if (!material) {
  ------------------
  |  Branch (945:9): [True: 540, False: 57.1k]
  ------------------
  946|    540|        RNP_LOG("unknown key algorithm: %d", (int) alg);
  ------------------
  |  |   76|    540|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    540|    do {                                                                                 \
  |  |  |  |   69|    540|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 540, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    540|            break;                                                                       \
  |  |  |  |   71|    540|        (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|    540|        return RNP_ERROR_BAD_FORMAT;
  948|    540|    }
  949|  57.1k|    switch (version) {
  950|  1.66k|    case PGP_V2:
  ------------------
  |  Branch (950:5): [True: 1.66k, False: 55.4k]
  ------------------
  951|  3.96k|    case PGP_V3:
  ------------------
  |  Branch (951:5): [True: 2.29k, False: 54.8k]
  ------------------
  952|       |        /* v3 keys must be RSA-only */
  953|  3.96k|        if (!is_rsa_key_alg(alg)) {
  ------------------
  |  Branch (953:13): [True: 388, False: 3.57k]
  ------------------
  954|    388|            RNP_LOG("wrong v3 pk algorithm");
  ------------------
  |  |   76|    388|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    388|    do {                                                                                 \
  |  |  |  |   69|    388|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 388, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    388|            break;                                                                       \
  |  |  |  |   71|    388|        (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|    388|            return RNP_ERROR_BAD_FORMAT;
  956|    388|        }
  957|  3.57k|        break;
  958|  3.57k|    case PGP_V5:
  ------------------
  |  Branch (958:5): [True: 3.04k, False: 54.0k]
  ------------------
  959|  3.04k|#if defined(ENABLE_CRYPTO_REFRESH)
  960|  11.4k|    case PGP_V6:
  ------------------
  |  Branch (960:5): [True: 8.43k, False: 48.6k]
  ------------------
  961|  11.4k|#endif
  962|       |        /* v5-v6 public key material length  */
  963|  11.4k|        if (!pkt.get(v5_pub_len)) {
  ------------------
  |  Branch (963:13): [True: 950, False: 10.5k]
  ------------------
  964|    950|            RNP_LOG("failed to get v5 octet count field");
  ------------------
  |  |   76|    950|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    950|    do {                                                                                 \
  |  |  |  |   69|    950|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 950, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    950|            break;                                                                       \
  |  |  |  |   71|    950|        (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|    950|            return RNP_ERROR_BAD_FORMAT;
  966|    950|        }
  967|  10.5k|        if (is_public_key_pkt(atag) && (v5_pub_len != pkt.left())) {
  ------------------
  |  Branch (967:13): [True: 1.01k, False: 9.51k]
  |  Branch (967:40): [True: 796, False: 218]
  ------------------
  968|    796|            RNP_LOG("v5 octet count mismatch");
  ------------------
  |  |   76|    796|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    796|    do {                                                                                 \
  |  |  |  |   69|    796|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 796, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    796|            break;                                                                       \
  |  |  |  |   71|    796|        (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|    796|            return RNP_ERROR_BAD_FORMAT;
  970|    796|        }
  971|  9.73k|        break;
  972|  41.6k|    default:;
  ------------------
  |  Branch (972:5): [True: 41.6k, False: 15.4k]
  ------------------
  973|  57.1k|    }
  974|       |
  975|       |    /* algorithm specific fields */
  976|  54.9k|    if (!material->parse(pkt)) {
  ------------------
  |  Branch (976:9): [True: 12.5k, False: 42.4k]
  ------------------
  977|  12.5k|        return RNP_ERROR_BAD_FORMAT;
  978|  12.5k|    }
  979|       |
  980|       |    /* fill hashed data used for signatures */
  981|  42.4k|    pub_data.assign(pkt.data(), pkt.data() + pkt.size() - pkt.left());
  982|       |
  983|       |    /* secret key fields if any */
  984|  42.4k|    if (is_secret_key_pkt(tag)) {
  ------------------
  |  Branch (984:9): [True: 29.4k, False: 13.0k]
  ------------------
  985|  29.4k|        uint8_t usage = 0;
  986|  29.4k|        if (!pkt.get(usage)) {
  ------------------
  |  Branch (986:13): [True: 236, False: 29.1k]
  ------------------
  987|    236|            RNP_LOG("failed to read key protection");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  988|    236|            return RNP_ERROR_BAD_FORMAT;
  989|    236|        }
  990|  29.1k|#if defined(ENABLE_CRYPTO_REFRESH)
  991|  29.1k|        if (version == PGP_V6 && usage == 255) {
  ------------------
  |  Branch (991:13): [True: 6.73k, False: 22.4k]
  |  Branch (991:34): [True: 204, False: 6.53k]
  ------------------
  992|    204|            RNP_LOG(
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  993|    204|              "Error when parsing S2K usage: A version 6 packet MUST NOT use the value 255.");
  994|    204|            return RNP_ERROR_BAD_FORMAT;
  995|    204|        }
  996|  28.9k|#endif
  997|  28.9k|        sec_protection.s2k.usage = (pgp_s2k_usage_t) usage;
  998|  28.9k|        sec_protection.cipher_mode = PGP_CIPHER_MODE_CFB;
  999|       |
 1000|       |        /* v5 s2k length, ignored for now */
 1001|  28.9k|        if (version == PGP_V5) {
  ------------------
  |  Branch (1001:13): [True: 1.62k, False: 27.3k]
  ------------------
 1002|  1.62k|            if (!pkt.get(v5_s2k_len)) {
  ------------------
  |  Branch (1002:17): [True: 206, False: 1.41k]
  ------------------
 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.62k|        }
 1007|  28.7k|#if defined(ENABLE_CRYPTO_REFRESH)
 1008|  28.7k|        if (version == PGP_V6 && sec_protection.s2k.usage != PGP_S2KU_NONE) {
  ------------------
  |  Branch (1008:13): [True: 6.53k, False: 22.2k]
  |  Branch (1008:34): [True: 6.19k, False: 337]
  ------------------
 1009|       |            // V6 packages contain the count of the optional 1-byte parameters
 1010|  6.19k|            if (!pkt.get(v5_s2k_len)) {
  ------------------
  |  Branch (1010:17): [True: 202, False: 5.99k]
  ------------------
 1011|    202|                RNP_LOG("failed to read key protection");
  ------------------
  |  |   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|  6.19k|        }
 1015|  28.5k|#endif
 1016|       |
 1017|  28.5k|        switch (sec_protection.s2k.usage) {
 1018|  8.98k|        case PGP_S2KU_NONE:
  ------------------
  |  Branch (1018:9): [True: 8.98k, False: 19.5k]
  ------------------
 1019|  8.98k|            break;
 1020|    595|        case PGP_S2KU_ENCRYPTED:
  ------------------
  |  Branch (1020:9): [True: 595, False: 27.9k]
  ------------------
 1021|  2.18k|        case PGP_S2KU_ENCRYPTED_AND_HASHED: {
  ------------------
  |  Branch (1021:9): [True: 1.59k, False: 26.9k]
  ------------------
 1022|       |            /* we have s2k */
 1023|  2.18k|            uint8_t salg = 0;
 1024|  2.18k|            if (!pkt.get(salg)) {
  ------------------
  |  Branch (1024:17): [True: 203, False: 1.98k]
  ------------------
 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.98k|#if defined(ENABLE_CRYPTO_REFRESH)
 1029|  1.98k|            if (version == PGP_V6) {
  ------------------
  |  Branch (1029:17): [True: 398, False: 1.58k]
  ------------------
 1030|       |                // V6 packages contain the length of the following field
 1031|    398|                uint8_t s2k_specifier_len;
 1032|    398|                if (!pkt.get(s2k_specifier_len)) {
  ------------------
  |  Branch (1032:21): [True: 196, False: 202]
  ------------------
 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|    398|            }
 1036|  1.98k|#endif
 1037|  1.98k|            if (!pkt.get(sec_protection.s2k)) {
  ------------------
  |  Branch (1037:17): [True: 541, False: 1.44k]
  ------------------
 1038|    541|                RNP_LOG("failed to read key protection (s2k)");
  ------------------
  |  |   76|    541|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    541|    do {                                                                                 \
  |  |  |  |   69|    541|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 541, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    541|            break;                                                                       \
  |  |  |  |   71|    541|        (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|    541|                return RNP_ERROR_BAD_FORMAT;
 1040|    541|            }
 1041|  1.44k|            sec_protection.symm_alg = (pgp_symm_alg_t) salg;
 1042|  1.44k|            break;
 1043|  1.98k|        }
 1044|  17.3k|        default:
  ------------------
  |  Branch (1044:9): [True: 17.3k, False: 11.1k]
  ------------------
 1045|       |            /* old-style: usage is symmetric algorithm identifier */
 1046|  17.3k|            sec_protection.symm_alg = (pgp_symm_alg_t) usage;
 1047|  17.3k|            sec_protection.s2k.usage = PGP_S2KU_ENCRYPTED;
 1048|  17.3k|            sec_protection.s2k.specifier = PGP_S2KS_SIMPLE;
 1049|  17.3k|            sec_protection.s2k.hash_alg = PGP_HASH_MD5;
 1050|  17.3k|            break;
 1051|  28.5k|        }
 1052|       |
 1053|       |        /* iv */
 1054|  27.8k|        if (sec_protection.s2k.usage &&
  ------------------
  |  Branch (1054:13): [True: 18.8k, False: 8.98k]
  ------------------
 1055|  18.8k|            (sec_protection.s2k.specifier != PGP_S2KS_EXPERIMENTAL)) {
  ------------------
  |  Branch (1055:13): [True: 18.2k, False: 568]
  ------------------
 1056|  18.2k|            size_t bl_size = pgp_block_size(sec_protection.symm_alg);
 1057|  18.2k|            if (!bl_size || !pkt.get(sec_protection.iv, bl_size)) {
  ------------------
  |  Branch (1057:17): [True: 1.38k, False: 16.8k]
  |  Branch (1057:29): [True: 1.13k, False: 15.7k]
  ------------------
 1058|  2.51k|                RNP_LOG("failed to read iv");
  ------------------
  |  |   76|  2.51k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.51k|    do {                                                                                 \
  |  |  |  |   69|  2.51k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.51k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.51k|            break;                                                                       \
  |  |  |  |   71|  2.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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1059|  2.51k|                return RNP_ERROR_BAD_FORMAT;
 1060|  2.51k|            }
 1061|  18.2k|        }
 1062|       |
 1063|       |        /* v5 secret key fields length */
 1064|  25.2k|        if (version == PGP_V5) {
  ------------------
  |  Branch (1064:13): [True: 1.03k, False: 24.2k]
  ------------------
 1065|  1.03k|            if (!pkt.get(v5_sec_len)) {
  ------------------
  |  Branch (1065:17): [True: 229, False: 809]
  ------------------
 1066|    229|                RNP_LOG("failed to read v5 secret fields length");
  ------------------
  |  |   76|    229|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    229|    do {                                                                                 \
  |  |  |  |   69|    229|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 229, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    229|            break;                                                                       \
  |  |  |  |   71|    229|        (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|    229|                return RNP_ERROR_BAD_FORMAT;
 1068|    229|            }
 1069|    809|            if (v5_sec_len != pkt.left()) {
  ------------------
  |  Branch (1069:17): [True: 279, False: 530]
  ------------------
 1070|    279|                RNP_LOG("v5 secret fields length mismatch");
  ------------------
  |  |   76|    279|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    279|    do {                                                                                 \
  |  |  |  |   69|    279|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 279, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    279|            break;                                                                       \
  |  |  |  |   71|    279|        (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|    279|                return RNP_ERROR_BAD_FORMAT;
 1072|    279|            }
 1073|    809|        }
 1074|       |
 1075|       |        /* encrypted/cleartext secret MPIs are left */
 1076|  24.7k|        size_t sec_len = pkt.left();
 1077|  24.7k|        sec_data.resize(sec_len);
 1078|  24.7k|        if (sec_len && !pkt.get(sec_data.data(), sec_len)) {
  ------------------
  |  Branch (1078:13): [True: 22.6k, False: 2.17k]
  |  Branch (1078:24): [True: 0, False: 22.6k]
  ------------------
 1079|      0|            return RNP_ERROR_BAD_STATE;
 1080|      0|        }
 1081|  24.7k|    }
 1082|       |
 1083|  37.8k|    if (pkt.left()) {
  ------------------
  |  Branch (1083:9): [True: 253, False: 37.5k]
  ------------------
 1084|    253|        RNP_LOG("extra %zu bytes in key packet", pkt.left());
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1085|    253|        return RNP_ERROR_BAD_FORMAT;
 1086|    253|    }
 1087|  37.5k|    return RNP_SUCCESS;
 1088|  37.8k|}

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

_Z15get_packet_typeh:
   67|   775k|{
   68|   775k|    if (!(ptag & PGP_PTAG_ALWAYS_SET)) {
  ------------------
  |  |   47|   775k|#define PGP_PTAG_ALWAYS_SET 0x80
  ------------------
  |  Branch (68:9): [True: 0, False: 775k]
  ------------------
   69|      0|        return -1;
   70|      0|    }
   71|       |
   72|   775k|    if (ptag & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|   775k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (72:9): [True: 520k, False: 255k]
  ------------------
   73|   520k|        return (int) (ptag & PGP_PTAG_NF_CONTENT_TAG_MASK);
  ------------------
  |  |  137|   520k|#define PGP_PTAG_NF_CONTENT_TAG_MASK 0x3f
  ------------------
   74|   520k|    } else {
   75|   255k|        return (int) ((ptag & PGP_PTAG_OF_CONTENT_TAG_MASK) >> PGP_PTAG_OF_CONTENT_TAG_SHIFT);
  ------------------
  |  |   66|   255k|#define PGP_PTAG_OF_CONTENT_TAG_MASK 0x3c
  ------------------
                      return (int) ((ptag & PGP_PTAG_OF_CONTENT_TAG_MASK) >> PGP_PTAG_OF_CONTENT_TAG_SHIFT);
  ------------------
  |  |   74|   255k|#define PGP_PTAG_OF_CONTENT_TAG_SHIFT 2
  ------------------
   76|   255k|    }
   77|   775k|}
_Z15stream_pkt_typeR12pgp_source_t:
   81|  95.2k|{
   82|  95.2k|    if (src.eof()) {
  ------------------
  |  Branch (82:9): [True: 0, False: 95.2k]
  ------------------
   83|      0|        return 0;
   84|      0|    }
   85|  95.2k|    size_t hdrneed = 0;
   86|  95.2k|    if (!stream_pkt_hdr_len(src, hdrneed)) {
  ------------------
  |  Branch (86:9): [True: 89, False: 95.1k]
  ------------------
   87|     89|        return -1;
   88|     89|    }
   89|  95.1k|    uint8_t hdr[PGP_MAX_HEADER_SIZE];
   90|  95.1k|    if (!src.peek_eq(hdr, hdrneed)) {
  ------------------
  |  Branch (90:9): [True: 0, False: 95.1k]
  ------------------
   91|      0|        return -1;
   92|      0|    }
   93|  95.1k|    return get_packet_type(hdr[0]);
   94|  95.1k|}
_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.09M|#define PGP_PTAG_ALWAYS_SET 0x80
  ------------------
  |  Branch (101:9): [True: 3.23k, False: 1.09M]
  |  Branch (101:33): [True: 3.12k, False: 1.09M]
  ------------------
  102|  6.36k|        return false;
  103|  6.36k|    }
  104|       |
  105|  1.09M|    if (buf[0] & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|  1.09M|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (105:9): [True: 738k, False: 352k]
  ------------------
  106|   738k|        if (buf[1] < 192) {
  ------------------
  |  Branch (106:13): [True: 659k, False: 79.1k]
  ------------------
  107|   659k|            hdrlen = 2;
  108|   659k|        } else if (buf[1] < 224) {
  ------------------
  |  Branch (108:20): [True: 53.3k, False: 25.8k]
  ------------------
  109|  53.3k|            hdrlen = 3;
  110|  53.3k|        } else if (buf[1] < 255) {
  ------------------
  |  Branch (110:20): [True: 23.7k, False: 2.11k]
  ------------------
  111|  23.7k|            hdrlen = 2;
  112|  23.7k|        } else {
  113|  2.11k|            hdrlen = 6;
  114|  2.11k|        }
  115|   738k|        return true;
  116|   738k|    }
  117|       |
  118|   352k|    switch (buf[0] & PGP_PTAG_OF_LENGTH_TYPE_MASK) {
  ------------------
  |  |   83|   352k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  119|   215k|    case PGP_PTAG_OLD_LEN_1:
  ------------------
  |  Branch (119:5): [True: 215k, False: 136k]
  ------------------
  120|   215k|        hdrlen = 2;
  121|   215k|        return true;
  122|  52.9k|    case PGP_PTAG_OLD_LEN_2:
  ------------------
  |  Branch (122:5): [True: 52.9k, False: 299k]
  ------------------
  123|  52.9k|        hdrlen = 3;
  124|  52.9k|        return true;
  125|  11.6k|    case PGP_PTAG_OLD_LEN_4:
  ------------------
  |  Branch (125:5): [True: 11.6k, False: 340k]
  ------------------
  126|  11.6k|        hdrlen = 5;
  127|  11.6k|        return true;
  128|  71.7k|    case PGP_PTAG_OLD_LEN_INDETERMINATE:
  ------------------
  |  Branch (128:5): [True: 71.7k, False: 280k]
  ------------------
  129|  71.7k|        hdrlen = 1;
  130|  71.7k|        return true;
  131|      0|    default:
  ------------------
  |  Branch (131:5): [True: 0, False: 352k]
  ------------------
  132|      0|        return false;
  133|   352k|    }
  134|   352k|}
_Z19stream_read_pkt_lenR12pgp_source_tPm:
  176|   314k|{
  177|   314k|    uint8_t buf[6] = {};
  178|   314k|    size_t  read = 0;
  179|       |
  180|   314k|    if (!stream_pkt_hdr_len(src, read)) {
  ------------------
  |  Branch (180:9): [True: 0, False: 314k]
  ------------------
  181|      0|        return false;
  182|      0|    }
  183|       |
  184|   314k|    if (!src.read_eq(buf, read)) {
  ------------------
  |  Branch (184:9): [True: 0, False: 314k]
  ------------------
  185|      0|        return false;
  186|      0|    }
  187|       |
  188|   314k|    return get_pkt_len(buf, pktlen);
  189|   314k|}
_Z29stream_read_partial_chunk_lenP12pgp_source_tPmPb:
  193|  22.9M|{
  194|  22.9M|    uint8_t hdr[5] = {};
  195|  22.9M|    size_t  read = 0;
  196|       |
  197|  22.9M|    if (!src->read(hdr, 1, &read)) {
  ------------------
  |  Branch (197:9): [True: 18, False: 22.9M]
  ------------------
  198|     18|        RNP_LOG("failed to read header");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  199|     18|        return false;
  200|     18|    }
  201|  22.9M|    if (read < 1) {
  ------------------
  |  Branch (201:9): [True: 150, False: 22.9M]
  ------------------
  202|    150|        RNP_LOG("wrong eof");
  ------------------
  |  |   76|    150|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    150|    do {                                                                                 \
  |  |  |  |   69|    150|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 150, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    150|            break;                                                                       \
  |  |  |  |   71|    150|        (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|    150|        return false;
  204|    150|    }
  205|       |
  206|  22.9M|    *last = true;
  207|       |    // partial length
  208|  22.9M|    if ((hdr[0] >= 224) && (hdr[0] < 255)) {
  ------------------
  |  Branch (208:9): [True: 22.9M, False: 9.23k]
  |  Branch (208:28): [True: 22.9M, False: 610]
  ------------------
  209|  22.9M|        *last = false;
  210|  22.9M|        *clen = get_partial_pkt_len(hdr[0]);
  211|  22.9M|        return true;
  212|  22.9M|    }
  213|       |    // 1-byte length
  214|  9.84k|    if (hdr[0] < 192) {
  ------------------
  |  Branch (214:9): [True: 8.09k, False: 1.74k]
  ------------------
  215|  8.09k|        *clen = hdr[0];
  216|  8.09k|        return true;
  217|  8.09k|    }
  218|       |    // 2-byte length
  219|  1.74k|    if (hdr[0] < 224) {
  ------------------
  |  Branch (219:9): [True: 1.13k, False: 610]
  ------------------
  220|  1.13k|        if (!src->read_eq(&hdr[1], 1)) {
  ------------------
  |  Branch (220:13): [True: 74, False: 1.06k]
  ------------------
  221|     74|            RNP_LOG("wrong 2-byte length");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  222|     74|            return false;
  223|     74|        }
  224|  1.06k|        *clen = ((size_t)(hdr[0] - 192) << 8) + (size_t) hdr[1] + 192;
  225|  1.06k|        return true;
  226|  1.13k|    }
  227|       |    // 4-byte length
  228|    610|    if (!src->read_eq(&hdr[1], 4)) {
  ------------------
  |  Branch (228:9): [True: 75, False: 535]
  ------------------
  229|     75|        RNP_LOG("wrong 4-byte length");
  ------------------
  |  |   76|     75|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     75|    do {                                                                                 \
  |  |  |  |   69|     75|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 75, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     75|            break;                                                                       \
  |  |  |  |   71|     75|        (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|     75|        return false;
  231|     75|    }
  232|    535|    *clen = ((size_t) hdr[1] << 24) | ((size_t) hdr[2] << 16) | ((size_t) hdr[3] << 8) |
  233|    535|            (size_t) hdr[4];
  234|    535|    return true;
  235|    610|}
_Z32stream_old_indeterminate_pkt_lenP12pgp_source_t:
  239|   481k|{
  240|   481k|    uint8_t ptag = 0;
  241|   481k|    if (!src->peek_eq(&ptag, 1)) {
  ------------------
  |  Branch (241:9): [True: 33, False: 481k]
  ------------------
  242|     33|        return false;
  243|     33|    }
  244|   481k|    return !(ptag & PGP_PTAG_NEW_FORMAT) &&
  ------------------
  |  |   56|   481k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (244:12): [True: 136k, False: 344k]
  ------------------
  245|   136k|           ((ptag & PGP_PTAG_OF_LENGTH_TYPE_MASK) == PGP_PTAG_OLD_LEN_INDETERMINATE);
  ------------------
  |  |   83|   136k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  |  Branch (245:12): [True: 35.4k, False: 101k]
  ------------------
  246|   481k|}
_Z22stream_partial_pkt_lenP12pgp_source_t:
  250|   504k|{
  251|   504k|    uint8_t hdr[2] = {};
  252|   504k|    if (!src->peek_eq(hdr, 2)) {
  ------------------
  |  Branch (252:9): [True: 33, False: 504k]
  ------------------
  253|     33|        return false;
  254|     33|    }
  255|   504k|    return (hdr[0] & PGP_PTAG_NEW_FORMAT) && (hdr[1] >= 224) && (hdr[1] < 255);
  ------------------
  |  |   56|   504k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (255:12): [True: 367k, False: 136k]
  |  Branch (255:46): [True: 28.6k, False: 338k]
  |  Branch (255:65): [True: 27.5k, False: 1.04k]
  ------------------
  256|   504k|}
_Z19get_partial_pkt_lenh:
  260|  22.9M|{
  261|  22.9M|    return 1 << (blen & 0x1f);
  262|  22.9M|}
_Z22stream_peek_packet_hdrP12pgp_source_tP16pgp_packet_hdr_t:
  266|   372k|{
  267|   372k|    size_t hlen = 0;
  268|   372k|    memset(hdr, 0, sizeof(*hdr));
  269|   372k|    if (!stream_pkt_hdr_len(*src, hlen)) {
  ------------------
  |  Branch (269:9): [True: 6.27k, False: 365k]
  ------------------
  270|  6.27k|        uint8_t hdr2[2] = {0};
  271|  6.27k|        if (!src->peek_eq(hdr2, 2)) {
  ------------------
  |  Branch (271:13): [True: 3.14k, False: 3.12k]
  ------------------
  272|  3.14k|            RNP_LOG("pkt header read failed");
  ------------------
  |  |   76|  3.14k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.14k|    do {                                                                                 \
  |  |  |  |   69|  3.14k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.14k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.14k|            break;                                                                       \
  |  |  |  |   71|  3.14k|        (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.14k|            return RNP_ERROR_READ;
  274|  3.14k|        }
  275|       |
  276|  3.12k|        RNP_LOG("bad packet header: 0x%02x%02x", hdr2[0], hdr2[1]);
  ------------------
  |  |   76|  3.12k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.12k|    do {                                                                                 \
  |  |  |  |   69|  3.12k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.12k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.12k|            break;                                                                       \
  |  |  |  |   71|  3.12k|        (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.12k|        return RNP_ERROR_BAD_FORMAT;
  278|  6.27k|    }
  279|       |
  280|   365k|    if (!src->peek_eq(hdr->hdr, hlen)) {
  ------------------
  |  Branch (280:9): [True: 142, False: 365k]
  ------------------
  281|    142|        RNP_LOG("failed to read pkt header");
  ------------------
  |  |   76|    142|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    142|    do {                                                                                 \
  |  |  |  |   69|    142|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 142, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    142|            break;                                                                       \
  |  |  |  |   71|    142|        (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|    142|        return RNP_ERROR_READ;
  283|    142|    }
  284|       |
  285|   365k|    hdr->hdr_len = hlen;
  286|   365k|    hdr->tag = (pgp_pkt_type_t) get_packet_type(hdr->hdr[0]);
  287|       |
  288|   365k|    if (stream_partial_pkt_len(src)) {
  ------------------
  |  Branch (288:9): [True: 22.7k, False: 342k]
  ------------------
  289|  22.7k|        hdr->partial = true;
  290|   342k|    } else if (stream_old_indeterminate_pkt_len(src)) {
  ------------------
  |  Branch (290:16): [True: 35.2k, False: 307k]
  ------------------
  291|  35.2k|        hdr->indeterminate = true;
  292|   307k|    } else {
  293|   307k|        (void) get_pkt_len(hdr->hdr, &hdr->pkt_len);
  294|   307k|    }
  295|       |
  296|   365k|    return RNP_SUCCESS;
  297|   365k|}
_Z18stream_read_packetP12pgp_source_tP10pgp_dest_t:
  345|   138k|{
  346|   138k|    if (stream_old_indeterminate_pkt_len(src)) {
  ------------------
  |  Branch (346:9): [True: 233, False: 138k]
  ------------------
  347|    233|        return dst_write_src(src, dst, PGP_MAX_OLD_LEN_INDETERMINATE_PKT_SIZE);
  ------------------
  |  |   42|    233|#define PGP_MAX_OLD_LEN_INDETERMINATE_PKT_SIZE 0x40000000
  ------------------
  348|    233|    }
  349|       |
  350|   138k|    if (stream_partial_pkt_len(src)) {
  ------------------
  |  Branch (350:9): [True: 4.79k, False: 133k]
  ------------------
  351|  4.79k|        return stream_read_packet_partial(src, dst);
  352|  4.79k|    }
  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: 761, False: 133k]
  ------------------
  358|    761|            body.write(*dst, false);
  359|    761|        }
  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|  2.77k|{
  376|  2.77k|    try {
  377|  2.77k|        pgp_packet_body_t pkt(PGP_PKT_MARKER);
  378|  2.77k|        rnp_result_t      res = pkt.read(src);
  379|  2.77k|        if (res) {
  ------------------
  |  Branch (379:13): [True: 1.04k, False: 1.72k]
  ------------------
  380|  1.04k|            return res;
  381|  1.04k|        }
  382|  1.72k|        if ((pkt.size() != PGP_MARKER_LEN) ||
  ------------------
  |  |  104|  1.72k|#define PGP_MARKER_LEN 3
  ------------------
  |  Branch (382:13): [True: 1.04k, False: 678]
  ------------------
  383|  1.40k|            memcmp(pkt.data(), PGP_MARKER_CONTENTS, PGP_MARKER_LEN)) {
  ------------------
  |  |  103|    678|#define PGP_MARKER_CONTENTS "PGP"
  ------------------
                          memcmp(pkt.data(), PGP_MARKER_CONTENTS, PGP_MARKER_LEN)) {
  ------------------
  |  |  104|    678|#define PGP_MARKER_LEN 3
  ------------------
  |  Branch (383:13): [True: 358, False: 320]
  ------------------
  384|  1.40k|            return RNP_ERROR_BAD_FORMAT;
  385|  1.40k|        }
  386|    320|        return RNP_SUCCESS;
  387|  1.72k|    } 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|  2.77k|}
_Z10is_key_pkti:
  395|  65.1k|{
  396|  65.1k|    switch (tag) {
  397|  10.2k|    case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (397:5): [True: 10.2k, False: 54.9k]
  ------------------
  398|  22.9k|    case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (398:5): [True: 12.7k, False: 52.4k]
  ------------------
  399|  45.5k|    case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (399:5): [True: 22.6k, False: 42.4k]
  ------------------
  400|  65.0k|    case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (400:5): [True: 19.4k, False: 45.6k]
  ------------------
  401|  65.0k|        return true;
  402|     75|    default:
  ------------------
  |  Branch (402:5): [True: 75, False: 65.0k]
  ------------------
  403|     75|        return false;
  404|  65.1k|    }
  405|  65.1k|}
_Z17is_public_key_pkti:
  421|  10.5k|{
  422|  10.5k|    switch (tag) {
  423|    735|    case PGP_PKT_PUBLIC_KEY:
  ------------------
  |  Branch (423:5): [True: 735, False: 9.79k]
  ------------------
  424|  1.01k|    case PGP_PKT_PUBLIC_SUBKEY:
  ------------------
  |  Branch (424:5): [True: 279, False: 10.2k]
  ------------------
  425|  1.01k|        return true;
  426|  9.51k|    default:
  ------------------
  |  Branch (426:5): [True: 9.51k, False: 1.01k]
  ------------------
  427|  9.51k|        return false;
  428|  10.5k|    }
  429|  10.5k|}
_Z17is_secret_key_pkti:
  433|   394k|{
  434|   394k|    switch (tag) {
  435|  57.4k|    case PGP_PKT_SECRET_KEY:
  ------------------
  |  Branch (435:5): [True: 57.4k, False: 337k]
  ------------------
  436|  96.3k|    case PGP_PKT_SECRET_SUBKEY:
  ------------------
  |  Branch (436:5): [True: 38.9k, False: 356k]
  ------------------
  437|  96.3k|        return true;
  438|   298k|    default:
  ------------------
  |  Branch (438:5): [True: 298k, False: 96.3k]
  ------------------
  439|   298k|        return false;
  440|   394k|    }
  441|   394k|}
_Z14is_rsa_key_alg16pgp_pubkey_alg_t:
  445|  7.01k|{
  446|  7.01k|    switch (alg) {
  447|  3.21k|    case PGP_PKA_RSA:
  ------------------
  |  Branch (447:5): [True: 3.21k, False: 3.80k]
  ------------------
  448|  5.94k|    case PGP_PKA_RSA_ENCRYPT_ONLY:
  ------------------
  |  Branch (448:5): [True: 2.73k, False: 4.28k]
  ------------------
  449|  6.63k|    case PGP_PKA_RSA_SIGN_ONLY:
  ------------------
  |  Branch (449:5): [True: 684, False: 6.33k]
  ------------------
  450|  6.63k|        return true;
  451|    388|    default:
  ------------------
  |  Branch (451:5): [True: 388, False: 6.63k]
  ------------------
  452|    388|        return false;
  453|  7.01k|    }
  454|  7.01k|}
_ZN17pgp_packet_body_tC2E14pgp_pkt_type_t:
  457|   314k|{
  458|   314k|    data_.reserve(16);
  459|   314k|    tag_ = tag;
  460|   314k|    secure_ = is_secret_key_pkt(tag);
  461|   314k|}
_ZN17pgp_packet_body_tC2EPKhm:
  464|  69.3k|{
  465|  69.3k|    data_.assign(data, data + len);
  466|  69.3k|    tag_ = PGP_PKT_RESERVED;
  467|  69.3k|    secure_ = false;
  468|  69.3k|}
_ZN17pgp_packet_body_tC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  471|  65.4k|    : pgp_packet_body_t(data.data(), data.size())
  472|  65.4k|{
  473|  65.4k|}
_ZN17pgp_packet_body_tD2Ev:
  476|   384k|{
  477|   384k|    if (secure_) {
  ------------------
  |  Branch (477:9): [True: 42.1k, False: 342k]
  ------------------
  478|  42.1k|        secure_clear(data_.data(), data_.size());
  479|  42.1k|    }
  480|   384k|}
_ZN17pgp_packet_body_t4dataEv:
  484|   110k|{
  485|   110k|    return data_.data();
  486|   110k|}
_ZN17pgp_packet_body_t3curEv:
  490|  91.1k|{
  491|  91.1k|    return data_.data() + pos_;
  492|  91.1k|}
_ZNK17pgp_packet_body_t4sizeEv:
  496|   128k|{
  497|   128k|    return data_.size();
  498|   128k|}
_ZNK17pgp_packet_body_t4leftEv:
  502|   287k|{
  503|   287k|    return data_.size() - pos_;
  504|   287k|}
_ZN17pgp_packet_body_t4skipEm:
  508|  26.0k|{
  509|  26.0k|    pos_ += bt;
  510|  26.0k|}
_ZN17pgp_packet_body_t9skip_backEm:
  514|  31.3k|{
  515|  31.3k|    pos_ = bt > pos_ ? 0 : pos_ - bt;
  ------------------
  |  Branch (515:12): [True: 0, False: 31.3k]
  ------------------
  516|  31.3k|}
_ZN17pgp_packet_body_t3getERh:
  520|   325k|{
  521|   325k|    if (pos_ >= data_.size()) {
  ------------------
  |  Branch (521:9): [True: 7.78k, False: 318k]
  ------------------
  522|  7.78k|        return false;
  523|  7.78k|    }
  524|   318k|    val = data_[pos_++];
  525|   318k|    return true;
  526|   325k|}
_ZN17pgp_packet_body_t3getERt:
  530|   196k|{
  531|   196k|    if (pos_ + 2 > data_.size()) {
  ------------------
  |  Branch (531:9): [True: 3.27k, False: 193k]
  ------------------
  532|  3.27k|        return false;
  533|  3.27k|    }
  534|   193k|    val = read_uint16(data_.data() + pos_);
  535|   193k|    pos_ += 2;
  536|   193k|    return true;
  537|   196k|}
_ZN17pgp_packet_body_t3getERj:
  541|  76.8k|{
  542|  76.8k|    if (pos_ + 4 > data_.size()) {
  ------------------
  |  Branch (542:9): [True: 1.70k, False: 75.1k]
  ------------------
  543|  1.70k|        return false;
  544|  1.70k|    }
  545|  75.1k|    val = read_uint32(data_.data() + pos_);
  546|  75.1k|    pos_ += 4;
  547|  75.1k|    return true;
  548|  76.8k|}
_ZN17pgp_packet_body_t3getEPhm:
  552|   341k|{
  553|   341k|    if (pos_ + len > data_.size()) {
  ------------------
  |  Branch (553:9): [True: 13.2k, False: 328k]
  ------------------
  554|  13.2k|        return false;
  555|  13.2k|    }
  556|   328k|    memcpy(val, data_.data() + pos_, len);
  557|   328k|    pos_ += len;
  558|   328k|    return true;
  559|   341k|}
_ZN17pgp_packet_body_t3getERNSt3__16vectorIhNS0_9allocatorIhEEEEm:
  563|  40.0k|{
  564|  40.0k|    if (pos_ + len > data_.size()) {
  ------------------
  |  Branch (564:9): [True: 2.86k, False: 37.1k]
  ------------------
  565|  2.86k|        return false;
  566|  2.86k|    }
  567|  37.1k|    val.assign(data_.data() + pos_, data_.data() + pos_ + len);
  568|  37.1k|    pos_ += len;
  569|  37.1k|    return true;
  570|  40.0k|}
_ZN17pgp_packet_body_t3getERNSt3__15arrayIhLm8EEE:
  574|  9.51k|{
  575|  9.51k|    static_assert(std::tuple_size<pgp::KeyID>::value == PGP_KEY_ID_SIZE,
  576|  9.51k|                  "pgp::KeyID size mismatch");
  577|  9.51k|    return get(val.data(), val.size());
  578|  9.51k|}
_ZN17pgp_packet_body_t3getERN3pgp3mpiE:
  582|   137k|{
  583|   137k|    uint16_t bits = 0;
  584|   137k|    if (!get(bits)) {
  ------------------
  |  Branch (584:9): [True: 2.64k, False: 134k]
  ------------------
  585|  2.64k|        return false;
  586|  2.64k|    }
  587|   134k|    size_t len = (bits + 7) >> 3;
  588|   134k|    if (len > PGP_MPINT_SIZE) {
  ------------------
  |  |   36|   134k|#define PGP_MPINT_SIZE (PGP_MPINT_BITS >> 3)
  |  |  ------------------
  |  |  |  |   35|   134k|#define PGP_MPINT_BITS (16384)
  |  |  ------------------
  ------------------
  |  Branch (588:9): [True: 1.97k, False: 132k]
  ------------------
  589|  1.97k|        RNP_LOG("too large mpi");
  ------------------
  |  |   76|  1.97k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.97k|    do {                                                                                 \
  |  |  |  |   69|  1.97k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.97k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.97k|            break;                                                                       \
  |  |  |  |   71|  1.97k|        (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.97k|        return false;
  591|  1.97k|    }
  592|   132k|    if (!len) {
  ------------------
  |  Branch (592:9): [True: 508, False: 132k]
  ------------------
  593|    508|        RNP_LOG("0 mpi");
  ------------------
  |  |   76|    508|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    508|    do {                                                                                 \
  |  |  |  |   69|    508|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 508, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    508|            break;                                                                       \
  |  |  |  |   71|    508|        (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|    508|        return false;
  595|    508|    }
  596|   132k|    val.resize(len);
  597|   132k|    if (!get(val.data(), len)) {
  ------------------
  |  Branch (597:9): [True: 3.30k, False: 128k]
  ------------------
  598|  3.30k|        RNP_LOG("failed to read mpi body");
  ------------------
  |  |   76|  3.30k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.30k|    do {                                                                                 \
  |  |  |  |   69|  3.30k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.30k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.30k|            break;                                                                       \
  |  |  |  |   71|  3.30k|        (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.30k|        return false;
  600|  3.30k|    }
  601|       |    /* check the mpi bit count */
  602|   128k|    size_t mbits = val.bits();
  603|   128k|    if (mbits != bits) {
  ------------------
  |  Branch (603:9): [True: 91.7k, False: 37.0k]
  ------------------
  604|  91.7k|        RNP_LOG(
  ------------------
  |  |   76|  91.7k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  91.7k|    do {                                                                                 \
  |  |  |  |   69|  91.7k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 91.7k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  91.7k|            break;                                                                       \
  |  |  |  |   71|  91.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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  605|  91.7k|          "Warning! Wrong mpi bit count: got %" PRIu16 ", but actual is %zu", bits, mbits);
  606|  91.7k|    }
  607|   128k|    return true;
  608|   132k|}
_ZN17pgp_packet_body_t3getER11pgp_curve_t:
  612|  9.79k|{
  613|  9.79k|    uint8_t oidlen = 0;
  614|  9.79k|    if (!get(oidlen)) {
  ------------------
  |  Branch (614:9): [True: 340, False: 9.45k]
  ------------------
  615|    340|        return false;
  616|    340|    }
  617|  9.45k|    if (!oidlen || (oidlen == 0xff)) {
  ------------------
  |  Branch (617:9): [True: 230, False: 9.22k]
  |  Branch (617:20): [True: 210, False: 9.01k]
  ------------------
  618|    440|        RNP_LOG("unsupported curve oid len: %" PRIu8, oidlen);
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  619|    440|        return false;
  620|    440|    }
  621|  9.01k|    std::vector<uint8_t> oid(oidlen, 0);
  622|  9.01k|    if (!get(oid, oidlen)) {
  ------------------
  |  Branch (622:9): [True: 927, False: 8.09k]
  ------------------
  623|    927|        return false;
  624|    927|    }
  625|  8.09k|    pgp_curve_t res = pgp::ec::Curve::by_OID(oid);
  626|  8.09k|    if (res == PGP_CURVE_MAX) {
  ------------------
  |  Branch (626:9): [True: 1.85k, False: 6.23k]
  ------------------
  627|  1.85k|        RNP_LOG("unsupported curve");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  628|  1.85k|        return false;
  629|  1.85k|    }
  630|  6.23k|    val = res;
  631|  6.23k|    return true;
  632|  8.09k|}
_ZN17pgp_packet_body_t3getER9pgp_s2k_t:
  636|  12.9k|{
  637|  12.9k|    uint8_t spec = 0, halg = 0;
  638|  12.9k|    if (!get(spec) || !get(halg)) {
  ------------------
  |  Branch (638:9): [True: 701, False: 12.2k]
  |  Branch (638:23): [True: 276, False: 11.9k]
  ------------------
  639|    977|        return false;
  640|    977|    }
  641|  11.9k|    s2k.specifier = (pgp_s2k_specifier_t) spec;
  642|  11.9k|    s2k.hash_alg = (pgp_hash_alg_t) halg;
  643|       |
  644|  11.9k|    switch (s2k.specifier) {
  645|  3.36k|    case PGP_S2KS_SIMPLE:
  ------------------
  |  Branch (645:5): [True: 3.36k, False: 8.63k]
  ------------------
  646|  3.36k|        return true;
  647|  1.12k|    case PGP_S2KS_SALTED:
  ------------------
  |  Branch (647:5): [True: 1.12k, False: 10.8k]
  ------------------
  648|  1.12k|        return get(s2k.salt, PGP_SALT_SIZE);
  ------------------
  |  |   92|  1.12k|#define PGP_SALT_SIZE 8
  ------------------
  649|  1.11k|    case PGP_S2KS_ITERATED_AND_SALTED: {
  ------------------
  |  Branch (649:5): [True: 1.11k, False: 10.8k]
  ------------------
  650|  1.11k|        uint8_t iter = 0;
  651|  1.11k|        if (!get(s2k.salt, PGP_SALT_SIZE) || !get(iter)) {
  ------------------
  |  |   92|  1.11k|#define PGP_SALT_SIZE 8
  ------------------
  |  Branch (651:13): [True: 266, False: 849]
  |  Branch (651:46): [True: 211, False: 638]
  ------------------
  652|    477|            return false;
  653|    477|        }
  654|    638|        s2k.iterations = iter;
  655|    638|        return true;
  656|  1.11k|    }
  657|  5.78k|    case PGP_S2KS_EXPERIMENTAL: {
  ------------------
  |  Branch (657:5): [True: 5.78k, False: 6.21k]
  ------------------
  658|  5.78k|        try {
  659|  5.78k|            s2k.experimental = {data_.begin() + pos_, data_.end()};
  660|  5.78k|        } 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.78k|        uint8_t gnu[3] = {0};
  665|  5.78k|        if (!get(gnu, 3) || memcmp(gnu, "GNU", 3)) {
  ------------------
  |  Branch (665:13): [True: 1.34k, False: 4.44k]
  |  Branch (665:29): [True: 1.21k, False: 3.22k]
  ------------------
  666|  2.55k|            RNP_LOG("Unknown experimental s2k. Skipping.");
  ------------------
  |  |   76|  2.55k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.55k|    do {                                                                                 \
  |  |  |  |   69|  2.55k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.55k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.55k|            break;                                                                       \
  |  |  |  |   71|  2.55k|        (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.55k|            pos_ = data_.size();
  668|  2.55k|            s2k.gpg_ext_num = PGP_S2K_GPG_NONE;
  669|  2.55k|            return true;
  670|  2.55k|        }
  671|  3.22k|        uint8_t ext_num = 0;
  672|  3.22k|        if (!get(ext_num)) {
  ------------------
  |  Branch (672:13): [True: 220, False: 3.00k]
  ------------------
  673|    220|            return false;
  674|    220|        }
  675|  3.00k|        if ((ext_num != PGP_S2K_GPG_NO_SECRET) && (ext_num != PGP_S2K_GPG_SMARTCARD)) {
  ------------------
  |  Branch (675:13): [True: 2.46k, False: 546]
  |  Branch (675:51): [True: 274, False: 2.18k]
  ------------------
  676|    274|            RNP_LOG("Unsupported gpg extension num: %" PRIu8 ", skipping", ext_num);
  ------------------
  |  |   76|    274|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    274|    do {                                                                                 \
  |  |  |  |   69|    274|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 274, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    274|            break;                                                                       \
  |  |  |  |   71|    274|        (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|    274|            pos_ = data_.size();
  678|    274|            s2k.gpg_ext_num = PGP_S2K_GPG_NONE;
  679|    274|            return true;
  680|    274|        }
  681|  2.73k|        s2k.gpg_ext_num = (pgp_s2k_gpg_extension_t) ext_num;
  682|  2.73k|        if (s2k.gpg_ext_num == PGP_S2K_GPG_NO_SECRET) {
  ------------------
  |  Branch (682:13): [True: 546, False: 2.18k]
  ------------------
  683|    546|            return true;
  684|    546|        }
  685|  2.18k|        if (!get(s2k.gpg_serial_len)) {
  ------------------
  |  Branch (685:13): [True: 94, False: 2.09k]
  ------------------
  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.09k|        size_t len = s2k.gpg_serial_len;
  690|  2.09k|        if (s2k.gpg_serial_len > 16) {
  ------------------
  |  Branch (690:13): [True: 682, False: 1.41k]
  ------------------
  691|    682|            RNP_LOG("Warning: gpg_serial_len is %d", (int) len);
  ------------------
  |  |   76|    682|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    682|    do {                                                                                 \
  |  |  |  |   69|    682|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 682, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    682|            break;                                                                       \
  |  |  |  |   71|    682|        (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|    682|            len = 16;
  693|    682|        }
  694|  2.09k|        if (!get(s2k.gpg_serial, len)) {
  ------------------
  |  Branch (694:13): [True: 216, False: 1.87k]
  ------------------
  695|    216|            RNP_LOG("Failed to get GPG serial");
  ------------------
  |  |   76|    216|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    216|    do {                                                                                 \
  |  |  |  |   69|    216|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 216, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    216|            break;                                                                       \
  |  |  |  |   71|    216|        (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|    216|            return false;
  697|    216|        }
  698|  1.87k|        return true;
  699|  2.09k|    }
  700|    606|    default:
  ------------------
  |  Branch (700:5): [True: 606, False: 11.3k]
  ------------------
  701|    606|        RNP_LOG("unknown s2k specifier: %d", (int) s2k.specifier);
  ------------------
  |  |   76|    606|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    606|    do {                                                                                 \
  |  |  |  |   69|    606|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 606, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    606|            break;                                                                       \
  |  |  |  |   71|    606|        (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|    606|        return false;
  703|  11.9k|    }
  704|  11.9k|}
_ZN17pgp_packet_body_t4readER12pgp_source_t:
  864|   314k|{
  865|       |    /* Make sure we have enough data for packet header */
  866|   314k|    if (!src.peek_eq(hdr_, 2)) {
  ------------------
  |  Branch (866:9): [True: 45, False: 314k]
  ------------------
  867|     45|        return RNP_ERROR_READ;
  868|     45|    }
  869|       |
  870|       |    /* Read the packet header and length */
  871|   314k|    size_t len = 0;
  872|   314k|    if (!stream_pkt_hdr_len(src, len)) {
  ------------------
  |  Branch (872:9): [True: 0, False: 314k]
  ------------------
  873|      0|        return RNP_ERROR_BAD_FORMAT;
  874|      0|    }
  875|   314k|    if (!src.peek_eq(hdr_, len)) {
  ------------------
  |  Branch (875:9): [True: 0, False: 314k]
  ------------------
  876|      0|        return RNP_ERROR_READ;
  877|      0|    }
  878|   314k|    hdr_len_ = len;
  879|       |
  880|   314k|    int ptag = get_packet_type(hdr_[0]);
  881|   314k|    if ((ptag < 0) || ((tag_ != PGP_PKT_RESERVED) && (tag_ != ptag))) {
  ------------------
  |  Branch (881:9): [True: 0, False: 314k]
  |  Branch (881:24): [True: 151k, False: 163k]
  |  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|   314k|    tag_ = (pgp_pkt_type_t) ptag;
  886|       |
  887|   314k|    if (!stream_read_pkt_len(src, &len)) {
  ------------------
  |  Branch (887:9): [True: 17.2k, False: 297k]
  ------------------
  888|  17.2k|        return RNP_ERROR_READ;
  889|  17.2k|    }
  890|       |
  891|       |    /* early exit for the empty packet */
  892|   297k|    if (!len) {
  ------------------
  |  Branch (892:9): [True: 109k, False: 188k]
  ------------------
  893|   109k|        return RNP_SUCCESS;
  894|   109k|    }
  895|       |
  896|   188k|    if (len > PGP_MAX_PKT_SIZE) {
  ------------------
  |  |   39|   188k|#define PGP_MAX_PKT_SIZE 0x100000
  ------------------
  |  Branch (896:9): [True: 3.40k, False: 185k]
  ------------------
  897|  3.40k|        RNP_LOG("too large packet");
  ------------------
  |  |   76|  3.40k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.40k|    do {                                                                                 \
  |  |  |  |   69|  3.40k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.40k|            break;                                                                       \
  |  |  |  |   71|  3.40k|        (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.40k|        return RNP_ERROR_BAD_FORMAT;
  899|  3.40k|    }
  900|       |
  901|       |    /* Read the packet contents */
  902|   185k|    try {
  903|   185k|        data_.resize(len);
  904|   185k|    } 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|   185k|    size_t read = 0;
  910|   185k|    if (!src.read(data_.data(), len, &read) || (read != len)) {
  ------------------
  |  Branch (910:9): [True: 217, False: 184k]
  |  Branch (910:48): [True: 4.12k, False: 180k]
  ------------------
  911|  4.33k|        RNP_LOG("read %d instead of %d", (int) read, (int) len);
  ------------------
  |  |   76|  4.33k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  4.33k|    do {                                                                                 \
  |  |  |  |   69|  4.33k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 4.33k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  4.33k|            break;                                                                       \
  |  |  |  |   71|  4.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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  912|  4.33k|        return RNP_ERROR_READ;
  913|  4.33k|    }
  914|   180k|    pos_ = 0;
  915|   180k|    return RNP_SUCCESS;
  916|   185k|}
_ZN17pgp_packet_body_t5writeER10pgp_dest_tb:
  920|    761|{
  921|    761|    if (hdr) {
  ------------------
  |  Branch (921:9): [True: 0, False: 761]
  ------------------
  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|    761|    dst_write(&dst, data_.data(), data_.size());
  928|    761|}
_ZN16pgp_sk_sesskey_t5parseER12pgp_source_t:
  978|  15.3k|{
  979|  15.3k|    pgp_packet_body_t pkt(PGP_PKT_SK_SESSION_KEY);
  980|  15.3k|    rnp_result_t      res = pkt.read(src);
  981|  15.3k|    if (res) {
  ------------------
  |  Branch (981:9): [True: 2.47k, False: 12.8k]
  ------------------
  982|  2.47k|        return res;
  983|  2.47k|    }
  984|       |
  985|       |    /* version */
  986|  12.8k|    uint8_t bt;
  987|  12.8k|    if (!pkt.get(bt) || ((bt != PGP_SKSK_V4) && (bt != PGP_SKSK_V5))) {
  ------------------
  |  Branch (987:9): [True: 342, False: 12.4k]
  |  Branch (987:26): [True: 3.83k, False: 8.65k]
  |  Branch (987:49): [True: 602, False: 3.23k]
  ------------------
  988|    944|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|    944|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    944|    do {                                                                                 \
  |  |  |  |   69|    944|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 944, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    944|            break;                                                                       \
  |  |  |  |   71|    944|        (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|    944|        return RNP_ERROR_BAD_FORMAT;
  990|    944|    }
  991|  11.8k|    version = bt;
  992|       |    /* symmetric algorithm */
  993|  11.8k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (993:9): [True: 393, False: 11.4k]
  ------------------
  994|    393|        RNP_LOG("failed to get symm alg");
  ------------------
  |  |   76|    393|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    393|    do {                                                                                 \
  |  |  |  |   69|    393|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 393, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    393|            break;                                                                       \
  |  |  |  |   71|    393|        (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|    393|        return RNP_ERROR_BAD_FORMAT;
  996|    393|    }
  997|  11.4k|    alg = (pgp_symm_alg_t) bt;
  998|       |
  999|  11.4k|    if (version == PGP_SKSK_V5) {
  ------------------
  |  Branch (999:9): [True: 2.98k, False: 8.51k]
  ------------------
 1000|       |        /* aead algorithm */
 1001|  2.98k|        if (!pkt.get(bt)) {
  ------------------
  |  Branch (1001:13): [True: 206, False: 2.77k]
  ------------------
 1002|    206|            RNP_LOG("failed to get aead alg");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1003|    206|            return RNP_ERROR_BAD_FORMAT;
 1004|    206|        }
 1005|  2.77k|        aalg = (pgp_aead_alg_t) bt;
 1006|  2.77k|        if ((aalg != PGP_AEAD_EAX) && (aalg != PGP_AEAD_OCB)) {
  ------------------
  |  Branch (1006:13): [True: 1.31k, False: 1.46k]
  |  Branch (1006:39): [True: 306, False: 1.00k]
  ------------------
 1007|    306|            RNP_LOG("unsupported AEAD algorithm : %d", (int) aalg);
  ------------------
  |  |   76|    306|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    306|    do {                                                                                 \
  |  |  |  |   69|    306|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 306, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    306|            break;                                                                       \
  |  |  |  |   71|    306|        (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|    306|            return RNP_ERROR_BAD_PARAMETERS;
 1009|    306|        }
 1010|  2.77k|    }
 1011|       |
 1012|       |    /* s2k */
 1013|  10.9k|    if (!pkt.get(s2k)) {
  ------------------
  |  Branch (1013:9): [True: 2.40k, False: 8.58k]
  ------------------
 1014|  2.40k|        RNP_LOG("failed to parse s2k");
  ------------------
  |  |   76|  2.40k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  2.40k|    do {                                                                                 \
  |  |  |  |   69|  2.40k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 2.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  2.40k|            break;                                                                       \
  |  |  |  |   71|  2.40k|        (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.40k|        return RNP_ERROR_BAD_FORMAT;
 1016|  2.40k|    }
 1017|       |
 1018|       |    /* v4 key */
 1019|  8.58k|    if (version == PGP_SKSK_V4) {
  ------------------
  |  Branch (1019:9): [True: 6.63k, False: 1.95k]
  ------------------
 1020|       |        /* encrypted session key if present */
 1021|  6.63k|        size_t keylen = pkt.left();
 1022|  6.63k|        if (keylen) {
  ------------------
  |  Branch (1022:13): [True: 3.79k, False: 2.83k]
  ------------------
 1023|  3.79k|            if (keylen > PGP_MAX_KEY_SIZE + 1) {
  ------------------
  |  |   89|  3.79k|#define PGP_MAX_KEY_SIZE 32
  ------------------
  |  Branch (1023:17): [True: 282, False: 3.51k]
  ------------------
 1024|    282|                RNP_LOG("too long esk");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1025|    282|                return RNP_ERROR_BAD_FORMAT;
 1026|    282|            }
 1027|  3.51k|            if (!pkt.get(enckey, keylen)) {
  ------------------
  |  Branch (1027:17): [True: 0, False: 3.51k]
  ------------------
 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.51k|        }
 1032|  6.34k|        enckeylen = keylen;
 1033|  6.34k|        return RNP_SUCCESS;
 1034|  6.63k|    }
 1035|       |
 1036|       |    /* v5: iv + esk + tag. For both EAX and OCB ivlen and taglen are 16 octets */
 1037|  1.95k|    size_t noncelen = pgp_cipher_aead_nonce_len(aalg);
 1038|  1.95k|    size_t taglen = pgp_cipher_aead_tag_len(aalg);
 1039|  1.95k|    size_t keylen = 0;
 1040|       |
 1041|  1.95k|    if (pkt.left() > noncelen + taglen + PGP_MAX_KEY_SIZE) {
  ------------------
  |  |   89|  1.95k|#define PGP_MAX_KEY_SIZE 32
  ------------------
  |  Branch (1041:9): [True: 263, False: 1.69k]
  ------------------
 1042|    263|        RNP_LOG("too long esk");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1043|    263|        return RNP_ERROR_BAD_FORMAT;
 1044|    263|    }
 1045|  1.69k|    if (pkt.left() < noncelen + taglen + 8) {
  ------------------
  |  Branch (1045:9): [True: 224, False: 1.46k]
  ------------------
 1046|    224|        RNP_LOG("too short esk");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1047|    224|        return RNP_ERROR_BAD_FORMAT;
 1048|    224|    }
 1049|       |    /* iv */
 1050|  1.46k|    if (!pkt.get(iv, noncelen)) {
  ------------------
  |  Branch (1050:9): [True: 0, False: 1.46k]
  ------------------
 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|  1.46k|    ivlen = noncelen;
 1055|       |
 1056|       |    /* key */
 1057|  1.46k|    keylen = pkt.left();
 1058|  1.46k|    if (!pkt.get(enckey, keylen)) {
  ------------------
  |  Branch (1058:9): [True: 0, False: 1.46k]
  ------------------
 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|  1.46k|    enckeylen = keylen;
 1063|  1.46k|    return RNP_SUCCESS;
 1064|  1.46k|}
_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.52k, False: 15.4k]
  ------------------
 1093|  1.52k|        return res;
 1094|  1.52k|    }
 1095|       |    /* version */
 1096|  15.4k|    uint8_t bt = 0;
 1097|  15.4k|    if (!pkt.get(bt)) {
  ------------------
  |  Branch (1097:9): [True: 372, False: 15.0k]
  ------------------
 1098|    372|        RNP_LOG("Error when reading packet version");
  ------------------
  |  |   76|    372|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    372|    do {                                                                                 \
  |  |  |  |   69|    372|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 372, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    372|            break;                                                                       \
  |  |  |  |   71|    372|        (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|    372|        return RNP_ERROR_BAD_FORMAT;
 1100|    372|    }
 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.57k, False: 9.51k]
  |  Branch (1102:32): [True: 460, False: 5.11k]
  ------------------
 1103|       |#else
 1104|       |    if ((bt != PGP_PKSK_V3)) {
 1105|       |#endif
 1106|    460|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|    460|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    460|    do {                                                                                 \
  |  |  |  |   69|    460|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 460, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    460|            break;                                                                       \
  |  |  |  |   71|    460|        (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|    460|        return RNP_ERROR_BAD_FORMAT;
 1108|    460|    }
 1109|  14.6k|    version = (pgp_pkesk_version_t) bt;
 1110|       |
 1111|  14.6k|#if defined(ENABLE_CRYPTO_REFRESH)
 1112|  14.6k|    if (version == PGP_PKSK_V3)
  ------------------
  |  Branch (1112:9): [True: 9.51k, False: 5.11k]
  ------------------
 1113|  9.51k|#endif
 1114|  9.51k|    {
 1115|       |        /* key id */
 1116|  9.51k|        if (!pkt.get(key_id)) {
  ------------------
  |  Branch (1116:13): [True: 228, False: 9.28k]
  ------------------
 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.51k|    }
 1121|  5.11k|#if defined(ENABLE_CRYPTO_REFRESH)
 1122|  5.11k|    else {                          // PGP_PKSK_V6
 1123|  5.11k|        uint8_t fp_and_key_ver_len; // A one-octet size of the following two fields.
 1124|  5.11k|        if (!pkt.get(fp_and_key_ver_len)) {
  ------------------
  |  Branch (1124:13): [True: 214, False: 4.90k]
  ------------------
 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.90k|        if ((fp_and_key_ver_len != 1 + PGP_FINGERPRINT_V4_SIZE) &&
  ------------------
  |  |   43|  4.90k|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
  |  Branch (1128:13): [True: 3.78k, False: 1.11k]
  ------------------
 1129|  3.78k|            (fp_and_key_ver_len != 1 + PGP_FINGERPRINT_V6_SIZE)) {
  ------------------
  |  |   51|  3.78k|#define PGP_FINGERPRINT_V6_SIZE 32
  ------------------
  |  Branch (1129:13): [True: 238, False: 3.54k]
  ------------------
 1130|    238|            RNP_LOG("Invalid size for key version + length field");
  ------------------
  |  |   76|    238|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    238|    do {                                                                                 \
  |  |  |  |   69|    238|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 238, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    238|            break;                                                                       \
  |  |  |  |   71|    238|        (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|    238|            return RNP_ERROR_BAD_FORMAT;
 1132|    238|        }
 1133|       |
 1134|  4.66k|        size_t  fp_len;
 1135|  4.66k|        uint8_t fp_key_version;
 1136|  4.66k|        if (!pkt.get(fp_key_version)) {
  ------------------
  |  Branch (1136:13): [True: 340, False: 4.32k]
  ------------------
 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.32k|        switch (fp_key_version) {
 1141|    880|        case 0: // anonymous
  ------------------
  |  Branch (1141:9): [True: 880, False: 3.44k]
  ------------------
 1142|    880|            fp_len = 0;
 1143|    880|            break;
 1144|    867|        case PGP_V4:
  ------------------
  |  Branch (1144:9): [True: 867, False: 3.45k]
  ------------------
 1145|    867|            fp_len = PGP_FINGERPRINT_V4_SIZE;
  ------------------
  |  |   43|    867|#define PGP_FINGERPRINT_V4_SIZE 20
  ------------------
 1146|    867|            break;
 1147|  2.30k|        case PGP_V6:
  ------------------
  |  Branch (1147:9): [True: 2.30k, False: 2.01k]
  ------------------
 1148|  2.30k|            fp_len = PGP_FINGERPRINT_V6_SIZE;
  ------------------
  |  |   51|  2.30k|#define PGP_FINGERPRINT_V6_SIZE 32
  ------------------
 1149|  2.30k|            break;
 1150|    272|        default:
  ------------------
  |  Branch (1150:9): [True: 272, False: 4.05k]
  ------------------
 1151|    272|            RNP_LOG("wrong key version used with PKESK v6");
  ------------------
  |  |   76|    272|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    272|    do {                                                                                 \
  |  |  |  |   69|    272|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 272, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    272|            break;                                                                       \
  |  |  |  |   71|    272|        (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|    272|            return RNP_ERROR_BAD_FORMAT;
 1153|  4.32k|        }
 1154|  4.05k|        if (fp_len && (fp_len + 1 != fp_and_key_ver_len)) {
  ------------------
  |  Branch (1154:13): [True: 3.17k, False: 880]
  |  Branch (1154:23): [True: 276, False: 2.89k]
  ------------------
 1155|    276|            RNP_LOG("size mismatch (fingerprint size and fp+key version length field)");
  ------------------
  |  |   76|    276|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    276|    do {                                                                                 \
  |  |  |  |   69|    276|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 276, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    276|            break;                                                                       \
  |  |  |  |   71|    276|        (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|    276|            return RNP_ERROR_BAD_FORMAT;
 1157|    276|        }
 1158|  3.77k|        std::vector<uint8_t> vec(fp_len, 0);
 1159|  3.77k|        if (!pkt.get(vec.data(), vec.size())) {
  ------------------
  |  Branch (1159:13): [True: 281, False: 3.49k]
  ------------------
 1160|    281|            RNP_LOG("Error when reading fingerprint");
  ------------------
  |  |   76|    281|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    281|    do {                                                                                 \
  |  |  |  |   69|    281|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 281, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    281|            break;                                                                       \
  |  |  |  |   71|    281|        (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|    281|            return RNP_ERROR_BAD_FORMAT;
 1162|    281|        }
 1163|  3.49k|        fp = pgp::Fingerprint(vec.data(), vec.size());
 1164|  3.49k|    }
 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: 5.88k, False: 6.37k]
  ------------------
 1192|  5.88k|        return RNP_ERROR_BAD_FORMAT;
 1193|  5.88k|    }
 1194|  6.37k|    return RNP_SUCCESS;
 1195|  12.2k|}
_ZNK16pgp_pk_sesskey_t14parse_materialEv:
 1199|  18.6k|{
 1200|  18.6k|    auto enc = pgp::EncMaterial::create(alg);
 1201|  18.6k|    if (!enc) {
  ------------------
  |  Branch (1201:9): [True: 468, False: 18.1k]
  ------------------
 1202|    468|        return nullptr;
 1203|    468|    }
 1204|  18.1k|#if defined(ENABLE_CRYPTO_REFRESH)
 1205|  18.1k|    enc->version = version;
 1206|  18.1k|#endif
 1207|  18.1k|    pgp_packet_body_t pkt(material_buf);
 1208|  18.1k|    if (!enc->parse(pkt)) {
  ------------------
  |  Branch (1208:9): [True: 4.22k, False: 13.9k]
  ------------------
 1209|  4.22k|        return nullptr;
 1210|  4.22k|    }
 1211|  13.9k|    if (pkt.left()) {
  ------------------
  |  Branch (1211:9): [True: 1.18k, False: 12.7k]
  ------------------
 1212|  1.18k|        RNP_LOG("extra %zu bytes in pk packet", pkt.left());
  ------------------
  |  |   76|  1.18k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.18k|    do {                                                                                 \
  |  |  |  |   69|  1.18k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.18k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.18k|            break;                                                                       \
  |  |  |  |   71|  1.18k|        (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.18k|        return nullptr;
 1214|  1.18k|    }
 1215|  12.7k|    return enc;
 1216|  13.9k|}
_ZN18pgp_one_pass_sig_t5parseER12pgp_source_t:
 1241|  2.46k|{
 1242|  2.46k|    pgp_packet_body_t pkt(PGP_PKT_ONE_PASS_SIG);
 1243|       |    /* Read the packet into memory */
 1244|  2.46k|    rnp_result_t res = pkt.read(src);
 1245|  2.46k|    if (res) {
  ------------------
  |  Branch (1245:9): [True: 747, False: 1.72k]
  ------------------
 1246|    747|        return res;
 1247|    747|    }
 1248|       |
 1249|  1.72k|    uint8_t buf[13] = {0};
 1250|  1.72k|    if ((pkt.size() != 13) || !pkt.get(buf, 13)) {
  ------------------
  |  Branch (1250:9): [True: 575, False: 1.14k]
  |  Branch (1250:31): [True: 0, False: 1.14k]
  ------------------
 1251|    575|        return RNP_ERROR_BAD_FORMAT;
 1252|    575|    }
 1253|       |    /* version */
 1254|  1.14k|    if (buf[0] != 3) {
  ------------------
  |  Branch (1254:9): [True: 342, False: 803]
  ------------------
 1255|    342|        RNP_LOG("wrong packet version");
  ------------------
  |  |   76|    342|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    342|    do {                                                                                 \
  |  |  |  |   69|    342|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 342, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    342|            break;                                                                       \
  |  |  |  |   71|    342|        (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|    342|        return RNP_ERROR_BAD_FORMAT;
 1257|    342|    }
 1258|    803|    version = buf[0];
 1259|       |    /* signature type */
 1260|    803|    type = (pgp_sig_type_t) buf[1];
 1261|       |    /* hash algorithm */
 1262|    803|    halg = (pgp_hash_alg_t) buf[2];
 1263|       |    /* pk algorithm */
 1264|    803|    palg = (pgp_pubkey_alg_t) buf[3];
 1265|       |    /* key id */
 1266|    803|    static_assert(std::tuple_size<decltype(keyid)>::value == PGP_KEY_ID_SIZE,
 1267|    803|                  "pgp_one_pass_sig_t.keyid size mismatch");
 1268|    803|    memcpy(keyid.data(), &buf[4], PGP_KEY_ID_SIZE);
  ------------------
  |  |   39|    803|#define PGP_KEY_ID_SIZE 8
  ------------------
 1269|       |    /* nested flag */
 1270|    803|    nested = buf[12];
 1271|    803|    return RNP_SUCCESS;
 1272|  1.14k|}
stream-packet.cpp:_ZL11get_pkt_lenPhPm:
  138|   622k|{
  139|   622k|    if (hdr[0] & PGP_PTAG_NEW_FORMAT) {
  ------------------
  |  |   56|   622k|#define PGP_PTAG_NEW_FORMAT 0x40
  ------------------
  |  Branch (139:9): [True: 443k, False: 178k]
  ------------------
  140|       |        // 1-byte length
  141|   443k|        if (hdr[1] < 192) {
  ------------------
  |  Branch (141:13): [True: 411k, False: 32.4k]
  ------------------
  142|   411k|            *pktlen = hdr[1];
  143|   411k|            return true;
  144|   411k|        }
  145|       |        // 2-byte length
  146|  32.4k|        if (hdr[1] < 224) {
  ------------------
  |  Branch (146:13): [True: 30.8k, False: 1.58k]
  ------------------
  147|  30.8k|            *pktlen = ((size_t)(hdr[1] - 192) << 8) + (size_t) hdr[2] + 192;
  148|  30.8k|            return true;
  149|  30.8k|        }
  150|       |        // partial length - we do not allow it here
  151|  1.58k|        if (hdr[1] < 255) {
  ------------------
  |  Branch (151:13): [True: 318, False: 1.26k]
  ------------------
  152|    318|            return false;
  153|    318|        }
  154|       |        // 4-byte length
  155|  1.26k|        *pktlen = read_uint32(&hdr[2]);
  156|  1.26k|        return true;
  157|  1.58k|    }
  158|       |
  159|   178k|    switch (hdr[0] & PGP_PTAG_OF_LENGTH_TYPE_MASK) {
  ------------------
  |  |   83|   178k|#define PGP_PTAG_OF_LENGTH_TYPE_MASK 0x03
  ------------------
  160|   125k|    case PGP_PTAG_OLD_LEN_1:
  ------------------
  |  Branch (160:5): [True: 125k, False: 53.0k]
  ------------------
  161|   125k|        *pktlen = hdr[1];
  162|   125k|        return true;
  163|  28.8k|    case PGP_PTAG_OLD_LEN_2:
  ------------------
  |  Branch (163:5): [True: 28.8k, False: 149k]
  ------------------
  164|  28.8k|        *pktlen = read_uint16(&hdr[1]);
  165|  28.8k|        return true;
  166|  7.18k|    case PGP_PTAG_OLD_LEN_4:
  ------------------
  |  Branch (166:5): [True: 7.18k, False: 171k]
  ------------------
  167|  7.18k|        *pktlen = read_uint32(&hdr[1]);
  168|  7.18k|        return true;
  169|  16.9k|    default:
  ------------------
  |  Branch (169:5): [True: 16.9k, False: 161k]
  ------------------
  170|  16.9k|        return false;
  171|   178k|    }
  172|   178k|}
stream-packet.cpp:_ZL26stream_read_packet_partialP12pgp_source_tP10pgp_dest_t:
  301|  4.79k|{
  302|  4.79k|    uint8_t hdr = 0;
  303|  4.79k|    if (!src->read_eq(&hdr, 1)) {
  ------------------
  |  Branch (303:9): [True: 0, False: 4.79k]
  ------------------
  304|      0|        return RNP_ERROR_READ;
  305|      0|    }
  306|       |
  307|  4.79k|    bool   last = false;
  308|  4.79k|    size_t partlen = 0;
  309|  4.79k|    if (!stream_read_partial_chunk_len(src, &partlen, &last)) {
  ------------------
  |  Branch (309:9): [True: 0, False: 4.79k]
  ------------------
  310|      0|        return RNP_ERROR_BAD_FORMAT;
  311|      0|    }
  312|       |
  313|  4.79k|    uint8_t *buf = (uint8_t *) malloc(PGP_INPUT_CACHE_SIZE);
  ------------------
  |  |   35|  4.79k|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  314|  4.79k|    if (!buf) {
  ------------------
  |  Branch (314:9): [True: 0, False: 4.79k]
  ------------------
  315|      0|        return RNP_ERROR_OUT_OF_MEMORY;
  316|      0|    }
  317|       |
  318|  22.3M|    while (partlen > 0) {
  ------------------
  |  Branch (318:12): [True: 22.3M, False: 481]
  ------------------
  319|  22.3M|        size_t read = std::min(partlen, (size_t) PGP_INPUT_CACHE_SIZE);
  ------------------
  |  |   35|  22.3M|#define PGP_INPUT_CACHE_SIZE 32768
  ------------------
  320|  22.3M|        if (!src->read_eq(buf, read)) {
  ------------------
  |  Branch (320:13): [True: 715, False: 22.3M]
  ------------------
  321|    715|            free(buf);
  322|    715|            return RNP_ERROR_READ;
  323|    715|        }
  324|  22.3M|        if (dst) {
  ------------------
  |  Branch (324:13): [True: 14.0M, False: 8.34M]
  ------------------
  325|  14.0M|            dst_write(dst, buf, read);
  326|  14.0M|        }
  327|  22.3M|        partlen -= read;
  328|  22.3M|        if (partlen > 0) {
  ------------------
  |  Branch (328:13): [True: 2.98k, False: 22.3M]
  ------------------
  329|  2.98k|            continue;
  330|  2.98k|        }
  331|  22.3M|        if (last) {
  ------------------
  |  Branch (331:13): [True: 3.40k, False: 22.3M]
  ------------------
  332|  3.40k|            break;
  333|  3.40k|        }
  334|  22.3M|        if (!stream_read_partial_chunk_len(src, &partlen, &last)) {
  ------------------
  |  Branch (334:13): [True: 199, False: 22.3M]
  ------------------
  335|    199|            free(buf);
  336|    199|            return RNP_ERROR_BAD_FORMAT;
  337|    199|        }
  338|  22.3M|    }
  339|  3.88k|    free(buf);
  340|  3.88k|    return RNP_SUCCESS;
  341|  4.79k|}

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

_Z16init_literal_srcP12pgp_source_tS0_:
 1810|  1.68k|{
 1811|  1.68k|    rnp_result_t                ret = RNP_ERROR_GENERIC;
 1812|  1.68k|    pgp_source_literal_param_t *param;
 1813|  1.68k|    uint8_t                     format = 0;
 1814|  1.68k|    uint8_t                     nlen = 0;
 1815|  1.68k|    uint8_t                     timestamp[4];
 1816|       |
 1817|  1.68k|    if (!init_src_common(src, sizeof(*param))) {
  ------------------
  |  Branch (1817:9): [True: 0, False: 1.68k]
  ------------------
 1818|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1819|      0|    }
 1820|       |
 1821|  1.68k|    param = (pgp_source_literal_param_t *) src->param;
 1822|  1.68k|    param->pkt.readsrc = readsrc;
 1823|  1.68k|    src->raw_read = literal_src_read;
 1824|  1.68k|    src->raw_close = literal_src_close;
 1825|  1.68k|    src->type = PGP_STREAM_LITERAL;
 1826|       |
 1827|       |    /* Reading packet length/checking whether it is partial */
 1828|  1.68k|    if ((ret = init_packet_params(param->pkt))) {
  ------------------
  |  Branch (1828:9): [True: 14, False: 1.67k]
  ------------------
 1829|     14|        goto finish;
 1830|     14|    }
 1831|       |
 1832|       |    /* data format */
 1833|  1.67k|    if (!param->pkt.readsrc->read_eq(&format, 1)) {
  ------------------
  |  Branch (1833:9): [True: 90, False: 1.58k]
  ------------------
 1834|     90|        RNP_LOG("failed to read data format");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1835|     90|        ret = RNP_ERROR_READ;
 1836|     90|        goto finish;
 1837|     90|    }
 1838|       |
 1839|  1.58k|    switch (format) {
 1840|    119|    case 'b':
  ------------------
  |  Branch (1840:5): [True: 119, False: 1.46k]
  ------------------
 1841|    209|    case 't':
  ------------------
  |  Branch (1841:5): [True: 90, False: 1.49k]
  ------------------
 1842|    291|    case 'u':
  ------------------
  |  Branch (1842:5): [True: 82, False: 1.50k]
  ------------------
 1843|    374|    case 'l':
  ------------------
  |  Branch (1843:5): [True: 83, False: 1.50k]
  ------------------
 1844|    521|    case '1':
  ------------------
  |  Branch (1844:5): [True: 147, False: 1.43k]
  ------------------
 1845|    610|    case 'm':
  ------------------
  |  Branch (1845:5): [True: 89, False: 1.49k]
  ------------------
 1846|    610|        break;
 1847|    975|    default:
  ------------------
  |  Branch (1847:5): [True: 975, False: 610]
  ------------------
 1848|    975|        RNP_LOG("Warning: unknown data format %" PRIu8 ", ignoring.", format);
  ------------------
  |  |   76|    975|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    975|    do {                                                                                 \
  |  |  |  |   69|    975|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 975, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    975|            break;                                                                       \
  |  |  |  |   71|    975|        (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|    975|        break;
 1850|  1.58k|    }
 1851|  1.58k|    param->hdr.format = format;
 1852|       |    /* file name */
 1853|  1.58k|    if (!param->pkt.readsrc->read_eq(&nlen, 1)) {
  ------------------
  |  Branch (1853:9): [True: 165, False: 1.42k]
  ------------------
 1854|    165|        RNP_LOG("failed to read file name length");
  ------------------
  |  |   76|    165|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    165|    do {                                                                                 \
  |  |  |  |   69|    165|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 165, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    165|            break;                                                                       \
  |  |  |  |   71|    165|        (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|    165|        ret = RNP_ERROR_READ;
 1856|    165|        goto finish;
 1857|    165|    }
 1858|  1.42k|    if (nlen && !param->pkt.readsrc->read_eq(param->hdr.fname, nlen)) {
  ------------------
  |  Branch (1858:9): [True: 1.02k, False: 394]
  |  Branch (1858:17): [True: 149, False: 877]
  ------------------
 1859|    149|        RNP_LOG("failed to read file name");
  ------------------
  |  |   76|    149|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    149|    do {                                                                                 \
  |  |  |  |   69|    149|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 149, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    149|            break;                                                                       \
  |  |  |  |   71|    149|        (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|    149|        ret = RNP_ERROR_READ;
 1861|    149|        goto finish;
 1862|    149|    }
 1863|  1.27k|    param->hdr.fname[nlen] = 0;
 1864|  1.27k|    param->hdr.fname_len = nlen;
 1865|       |    /* timestamp */
 1866|  1.27k|    if (!param->pkt.readsrc->read_eq(timestamp, 4)) {
  ------------------
  |  Branch (1866:9): [True: 83, False: 1.18k]
  ------------------
 1867|     83|        RNP_LOG("failed to read file timestamp");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1868|     83|        ret = RNP_ERROR_READ;
 1869|     83|        goto finish;
 1870|     83|    }
 1871|  1.18k|    param->hdr.timestamp = read_uint32(timestamp);
 1872|       |
 1873|  1.18k|    if (!param->pkt.hdr.indeterminate && !param->pkt.hdr.partial) {
  ------------------
  |  Branch (1873:9): [True: 1.11k, False: 75]
  |  Branch (1873:42): [True: 989, False: 124]
  ------------------
 1874|       |        /* format filename-length filename timestamp */
 1875|    989|        const uint16_t nbytes = 1 + 1 + nlen + 4;
 1876|    989|        if (param->pkt.hdr.pkt_len < nbytes) {
  ------------------
  |  Branch (1876:13): [True: 519, False: 470]
  ------------------
 1877|    519|            ret = RNP_ERROR_BAD_FORMAT;
 1878|    519|            goto finish;
 1879|    519|        }
 1880|    470|        src->size = param->pkt.hdr.pkt_len - nbytes;
 1881|    470|        src->knownsize = 1;
 1882|    470|    }
 1883|    669|    ret = RNP_SUCCESS;
 1884|  1.68k|finish:
 1885|  1.68k|    if (ret) {
  ------------------
  |  Branch (1885:9): [True: 1.02k, False: 669]
  ------------------
 1886|  1.02k|        src->close();
 1887|  1.02k|    }
 1888|  1.68k|    return ret;
 1889|    669|}
_Z19get_literal_src_hdrR12pgp_source_t:
 1893|    669|{
 1894|    669|    return (static_cast<pgp_source_literal_param_t *>(src.param))->hdr;
 1895|    669|}
_Z19init_compressed_srcP12pgp_source_tS0_:
 1899|  20.9k|{
 1900|  20.9k|    rnp_result_t                   errcode = RNP_ERROR_GENERIC;
 1901|  20.9k|    pgp_source_compressed_param_t *param;
 1902|  20.9k|    uint8_t                        alg;
 1903|  20.9k|    int                            zret;
 1904|       |
 1905|  20.9k|    if (!init_src_common(src, sizeof(*param))) {
  ------------------
  |  Branch (1905:9): [True: 0, False: 20.9k]
  ------------------
 1906|      0|        return RNP_ERROR_OUT_OF_MEMORY; // LCOV_EXCL_LINE
 1907|      0|    }
 1908|       |
 1909|  20.9k|    param = (pgp_source_compressed_param_t *) src->param;
 1910|  20.9k|    param->pkt.readsrc = readsrc;
 1911|  20.9k|    src->raw_read = compressed_src_read;
 1912|  20.9k|    src->raw_close = compressed_src_close;
 1913|  20.9k|    src->type = PGP_STREAM_COMPRESSED;
 1914|       |
 1915|       |    /* Reading packet length/checking whether it is partial */
 1916|  20.9k|    errcode = init_packet_params(param->pkt);
 1917|  20.9k|    if (errcode != RNP_SUCCESS) {
  ------------------
  |  Branch (1917:9): [True: 13, False: 20.9k]
  ------------------
 1918|     13|        goto finish;
 1919|     13|    }
 1920|       |
 1921|       |    /* Reading compression algorithm */
 1922|  20.9k|    if (!param->pkt.readsrc->read_eq(&alg, 1)) {
  ------------------
  |  Branch (1922:9): [True: 250, False: 20.7k]
  ------------------
 1923|    250|        RNP_LOG("failed to read compression algorithm");
  ------------------
  |  |   76|    250|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    250|    do {                                                                                 \
  |  |  |  |   69|    250|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 250, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    250|            break;                                                                       \
  |  |  |  |   71|    250|        (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|    250|        errcode = RNP_ERROR_READ;
 1925|    250|        goto finish;
 1926|    250|    }
 1927|       |
 1928|       |    /* Initializing decompression */
 1929|  20.7k|    switch (alg) {
 1930|  6.65k|    case PGP_C_NONE:
  ------------------
  |  Branch (1930:5): [True: 6.65k, False: 14.0k]
  ------------------
 1931|  6.65k|        break;
 1932|  12.8k|    case PGP_C_ZIP:
  ------------------
  |  Branch (1932:5): [True: 12.8k, False: 7.85k]
  ------------------
 1933|  12.9k|    case PGP_C_ZLIB:
  ------------------
  |  Branch (1933:5): [True: 113, False: 20.6k]
  ------------------
 1934|  12.9k|        (void) memset(&param->z, 0x0, sizeof(param->z));
 1935|  12.9k|        zret =
 1936|  12.9k|          alg == PGP_C_ZIP ? (int) inflateInit2(&param->z, -15) : (int) inflateInit(&param->z);
  ------------------
  |  Branch (1936:11): [True: 12.8k, False: 113]
  ------------------
 1937|  12.9k|        if (zret != Z_OK) {
  ------------------
  |  Branch (1937:13): [True: 0, False: 12.9k]
  ------------------
 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.9k|        break;
 1943|  12.9k|#ifdef HAVE_BZLIB_H
 1944|  12.9k|    case PGP_C_BZIP2:
  ------------------
  |  Branch (1944:5): [True: 343, False: 20.3k]
  ------------------
 1945|    343|        (void) memset(&param->bz, 0x0, sizeof(param->bz));
 1946|    343|        zret = BZ2_bzDecompressInit(&param->bz, 0, 0);
 1947|    343|        if (zret != BZ_OK) {
  ------------------
  |  Branch (1947:13): [True: 0, False: 343]
  ------------------
 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|    343|        break;
 1953|    343|#endif
 1954|    743|    default:
  ------------------
  |  Branch (1954:5): [True: 743, False: 19.9k]
  ------------------
 1955|    743|        RNP_LOG("unknown compression algorithm: %d", (int) alg);
  ------------------
  |  |   76|    743|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    743|    do {                                                                                 \
  |  |  |  |   69|    743|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 743, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    743|            break;                                                                       \
  |  |  |  |   71|    743|        (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|    743|        errcode = RNP_ERROR_BAD_FORMAT;
 1957|    743|        goto finish;
 1958|  20.7k|    }
 1959|  19.9k|    param->alg = (pgp_compression_type_t) alg;
 1960|  19.9k|    param->inlen = 0;
 1961|  19.9k|    param->inpos = 0;
 1962|       |
 1963|  19.9k|    errcode = RNP_SUCCESS;
 1964|  20.9k|finish:
 1965|  20.9k|    if (errcode != RNP_SUCCESS) {
  ------------------
  |  Branch (1965:9): [True: 1.00k, False: 19.9k]
  ------------------
 1966|  1.00k|        src->close();
 1967|  1.00k|    }
 1968|  20.9k|    return errcode;
 1969|  19.9k|}
_Z22get_compressed_src_algP12pgp_source_tPh:
 1973|  19.9k|{
 1974|  19.9k|    pgp_source_compressed_param_t *param;
 1975|       |
 1976|  19.9k|    if (src->type != PGP_STREAM_COMPRESSED) {
  ------------------
  |  Branch (1976:9): [True: 0, False: 19.9k]
  ------------------
 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|  19.9k|    param = (pgp_source_compressed_param_t *) src->param;
 1982|  19.9k|    *alg = param->alg;
 1983|  19.9k|    return true;
 1984|  19.9k|}
_Z16get_aead_src_hdrP12pgp_source_tP14pgp_aead_hdr_t:
 2021|    764|{
 2022|    764|    uint8_t hdrbt[4] = {0};
 2023|       |
 2024|    764|    if (!src->read_eq(hdrbt, 4)) {
  ------------------
  |  Branch (2024:9): [True: 186, False: 578]
  ------------------
 2025|    186|        return false;
 2026|    186|    }
 2027|       |
 2028|    578|    hdr->version = hdrbt[0];
 2029|    578|    hdr->ealg = (pgp_symm_alg_t) hdrbt[1];
 2030|    578|    hdr->aalg = (pgp_aead_alg_t) hdrbt[2];
 2031|    578|    hdr->csize = hdrbt[3];
 2032|       |
 2033|    578|    if (!(hdr->ivlen = pgp_cipher_aead_nonce_len(hdr->aalg))) {
  ------------------
  |  Branch (2033:9): [True: 424, False: 154]
  ------------------
 2034|    424|        RNP_LOG("wrong aead nonce length: alg %d", (int) hdr->aalg);
  ------------------
  |  |   76|    424|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    424|    do {                                                                                 \
  |  |  |  |   69|    424|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 424, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    424|            break;                                                                       \
  |  |  |  |   71|    424|        (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|    424|        return false;
 2036|    424|    }
 2037|       |
 2038|    154|    return src->read_eq(hdr->iv, hdr->ivlen);
 2039|    578|}
stream-parse.cpp:_ZL16literal_src_readP12pgp_source_tPvmPm:
  327|   559k|{
  328|   559k|    pgp_source_literal_param_t *param = (pgp_source_literal_param_t *) src->param;
  329|   559k|    if (!param) {
  ------------------
  |  Branch (329:9): [True: 0, False: 559k]
  ------------------
  330|      0|        return false;
  331|      0|    }
  332|   559k|    return param->pkt.readsrc->read(buf, len, read);
  333|   559k|}
stream-parse.cpp:_ZL17literal_src_closeP12pgp_source_t:
  337|  2.70k|{
  338|  2.70k|    pgp_source_literal_param_t *param = (pgp_source_literal_param_t *) src->param;
  339|  2.70k|    if (param) {
  ------------------
  |  Branch (339:9): [True: 1.68k, False: 1.02k]
  ------------------
  340|  1.68k|        if (param->pkt.hdr.partial) {
  ------------------
  |  Branch (340:13): [True: 456, False: 1.23k]
  ------------------
  341|    456|            param->pkt.readsrc->close();
  342|    456|            free(param->pkt.readsrc);
  343|    456|            param->pkt.readsrc = NULL;
  344|    456|        }
  345|       |
  346|  1.68k|        free(src->param);
  347|       |        src->param = NULL;
  348|  1.68k|    }
  349|  2.70k|}
stream-parse.cpp:_ZL18init_packet_paramsR25pgp_source_packet_param_t:
 1780|  22.6k|{
 1781|  22.6k|    param.origsrc = NULL;
 1782|       |
 1783|       |    /* save packet header */
 1784|  22.6k|    rnp_result_t ret = stream_peek_packet_hdr(param.readsrc, &param.hdr);
 1785|  22.6k|    if (ret) {
  ------------------
  |  Branch (1785:9): [True: 27, False: 22.6k]
  ------------------
 1786|     27|        return ret;
 1787|     27|    }
 1788|  22.6k|    param.readsrc->skip(param.hdr.hdr_len);
 1789|  22.6k|    if (!param.hdr.partial) {
  ------------------
  |  Branch (1789:9): [True: 13.8k, False: 8.82k]
  ------------------
 1790|  13.8k|        return RNP_SUCCESS;
 1791|  13.8k|    }
 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.09k, False: 1.73k]
  ------------------
  317|  7.09k|        RNP_LOG("first part of partial length packet sequence has size %d and that's less "
  ------------------
  |  |   76|  7.09k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  7.09k|    do {                                                                                 \
  |  |  |  |   69|  7.09k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 7.09k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  7.09k|            break;                                                                       \
  |  |  |  |   71|  7.09k|        (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.09k|                "than allowed by the protocol",
  319|  7.09k|                (int) param->psize);
  320|  7.09k|    }
  321|       |
  322|  8.82k|    return RNP_SUCCESS;
  323|  8.82k|}
stream-parse.cpp:_ZL20partial_pkt_src_readP12pgp_source_tPvmPm:
  232|   579k|{
  233|   579k|    if (src->eof_) {
  ------------------
  |  Branch (233:9): [True: 0, False: 579k]
  ------------------
  234|      0|        *readres = 0;
  235|      0|        return true;
  236|      0|    }
  237|       |
  238|   579k|    pgp_source_partial_param_t *param = (pgp_source_partial_param_t *) src->param;
  239|   579k|    if (!param) {
  ------------------
  |  Branch (239:9): [True: 0, False: 579k]
  ------------------
  240|      0|        return false;
  241|      0|    }
  242|       |
  243|   579k|    size_t read;
  244|   579k|    size_t write = 0;
  245|  1.74M|    while (len > 0) {
  ------------------
  |  Branch (245:12): [True: 1.18M, False: 562k]
  ------------------
  246|  1.18M|        if (!param->pleft && param->last) {
  ------------------
  |  Branch (246:13): [True: 607k, False: 577k]
  |  Branch (246:30): [True: 6.38k, False: 601k]
  ------------------
  247|       |            // we have the last chunk
  248|  6.38k|            *readres = write;
  249|  6.38k|            return true;
  250|  6.38k|        }
  251|  1.17M|        if (!param->pleft) {
  ------------------
  |  Branch (251:13): [True: 601k, False: 577k]
  ------------------
  252|       |            // reading next chunk
  253|   601k|            if (!stream_read_partial_chunk_len(param->readsrc, &read, &param->last)) {
  ------------------
  |  Branch (253:17): [True: 118, False: 601k]
  ------------------
  254|    118|                return false;
  255|    118|            }
  256|   601k|            param->psize = read;
  257|   601k|            param->pleft = read;
  258|   601k|        }
  259|       |
  260|  1.17M|        if (!param->pleft) {
  ------------------
  |  Branch (260:13): [True: 3.28k, False: 1.17M]
  ------------------
  261|  3.28k|            *readres = write;
  262|  3.28k|            return true;
  263|  3.28k|        }
  264|       |
  265|  1.17M|        read = param->pleft > len ? len : param->pleft;
  ------------------
  |  Branch (265:16): [True: 566k, False: 608k]
  ------------------
  266|  1.17M|        if (!param->readsrc->read(buf, read, &read)) {
  ------------------
  |  Branch (266:13): [True: 158, False: 1.17M]
  ------------------
  267|    158|            RNP_LOG("failed to read data chunk");
  ------------------
  |  |   76|    158|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    158|    do {                                                                                 \
  |  |  |  |   69|    158|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 158, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    158|            break;                                                                       \
  |  |  |  |   71|    158|        (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|    158|            return false;
  269|    158|        }
  270|  1.17M|        if (!read) {
  ------------------
  |  Branch (270:13): [True: 7.09k, False: 1.16M]
  ------------------
  271|  7.09k|            RNP_LOG("unexpected eof");
  ------------------
  |  |   76|  7.09k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  7.09k|    do {                                                                                 \
  |  |  |  |   69|  7.09k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 7.09k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  7.09k|            break;                                                                       \
  |  |  |  |   71|  7.09k|        (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.09k|            *readres = write;
  273|  7.09k|            return true;
  274|  7.09k|        }
  275|  1.16M|        write += read;
  276|  1.16M|        len -= read;
  277|  1.16M|        buf = (uint8_t *) buf + read;
  278|  1.16M|        param->pleft -= read;
  279|  1.16M|    }
  280|       |
  281|   562k|    *readres = write;
  282|   562k|    return true;
  283|   579k|}
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|   938k|{
  354|   938k|    pgp_source_compressed_param_t *param = (pgp_source_compressed_param_t *) src->param;
  355|   938k|    if (!param) {
  ------------------
  |  Branch (355:9): [True: 0, False: 938k]
  ------------------
  356|      0|        return false; // LCOV_EXCL_LINE
  357|      0|    }
  358|       |
  359|   938k|    if (src->eof_ || param->zend) {
  ------------------
  |  Branch (359:9): [True: 0, False: 938k]
  |  Branch (359:22): [True: 102k, False: 836k]
  ------------------
  360|   102k|        *readres = 0;
  361|   102k|        return true;
  362|   102k|    }
  363|       |
  364|   836k|    if (param->alg == PGP_C_NONE) {
  ------------------
  |  Branch (364:9): [True: 56.8k, False: 779k]
  ------------------
  365|  56.8k|        if (!param->pkt.readsrc->read(buf, len, readres)) {
  ------------------
  |  Branch (365:13): [True: 375, False: 56.4k]
  ------------------
  366|    375|            RNP_LOG("failed to read uncompressed data");
  ------------------
  |  |   76|    375|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    375|    do {                                                                                 \
  |  |  |  |   69|    375|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 375, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    375|            break;                                                                       \
  |  |  |  |   71|    375|        (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|    375|            return false;
  368|    375|        }
  369|  56.4k|        return true;
  370|  56.8k|    }
  371|   779k|    if ((param->alg == PGP_C_ZIP) || (param->alg == PGP_C_ZLIB)) {
  ------------------
  |  Branch (371:9): [True: 205k, False: 574k]
  |  Branch (371:38): [True: 247, False: 574k]
  ------------------
  372|   205k|        param->z.next_out = (Bytef *) buf;
  373|   205k|        param->z.avail_out = len;
  374|   205k|        param->z.next_in = param->in + param->inpos;
  375|   205k|        param->z.avail_in = param->inlen - param->inpos;
  376|       |
  377|   438k|        while ((param->z.avail_out > 0) && (!param->zend)) {
  ------------------
  |  Branch (377:16): [True: 245k, False: 192k]
  |  Branch (377:44): [True: 245k, False: 0]
  ------------------
  378|   245k|            if (param->z.avail_in == 0) {
  ------------------
  |  Branch (378:17): [True: 52.9k, False: 192k]
  ------------------
  379|  52.9k|                size_t read = 0;
  380|  52.9k|                if (!param->pkt.readsrc->read(param->in, sizeof(param->in), &read)) {
  ------------------
  |  Branch (380:21): [True: 93, False: 52.8k]
  ------------------
  381|     93|                    RNP_LOG("failed to read data");
  ------------------
  |  |   76|     93|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     93|    do {                                                                                 \
  |  |  |  |   69|     93|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 93, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     93|            break;                                                                       \
  |  |  |  |   71|     93|        (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|     93|                    return false;
  383|     93|                }
  384|  52.8k|                param->z.next_in = param->in;
  385|  52.8k|                param->z.avail_in = read;
  386|  52.8k|                param->inlen = read;
  387|  52.8k|                param->inpos = 0;
  388|  52.8k|            }
  389|   245k|            int ret = inflate(&param->z, Z_SYNC_FLUSH);
  390|   245k|            if (ret == Z_STREAM_END) {
  ------------------
  |  Branch (390:17): [True: 10.9k, False: 234k]
  ------------------
  391|  10.9k|                param->zend = true;
  392|  10.9k|                if (param->z.avail_in > 0) {
  ------------------
  |  Branch (392:21): [True: 908, False: 10.0k]
  ------------------
  393|    908|                    RNP_LOG("data beyond the end of z stream");
  ------------------
  |  |   76|    908|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    908|    do {                                                                                 \
  |  |  |  |   69|    908|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 908, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    908|            break;                                                                       \
  |  |  |  |   71|    908|        (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|    908|                }
  395|  10.9k|                break;
  396|  10.9k|            }
  397|   234k|            if (ret != Z_OK) {
  ------------------
  |  Branch (397:17): [True: 269, False: 233k]
  ------------------
  398|    269|                RNP_LOG("inflate error %d", ret);
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  399|    269|                return false;
  400|    269|            }
  401|   233k|            if (!param->z.avail_in && param->pkt.readsrc->eof()) {
  ------------------
  |  Branch (401:17): [True: 41.0k, False: 192k]
  |  Branch (401:39): [True: 1.06k, False: 39.9k]
  ------------------
  402|  1.06k|                RNP_LOG("unexpected end of zlib stream");
  ------------------
  |  |   76|  1.06k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.06k|    do {                                                                                 \
  |  |  |  |   69|  1.06k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.06k|            break;                                                                       \
  |  |  |  |   71|  1.06k|        (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.06k|                return false;
  404|  1.06k|            }
  405|   233k|        }
  406|   203k|        param->inpos = param->z.next_in - param->in;
  407|   203k|        *readres = len - param->z.avail_out;
  408|   203k|        return true;
  409|   205k|    }
  410|   574k|#ifdef HAVE_BZLIB_H
  411|   574k|    if (param->alg == PGP_C_BZIP2) {
  ------------------
  |  Branch (411:9): [True: 574k, False: 0]
  ------------------
  412|   574k|        param->bz.next_out = (char *) buf;
  413|   574k|        param->bz.avail_out = len;
  414|   574k|        param->bz.next_in = (char *) (param->in + param->inpos);
  415|   574k|        param->bz.avail_in = param->inlen - param->inpos;
  416|       |
  417|  1.14M|        while ((param->bz.avail_out > 0) && (!param->zend)) {
  ------------------
  |  Branch (417:16): [True: 574k, False: 573k]
  |  Branch (417:45): [True: 574k, False: 0]
  ------------------
  418|   574k|            if (param->bz.avail_in == 0) {
  ------------------
  |  Branch (418:17): [True: 409, False: 573k]
  ------------------
  419|    409|                size_t read = 0;
  420|    409|                if (!param->pkt.readsrc->read(param->in, sizeof(param->in), &read)) {
  ------------------
  |  Branch (420:21): [True: 18, False: 391]
  ------------------
  421|     18|                    RNP_LOG("failed to read data");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  422|     18|                    return false;
  423|     18|                }
  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|   574k|            int ret = BZ2_bzDecompress(&param->bz);
  430|   574k|            if (ret == BZ_STREAM_END) {
  ------------------
  |  Branch (430:17): [True: 37, False: 574k]
  ------------------
  431|     37|                param->zend = true;
  432|     37|                if (param->bz.avail_in > 0) {
  ------------------
  |  Branch (432:21): [True: 12, False: 25]
  ------------------
  433|     12|                    RNP_LOG("data beyond the end of z stream");
  ------------------
  |  |   76|     12|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     12|    do {                                                                                 \
  |  |  |  |   69|     12|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 12, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     12|            break;                                                                       \
  |  |  |  |   71|     12|        (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|     12|                }
  435|     37|                break;
  436|     37|            }
  437|   574k|            if (ret != BZ_OK) {
  ------------------
  |  Branch (437:17): [True: 187, False: 573k]
  ------------------
  438|    187|                RNP_LOG("bzdecompress error %d", ret);
  ------------------
  |  |   76|    187|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    187|    do {                                                                                 \
  |  |  |  |   69|    187|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 187, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    187|            break;                                                                       \
  |  |  |  |   71|    187|        (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|    187|                return false;
  440|    187|            }
  441|   573k|            if (!param->bz.avail_in && param->pkt.readsrc->eof()) {
  ------------------
  |  Branch (441:17): [True: 163, False: 573k]
  |  Branch (441:40): [True: 97, False: 66]
  ------------------
  442|     97|                RNP_LOG("unexpected end of bzip stream");
  ------------------
  |  |   76|     97|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     97|    do {                                                                                 \
  |  |  |  |   69|     97|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 97, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     97|            break;                                                                       \
  |  |  |  |   71|     97|        (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|     97|                return false;
  444|     97|            }
  445|   573k|        }
  446|       |
  447|   573k|        param->inpos = (uint8_t *) param->bz.next_in - param->in;
  448|   573k|        *readres = len - param->bz.avail_out;
  449|   573k|        return true;
  450|   574k|    }
  451|      0|#endif
  452|      0|    return false;
  453|   574k|}
stream-parse.cpp:_ZL20compressed_src_closeP12pgp_source_t:
  457|  21.9k|{
  458|  21.9k|    pgp_source_compressed_param_t *param = (pgp_source_compressed_param_t *) src->param;
  459|  21.9k|    if (!param) {
  ------------------
  |  Branch (459:9): [True: 1.00k, False: 20.9k]
  ------------------
  460|  1.00k|        return; // LCOV_EXCL_LINE
  461|  1.00k|    }
  462|       |
  463|  20.9k|    if (param->pkt.hdr.partial) {
  ------------------
  |  Branch (463:9): [True: 8.36k, False: 12.6k]
  ------------------
  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|  20.9k|#ifdef HAVE_BZLIB_H
  470|  20.9k|    if (param->alg == PGP_C_BZIP2) {
  ------------------
  |  Branch (470:9): [True: 343, False: 20.6k]
  ------------------
  471|    343|        BZ2_bzDecompressEnd(&param->bz);
  472|    343|    }
  473|  20.9k|#endif
  474|  20.9k|    if ((param->alg == PGP_C_ZIP) || (param->alg == PGP_C_ZLIB)) {
  ------------------
  |  Branch (474:9): [True: 12.8k, False: 8.12k]
  |  Branch (474:38): [True: 113, False: 8.00k]
  ------------------
  475|  12.9k|        inflateEnd(&param->z);
  476|  12.9k|    }
  477|       |
  478|  20.9k|    free(src->param);
  479|       |    src->param = NULL;
  480|  20.9k|}

_Z18signature_hash_keyRK13pgp_key_pkt_tRN3rnp4HashE13pgp_version_t:
   53|  34.5k|{
   54|  34.5k|    if (key.pub_data.empty()) {
  ------------------
  |  Branch (54:9): [True: 0, False: 34.5k]
  ------------------
   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|  34.5k|    switch (pgpver) {
   63|      0|    case PGP_V2:
  ------------------
  |  Branch (63:5): [True: 0, False: 34.5k]
  ------------------
   64|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   65|      0|    case PGP_V3:
  ------------------
  |  Branch (65:5): [True: 0, False: 34.5k]
  ------------------
   66|      0|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|      0|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
   67|  28.5k|    case PGP_V4: {
  ------------------
  |  Branch (67:5): [True: 28.5k, False: 6.00k]
  ------------------
   68|  28.5k|        assert(key.pub_data.size() <= ((size_t) 0xffffu));
   69|  28.5k|        uint8_t hdr[3] = {0x99, 0x00, 0x00};
   70|  28.5k|        write_uint16(hdr + 1, key.pub_data.size());
   71|  28.5k|        hash.add(hdr, 3);
   72|  28.5k|        hash.add(key.pub_data);
   73|  28.5k|        break;
   74|      0|    }
   75|    530|    case PGP_V5: {
  ------------------
  |  Branch (75:5): [True: 530, False: 33.9k]
  ------------------
   76|    530|        assert(key.pub_data.size() <= (size_t) 0xffffffffu);
   77|    530|        uint8_t hdr[5] = {0x9A, 0x00, 0x00, 0x00, 0x00};
   78|    530|        write_uint32(hdr + 1, key.pub_data.size());
   79|    530|        hash.add(&hdr, 5);
   80|    530|        hash.add(key.pub_data);
   81|    530|        break;
   82|      0|    }
   83|      0|#if defined(ENABLE_CRYPTO_REFRESH)
   84|  5.47k|    case PGP_V6: {
  ------------------
  |  Branch (84:5): [True: 5.47k, False: 29.0k]
  ------------------
   85|  5.47k|        assert(key.pub_data.size() <= (size_t) 0xffffffffu);
   86|  5.47k|        uint8_t hdr[5] = {0x9b, 0x00, 0x00, 0x00, 0x00};
   87|  5.47k|        write_uint32(hdr + 1, key.pub_data.size());
   88|  5.47k|        hash.add(hdr, sizeof(hdr));
   89|  5.47k|        hash.add(key.pub_data);
   90|  5.47k|        break;
   91|      0|    }
   92|      0|#endif
   93|      0|    default:
  ------------------
  |  Branch (93:5): [True: 0, False: 34.5k]
  ------------------
   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|  34.5k|    }
   97|  34.5k|}
_ZN3pgp3pkt9Signature10parse_v2v3ER17pgp_packet_body_t:
  756|  5.54k|{
  757|       |    /* parse v2/v3-specific fields, not the whole signature */
  758|  5.54k|    uint8_t buf[16] = {};
  759|  5.54k|    if (!pkt.get(buf, 16)) {
  ------------------
  |  Branch (759:9): [True: 460, False: 5.08k]
  ------------------
  760|    460|        RNP_LOG("cannot get enough bytes");
  ------------------
  |  |   76|    460|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    460|    do {                                                                                 \
  |  |  |  |   69|    460|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 460, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    460|            break;                                                                       \
  |  |  |  |   71|    460|        (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|    460|        return RNP_ERROR_BAD_FORMAT;
  762|    460|    }
  763|       |    /* length of hashed data, 5 */
  764|  5.08k|    if (buf[0] != 5) {
  ------------------
  |  Branch (764:9): [True: 339, False: 4.74k]
  ------------------
  765|    339|        RNP_LOG("wrong length of hashed data");
  ------------------
  |  |   76|    339|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    339|    do {                                                                                 \
  |  |  |  |   69|    339|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 339, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    339|            break;                                                                       \
  |  |  |  |   71|    339|        (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|    339|        return RNP_ERROR_BAD_FORMAT;
  767|    339|    }
  768|       |    /* hashed data */
  769|  4.74k|    hashed_data.assign(buf + 1, buf + 6);
  770|       |    /* signature type */
  771|  4.74k|    type_ = (pgp_sig_type_t) buf[1];
  772|       |    /* creation time */
  773|  4.74k|    creation_time = read_uint32(&buf[2]);
  774|       |    /* signer's key id */
  775|  4.74k|    static_assert(std::tuple_size<decltype(signer)>::value == PGP_KEY_ID_SIZE,
  776|  4.74k|                  "v3 signer field size mismatch");
  777|  4.74k|    memcpy(signer.data(), &buf[6], PGP_KEY_ID_SIZE);
  ------------------
  |  |   39|  4.74k|#define PGP_KEY_ID_SIZE 8
  ------------------
  778|       |    /* public key algorithm */
  779|  4.74k|    palg = (pgp_pubkey_alg_t) buf[14];
  780|       |    /* hash algorithm */
  781|  4.74k|    halg = (pgp_hash_alg_t) buf[15];
  782|  4.74k|    return RNP_SUCCESS;
  783|  5.08k|}
_ZN3pgp3pkt9Signature16parse_subpacketsEPhmb:
  789|  57.7k|{
  790|  57.7k|    bool res = true;
  791|       |
  792|   195k|    while (len) {
  ------------------
  |  Branch (792:12): [True: 140k, False: 54.8k]
  ------------------
  793|   140k|        if (subpkts.size() >= MAX_SUBPACKETS) {
  ------------------
  |  |  785|   140k|#define MAX_SUBPACKETS 64
  ------------------
  |  Branch (793:13): [True: 188, False: 140k]
  ------------------
  794|    188|            RNP_LOG("too many signature subpackets");
  ------------------
  |  |   76|    188|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    188|    do {                                                                                 \
  |  |  |  |   69|    188|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 188, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    188|            break;                                                                       \
  |  |  |  |   71|    188|        (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|    188|            return false;
  796|    188|        }
  797|   140k|        if (len < 2) {
  ------------------
  |  Branch (797:13): [True: 396, False: 140k]
  ------------------
  798|    396|            RNP_LOG("got single byte %" PRIu8, *buf);
  ------------------
  |  |   76|    396|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    396|    do {                                                                                 \
  |  |  |  |   69|    396|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 396, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    396|            break;                                                                       \
  |  |  |  |   71|    396|        (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|    396|            return false;
  800|    396|        }
  801|       |
  802|       |        /* subpacket length */
  803|   140k|        size_t splen = *buf++;
  804|   140k|        len--;
  805|   140k|        if ((splen >= 192) && (splen < 255)) {
  ------------------
  |  Branch (805:13): [True: 2.01k, False: 138k]
  |  Branch (805:31): [True: 1.50k, False: 510]
  ------------------
  806|  1.50k|            splen = ((splen - 192) << 8) + *buf++ + 192;
  807|  1.50k|            len--;
  808|   138k|        } else if (splen == 255) {
  ------------------
  |  Branch (808:20): [True: 510, False: 138k]
  ------------------
  809|    510|            if (len < 4) {
  ------------------
  |  Branch (809:17): [True: 210, False: 300]
  ------------------
  810|    210|                RNP_LOG("got 4-byte len but only %zu bytes in buffer", len);
  ------------------
  |  |   76|    210|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    210|    do {                                                                                 \
  |  |  |  |   69|    210|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 210, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    210|            break;                                                                       \
  |  |  |  |   71|    210|        (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|    210|                return false;
  812|    210|            }
  813|    300|            splen = read_uint32(buf);
  814|    300|            buf += 4;
  815|    300|            len -= 4;
  816|    300|        }
  817|       |
  818|   140k|        if (!splen) {
  ------------------
  |  Branch (818:13): [True: 612, False: 139k]
  ------------------
  819|    612|            RNP_LOG("got subpacket with 0 length");
  ------------------
  |  |   76|    612|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    612|    do {                                                                                 \
  |  |  |  |   69|    612|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 612, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    612|            break;                                                                       \
  |  |  |  |   71|    612|        (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|    612|            return false;
  821|    612|        }
  822|       |
  823|       |        /* subpacket data */
  824|   139k|        if (len < splen) {
  ------------------
  |  Branch (824:13): [True: 1.51k, False: 138k]
  ------------------
  825|  1.51k|            RNP_LOG("got subpacket len %zu, while only %zu bytes left", splen, len);
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  826|  1.51k|            return false;
  827|  1.51k|        }
  828|       |
  829|   138k|        auto subpkt = sigsub::Raw::create(buf, splen, hashed);
  830|   138k|        if (!subpkt) {
  ------------------
  |  Branch (830:13): [True: 47.6k, False: 90.4k]
  ------------------
  831|  47.6k|            res = false;
  832|  90.4k|        } else {
  833|  90.4k|            subpkts.items.push_back(std::move(subpkt));
  834|  90.4k|        }
  835|   138k|        len -= splen;
  836|   138k|        buf += splen;
  837|   138k|    }
  838|  54.8k|    return res;
  839|  57.7k|}
_ZN3pgp3pkt9Signature14get_subpkt_lenER17pgp_packet_body_tRm:
  843|  60.5k|{
  844|  60.5k|    switch (version) {
  845|  45.9k|    case PGP_V4:
  ------------------
  |  Branch (845:5): [True: 45.9k, False: 14.6k]
  ------------------
  846|  54.5k|    case PGP_V5: {
  ------------------
  |  Branch (846:5): [True: 8.67k, False: 51.8k]
  ------------------
  847|  54.5k|        uint16_t len = 0;
  848|  54.5k|        if (!pkt.get(len)) {
  ------------------
  |  Branch (848:13): [True: 396, False: 54.1k]
  ------------------
  849|    396|            return false;
  850|    396|        }
  851|  54.1k|        splen = len;
  852|  54.1k|        return true;
  853|  54.5k|    }
  854|      0|#if defined(ENABLE_CRYPTO_REFRESH)
  855|  5.98k|    case PGP_V6: {
  ------------------
  |  Branch (855:5): [True: 5.98k, False: 54.5k]
  ------------------
  856|  5.98k|        uint32_t len = 0;
  857|  5.98k|        if (!pkt.get(len)) {
  ------------------
  |  Branch (857:13): [True: 256, False: 5.72k]
  ------------------
  858|    256|            return false;
  859|    256|        }
  860|  5.72k|        splen = len;
  861|  5.72k|        return true;
  862|  5.98k|    }
  863|      0|#endif
  864|      0|    default:
  ------------------
  |  Branch (864:5): [True: 0, False: 60.5k]
  ------------------
  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|  60.5k|    }
  868|  60.5k|}
_ZN3pgp3pkt9Signature10parse_v4upER17pgp_packet_body_t:
  896|  33.3k|{
  897|       |    /* parse v4 (and up) specific fields, not the whole signature */
  898|  33.3k|    uint8_t buf[3];
  899|  33.3k|    if (!pkt.get(buf, 3)) {
  ------------------
  |  Branch (899:9): [True: 707, False: 32.6k]
  ------------------
  900|    707|        RNP_LOG("cannot get first 3 bytes");
  ------------------
  |  |   76|    707|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    707|    do {                                                                                 \
  |  |  |  |   69|    707|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 707, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    707|            break;                                                                       \
  |  |  |  |   71|    707|        (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|    707|        return RNP_ERROR_BAD_FORMAT;
  902|    707|    }
  903|       |
  904|       |    /* signature type */
  905|  32.6k|    type_ = (pgp_sig_type_t) buf[0];
  906|       |    /* public key algorithm */
  907|  32.6k|    palg = (pgp_pubkey_alg_t) buf[1];
  908|       |    /* hash algorithm */
  909|  32.6k|    halg = (pgp_hash_alg_t) buf[2];
  910|       |    /* hashed subpackets length */
  911|       |
  912|  32.6k|    size_t splen = 0;
  913|  32.6k|    auto   hash_begin = pkt.cur();
  914|  32.6k|    if (!get_subpkt_len(pkt, splen)) {
  ------------------
  |  Branch (914:9): [True: 652, False: 32.0k]
  ------------------
  915|    652|        RNP_LOG("cannot get hashed len");
  ------------------
  |  |   76|    652|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    652|    do {                                                                                 \
  |  |  |  |   69|    652|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 652, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    652|            break;                                                                       \
  |  |  |  |   71|    652|        (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|    652|        return RNP_ERROR_BAD_FORMAT;
  917|    652|    }
  918|  32.0k|    size_t splen_size = pkt.cur() - hash_begin;
  919|       |    /* hashed subpackets length + splen_size bytes of length of unhashed subpackets */
  920|  32.0k|    if (pkt.left() < splen + splen_size) {
  ------------------
  |  Branch (920:9): [True: 706, False: 31.3k]
  ------------------
  921|    706|        RNP_LOG("wrong packet or hashed subpackets length");
  ------------------
  |  |   76|    706|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    706|    do {                                                                                 \
  |  |  |  |   69|    706|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 706, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    706|            break;                                                                       \
  |  |  |  |   71|    706|        (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|    706|        return RNP_ERROR_BAD_FORMAT;
  923|    706|    }
  924|       |    /* building hashed data */
  925|  31.3k|    size_t hlen = 4 + splen + splen_size;
  926|  31.3k|    hashed_data.resize(hlen);
  927|  31.3k|    hashed_data[0] = version;
  928|  31.3k|    static_assert(sizeof(buf) == 3, "Wrong signature header size.");
  929|  31.3k|    pkt.skip_back(3 + splen_size);
  930|       |
  931|  31.3k|    if (!pkt.get(hashed_data.data() + 1, hlen - 1)) {
  ------------------
  |  Branch (931:9): [True: 0, False: 31.3k]
  ------------------
  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|  31.3k|    if (!parse_subpackets(hashed_data.data() + 4 + splen_size, splen, true)) {
  ------------------
  |  Branch (936:9): [True: 3.40k, False: 27.9k]
  ------------------
  937|  3.40k|        RNP_LOG("failed to parse hashed subpackets");
  ------------------
  |  |   76|  3.40k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  3.40k|    do {                                                                                 \
  |  |  |  |   69|  3.40k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 3.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  3.40k|            break;                                                                       \
  |  |  |  |   71|  3.40k|        (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.40k|        return RNP_ERROR_BAD_FORMAT;
  939|  3.40k|    }
  940|       |
  941|       |    /* reading unhashed subpackets */
  942|  27.9k|    if (!get_subpkt_len(pkt, splen)) {
  ------------------
  |  Branch (942:9): [True: 0, False: 27.9k]
  ------------------
  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.9k|    if (pkt.left() < splen) {
  ------------------
  |  Branch (946:9): [True: 1.45k, False: 26.4k]
  ------------------
  947|  1.45k|        RNP_LOG("not enough data for unhashed subpackets");
  ------------------
  |  |   76|  1.45k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.45k|    do {                                                                                 \
  |  |  |  |   69|  1.45k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.45k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.45k|            break;                                                                       \
  |  |  |  |   71|  1.45k|        (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.45k|        return RNP_ERROR_BAD_FORMAT;
  949|  1.45k|    }
  950|  26.4k|    if (!parse_subpackets(pkt.cur(), splen, false)) {
  ------------------
  |  Branch (950:9): [True: 431, False: 26.0k]
  ------------------
  951|    431|        RNP_LOG("failed to parse unhashed subpackets");
  ------------------
  |  |   76|    431|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    431|    do {                                                                                 \
  |  |  |  |   69|    431|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 431, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    431|            break;                                                                       \
  |  |  |  |   71|    431|        (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|    431|        return RNP_ERROR_BAD_FORMAT;
  953|    431|    }
  954|  26.0k|    pkt.skip(splen);
  955|  26.0k|    return RNP_SUCCESS;
  956|  26.4k|}
_ZN3pgp3pkt9Signature5parseER17pgp_packet_body_t:
  960|  40.7k|{
  961|  40.7k|    uint8_t ver = 0;
  962|  40.7k|    if (!pkt.get(ver)) {
  ------------------
  |  Branch (962:9): [True: 210, False: 40.5k]
  ------------------
  963|    210|        return RNP_ERROR_BAD_FORMAT;
  964|    210|    }
  965|  40.5k|    version = (pgp_version_t) ver;
  966|       |
  967|       |    /* v3 or v4 or v6 signature body */
  968|  40.5k|    rnp_result_t res;
  969|  40.5k|    switch (ver) {
  970|  1.59k|    case PGP_V2:
  ------------------
  |  Branch (970:5): [True: 1.59k, False: 38.9k]
  ------------------
  971|  1.59k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  1.59k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  972|  5.54k|    case PGP_V3:
  ------------------
  |  Branch (972:5): [True: 3.94k, False: 36.5k]
  ------------------
  973|  5.54k|        res = parse_v2v3(pkt);
  974|  5.54k|        break;
  975|  24.2k|    case PGP_V4:
  ------------------
  |  Branch (975:5): [True: 24.2k, False: 16.2k]
  ------------------
  976|  24.2k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  24.2k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  977|  29.8k|    case PGP_V5:
  ------------------
  |  Branch (977:5): [True: 5.58k, False: 34.9k]
  ------------------
  978|  29.8k|#if defined(ENABLE_CRYPTO_REFRESH)
  979|  29.8k|        FALLTHROUGH_STATEMENT;
  ------------------
  |  |   81|  29.8k|# define FALLTHROUGH_STATEMENT [[fallthrough]]
  ------------------
  980|  33.3k|    case PGP_V6:
  ------------------
  |  Branch (980:5): [True: 3.52k, False: 37.0k]
  ------------------
  981|  33.3k|#endif
  982|  33.3k|        res = parse_v4up(pkt);
  983|  33.3k|        break;
  984|  1.61k|    default:
  ------------------
  |  Branch (984:5): [True: 1.61k, False: 38.9k]
  ------------------
  985|  1.61k|        RNP_LOG("unknown signature version: %d", (int) ver);
  ------------------
  |  |   76|  1.61k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.61k|    do {                                                                                 \
  |  |  |  |   69|  1.61k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.61k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.61k|            break;                                                                       \
  |  |  |  |   71|  1.61k|        (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.61k|        res = RNP_ERROR_BAD_FORMAT;
  987|  40.5k|    }
  988|       |
  989|  40.5k|    if (res) {
  ------------------
  |  Branch (989:9): [True: 9.76k, False: 30.7k]
  ------------------
  990|  9.76k|        return res;
  991|  9.76k|    }
  992|       |
  993|       |    /* left 16 bits of the hash */
  994|  30.7k|    if (!pkt.get(lbits.data(), 2)) {
  ------------------
  |  Branch (994:9): [True: 229, False: 30.5k]
  ------------------
  995|    229|        RNP_LOG("not enough data for hash left bits");
  ------------------
  |  |   76|    229|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|    229|    do {                                                                                 \
  |  |  |  |   69|    229|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 229, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|    229|            break;                                                                       \
  |  |  |  |   71|    229|        (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|    229|        return RNP_ERROR_BAD_FORMAT;
  997|    229|    }
  998|       |
  999|  30.5k|#if defined(ENABLE_CRYPTO_REFRESH)
 1000|  30.5k|    if (ver == PGP_V6) {
  ------------------
  |  Branch (1000:9): [True: 2.65k, False: 27.8k]
  ------------------
 1001|  2.65k|        uint8_t salt_size = 0;
 1002|  2.65k|        if (!pkt.get(salt_size)) {
  ------------------
  |  Branch (1002:13): [True: 71, False: 2.58k]
  ------------------
 1003|     71|            RNP_LOG("not enough data for v6 salt size octet");
  ------------------
  |  |   76|     71|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|     71|    do {                                                                                 \
  |  |  |  |   69|     71|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 71, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|     71|            break;                                                                       \
  |  |  |  |   71|     71|        (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|     71|            return RNP_ERROR_BAD_FORMAT;
 1005|     71|        }
 1006|  2.58k|        if (salt_size != rnp::Hash::size(halg) / 2) {
  ------------------
  |  Branch (1006:13): [True: 1.95k, False: 633]
  ------------------
 1007|  1.95k|            RNP_LOG("invalid salt size");
  ------------------
  |  |   76|  1.95k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.95k|    do {                                                                                 \
  |  |  |  |   69|  1.95k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.95k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.95k|            break;                                                                       \
  |  |  |  |   71|  1.95k|        (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|  1.95k|            return RNP_ERROR_BAD_FORMAT;
 1009|  1.95k|        }
 1010|    633|        if (!pkt.get(salt, salt_size)) {
  ------------------
  |  Branch (1010:13): [True: 202, False: 431]
  ------------------
 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|    633|    }
 1015|  28.3k|#endif
 1016|       |
 1017|       |    /* raw signature material */
 1018|       |    /* we cannot fail here */
 1019|  28.3k|    pkt.get(material_buf, pkt.left());
 1020|       |    /* check whether it can be parsed */
 1021|  28.3k|    if (!parse_material()) {
  ------------------
  |  Branch (1021:9): [True: 6.68k, False: 21.6k]
  ------------------
 1022|  6.68k|        return RNP_ERROR_BAD_FORMAT;
 1023|  6.68k|    }
 1024|  21.6k|    return RNP_SUCCESS;
 1025|  28.3k|}
_ZN3pgp3pkt9Signature5parseER12pgp_source_t:
 1029|  48.4k|{
 1030|  48.4k|    pgp_packet_body_t pkt(PGP_PKT_SIGNATURE);
 1031|  48.4k|    rnp_result_t      res = pkt.read(src);
 1032|  48.4k|    if (res) {
  ------------------
  |  Branch (1032:9): [True: 11.5k, False: 36.9k]
  ------------------
 1033|  11.5k|        return res;
 1034|  11.5k|    }
 1035|  36.9k|    return parse(pkt);
 1036|  48.4k|}
_ZNK3pgp3pkt9Signature14parse_materialEv:
 1040|  47.7k|{
 1041|  47.7k|    auto sig = SigMaterial::create(palg, halg);
 1042|  47.7k|    if (!sig) {
  ------------------
  |  Branch (1042:9): [True: 438, False: 47.3k]
  ------------------
 1043|    438|        return nullptr;
 1044|    438|    }
 1045|  47.3k|    pgp_packet_body_t pkt(material_buf);
 1046|  47.3k|    if (!sig->parse(pkt)) {
  ------------------
  |  Branch (1046:9): [True: 4.94k, False: 42.3k]
  ------------------
 1047|  4.94k|        return nullptr;
 1048|  4.94k|    }
 1049|  42.3k|    if (pkt.left()) {
  ------------------
  |  Branch (1049:9): [True: 1.30k, False: 41.0k]
  ------------------
 1050|  1.30k|        RNP_LOG("extra %zu bytes in pk packet", pkt.left());
  ------------------
  |  |   76|  1.30k|#define RNP_LOG(...) RNP_LOG_FD(stderr, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |   68|  1.30k|    do {                                                                                 \
  |  |  |  |   69|  1.30k|        if (!rnp_log_switch())                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:13): [True: 1.30k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   70|  1.30k|            break;                                                                       \
  |  |  |  |   71|  1.30k|        (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.30k|        return nullptr;
 1052|  1.30k|    }
 1053|  41.0k|    return sig;
 1054|  42.3k|}

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