_ZN10Minisketch17MaxImplementationEv:
  213|  2.00k|    static uint32_t MaxImplementation() noexcept { return minisketch_implementation_max(); }
_ZN10Minisketch23ImplementationSupportedEjj:
  219|  2.00k|    static bool ImplementationSupported(uint32_t bits, uint32_t implementation) noexcept { return minisketch_implementation_supported(bits, implementation); }
_ZNK10MinisketchcvbEv:
  249|  8.00k|    explicit operator bool() const noexcept { return bool{m_minisketch}; }
_ZN10MinisketchC2Ejjm:
  267|  8.00k|    {
  268|  8.00k|        m_minisketch = std::unique_ptr<minisketch, Deleter>(minisketch_create(bits, implementation, capacity));
  269|  8.00k|    }
_ZNK10Minisketch7DeleterclEP10minisketch:
  201|  8.00k|        {
  202|  8.00k|            minisketch_destroy(ptr);
  203|  8.00k|        }
_ZN10Minisketch7SetSeedEm:
  289|  8.00k|    {
  290|  8.00k|        minisketch_set_seed(m_minisketch.get(), seed);
  291|  8.00k|        return *this;
  292|  8.00k|    }
_ZNK10Minisketch9SerializeEv:
  325|  4.00k|    {
  326|  4.00k|        std::vector<unsigned char> result(GetSerializedSize());
  327|  4.00k|        minisketch_serialize(m_minisketch.get(), result.data());
  328|  4.00k|        return result;
  329|  4.00k|    }
_ZNK10Minisketch17GetSerializedSizeEv:
  321|  8.00k|    size_t GetSerializedSize() const noexcept { return minisketch_serialized_size(m_minisketch.get()); }
_ZN10MinisketchC2EOS_:
  255|  10.0k|    Minisketch(Minisketch&&) noexcept = default;
_ZN10Minisketch5MergeERKS_:
  305|  2.00k|    {
  306|  2.00k|        minisketch_merge(m_minisketch.get(), sketch.m_minisketch.get());
  307|  2.00k|        return *this;
  308|  2.00k|    }
_ZNK10Minisketch6DecodeEm:
  350|  1.96k|    {
  351|  1.96k|        std::vector<uint64_t> result(max_elements);
  352|  1.96k|        ssize_t ret = minisketch_decode(m_minisketch.get(), max_elements, result.data());
  353|  1.96k|        if (ret == -1) return {};
  ------------------
  |  Branch (353:13): [True: 0, False: 1.96k]
  ------------------
  354|  1.96k|        result.resize(ret);
  355|  1.96k|        return result;
  356|  1.96k|    }
_ZN10Minisketch3AddEm:
  297|  95.0k|    {
  298|  95.0k|        minisketch_add_uint64(m_minisketch.get(), element);
  299|  95.0k|        return *this;
  300|  95.0k|    }
_ZN10Minisketch11DeserializeINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_NS1_9enable_ifIXaasr3std14is_convertibleIPA_NS1_14remove_pointerIDTcldtfL0p_4dataEEE4typeEPA_KhEE5valuesr3std14is_convertibleIDTcldtfL0p_4sizeEEmEE5valueEDnE4typeE:
  341|  4.00k|    {
  342|  4.00k|        assert(GetSerializedSize() == obj.size());
  343|  4.00k|        minisketch_deserialize(m_minisketch.get(), obj.data());
  344|  4.00k|        return *this;
  345|  4.00k|    }

_Z20ConstructClMul4Bytesii:
  115|  3.71k|Sketch* ConstructClMul4Bytes(int bits, int implementation) {
  116|  3.71k|    switch (bits) {
  ------------------
  |  Branch (116:13): [True: 0, False: 3.71k]
  ------------------
  117|       |#ifdef ENABLE_FIELD_INT_25
  118|       |    case 25: return new SketchImpl<Field25>(implementation, 25);
  119|       |#endif
  120|       |#ifdef ENABLE_FIELD_INT_26
  121|       |    case 26: return new SketchImpl<Field26>(implementation, 26);
  122|       |#endif
  123|       |#ifdef ENABLE_FIELD_INT_27
  124|       |    case 27: return new SketchImpl<Field27>(implementation, 27);
  125|       |#endif
  126|       |#ifdef ENABLE_FIELD_INT_29
  127|       |    case 29: return new SketchImpl<Field29>(implementation, 29);
  128|       |#endif
  129|       |#ifdef ENABLE_FIELD_INT_31
  130|       |    case 31: return new SketchImpl<Field31>(implementation, 31);
  131|       |#endif
  132|      0|#ifdef ENABLE_FIELD_INT_32
  133|  3.71k|    case 32: return new SketchImpl<Field32>(implementation, 32);
  ------------------
  |  Branch (133:5): [True: 3.71k, False: 0]
  ------------------
  134|  3.71k|#endif
  135|  3.71k|    }
  136|      0|    return nullptr;
  137|  3.71k|}
_Z23ConstructClMulTri4Bytesii:
  139|      2|Sketch* ConstructClMulTri4Bytes(int bits, int implementation) {
  140|      2|    switch (bits) {
  ------------------
  |  Branch (140:13): [True: 2, False: 0]
  ------------------
  141|       |#ifdef ENABLE_FIELD_INT_25
  142|       |    case 25: return new SketchImpl<FieldTri25>(implementation, 25);
  143|       |#endif
  144|       |#ifdef ENABLE_FIELD_INT_28
  145|       |    case 28: return new SketchImpl<FieldTri28>(implementation, 28);
  146|       |#endif
  147|       |#ifdef ENABLE_FIELD_INT_29
  148|       |    case 29: return new SketchImpl<FieldTri29>(implementation, 29);
  149|       |#endif
  150|       |#ifdef ENABLE_FIELD_INT_30
  151|       |    case 30: return new SketchImpl<FieldTri30>(implementation, 30);
  152|       |#endif
  153|       |#ifdef ENABLE_FIELD_INT_31
  154|       |    case 31: return new SketchImpl<FieldTri31>(implementation, 31);
  155|       |#endif
  156|      2|    }
  157|      2|    return nullptr;
  158|      2|}

clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE8FromSeedEm:
  143|  6.56k|    Elem FromSeed(uint64_t seed) const {
  144|  6.56k|        uint64_t k0 = 0x434c4d554c466c64ull; // "CLMULFld"
  145|  6.56k|        uint64_t k1 = seed;
  146|  6.56k|        uint64_t count = ((uint64_t)B) << 32;
  147|  6.56k|        I ret;
  148|  6.56k|        do {
  149|  6.56k|            ret = O::Mask(I(SipHash(k0, k1, count++)));
  150|  6.56k|        } while(ret == 0);
  ------------------
  |  Branch (150:17): [True: 0, False: 6.56k]
  ------------------
  151|  6.56k|        return LOAD->template Map<O>(ret);
  152|  6.56k|    }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE10FromUint64Em:
  158|  43.9k|    constexpr Elem FromUint64(uint64_t x) const { return LOAD->template Map<O>(O::Mask(I(x))); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE3SqrEj:
  134|  2.13M|    inline constexpr Elem Sqr(Elem val) const { return SQR->template Map<O>(val); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE10MultiplierC2ERKS6_j:
  129|  1.89M|        inline constexpr explicit Multiplier(const GenField&, Elem a) : m_val(a) {}
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE10MultiplierclEj:
  130|  57.8M|        constexpr Elem operator()(Elem a) const { return MUL(m_val, a); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_118MulWithClMulReduceIjLi32ETnT_Lj141EEES1_S1_S1_:
   32|  58.0M|{
   33|  58.0M|    static constexpr I MASK = Mask<BITS, I>();
   34|       |
   35|  58.0M|    const __m128i MOD128 = _mm_cvtsi64_si128(MOD);
   36|  58.0M|    __m128i product = _mm_clmulepi64_si128(_mm_cvtsi64_si128((uint64_t)a), _mm_cvtsi64_si128((uint64_t)b), 0x00);
   37|  58.0M|    if (BITS <= 32) {
  ------------------
  |  Branch (37:9): [Folded - Ignored]
  ------------------
   38|  58.0M|        __m128i high1 = _mm_srli_epi64(product, BITS);
   39|  58.0M|        __m128i red1 = _mm_clmulepi64_si128(high1, MOD128, 0x00); 
   40|  58.0M|        __m128i high2 = _mm_srli_epi64(red1, BITS);
   41|  58.0M|        __m128i red2 = _mm_clmulepi64_si128(high2, MOD128, 0x00);
   42|  58.0M|        return _mm_cvtsi128_si64(_mm_xor_si128(_mm_xor_si128(product, red1), red2)) & MASK;
   43|  58.0M|    } else if (BITS == 64) {
  ------------------
  |  Branch (43:16): [Folded - Ignored]
  ------------------
   44|      0|        __m128i red1 = _mm_clmulepi64_si128(product, MOD128, 0x01);
   45|      0|        __m128i red2 = _mm_clmulepi64_si128(red1, MOD128, 0x01);
   46|      0|        return _mm_cvtsi128_si64(_mm_xor_si128(_mm_xor_si128(product, red1), red2));
   47|      0|    } else if ((BITS % 8) == 0) {
  ------------------
  |  Branch (47:16): [Folded - Ignored]
  ------------------
   48|      0|        __m128i high1 = _mm_srli_si128(product, BITS / 8);
   49|      0|        __m128i red1 = _mm_clmulepi64_si128(high1, MOD128, 0x00);
   50|      0|        __m128i high2 = _mm_srli_si128(red1, BITS / 8);
   51|      0|        __m128i red2 = _mm_clmulepi64_si128(high2, MOD128, 0x00);
   52|      0|        return _mm_cvtsi128_si64(_mm_xor_si128(_mm_xor_si128(product, red1), red2)) & MASK;
   53|      0|    } else {
   54|      0|        __m128i high1 = _mm_or_si128(_mm_srli_epi64(product, BITS), _mm_srli_si128(_mm_slli_epi64(product, 64 - BITS), 8));
   55|      0|        __m128i red1 = _mm_clmulepi64_si128(high1, MOD128, 0x00);
   56|      0|        if ((uint64_t(MOD) >> (66 - BITS)) == 0) {
  ------------------
  |  Branch (56:13): [Folded - Ignored]
  ------------------
   57|      0|            __m128i high2 = _mm_srli_epi64(red1, BITS);
   58|      0|            __m128i red2 = _mm_clmulepi64_si128(high2, MOD128, 0x00);
   59|      0|            return _mm_cvtsi128_si64(_mm_xor_si128(_mm_xor_si128(product, red1), red2)) & MASK;
   60|      0|        } else {
   61|      0|            __m128i high2 = _mm_or_si128(_mm_srli_epi64(red1, BITS), _mm_srli_si128(_mm_slli_epi64(red1, 64 - BITS), 8));
   62|      0|            __m128i red2 = _mm_clmulepi64_si128(high2, MOD128, 0x00);
   63|      0|            return _mm_cvtsi128_si64(_mm_xor_si128(_mm_xor_si128(product, red1), red2)) & MASK;
   64|      0|        }
   65|      0|    }
   66|  58.0M|}
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE9SerializeER9BitWriterj:
  156|   144k|    void Serialize(BitWriter& out, Elem val) const { out.Write<B, I>(SAVE->template Map<O>(val)); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE11DeserializeER9BitReader:
  154|   144k|    Elem Deserialize(BitReader& in) const { return LOAD->template Map<O>(in.Read<B, I>()); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE3InvEj:
  140|  29.2k|    inline Elem Inv(Elem val) const { return InvLadder<I, O, B, MUL, Sqr1, Sqr2, Sqr4, Sqr8, Sqr16>(val); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Sqr1Ej:
  110|  87.7k|    static inline constexpr I Sqr1(I a) { return SQR->template Map<O>(a); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Sqr2Ej:
  111|  58.5k|    static inline constexpr I Sqr2(I a) { return SQR2->template Map<O>(a); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Sqr4Ej:
  112|  58.5k|    static inline constexpr I Sqr4(I a) { return SQR4->template Map<O>(a); }
clmul_4bytes.cpp:_ZN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Sqr8Ej:
  113|  58.5k|    static inline constexpr I Sqr8(I a) { return SQR8->template Map<O>(a); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE3MulEjj:
  123|  15.2k|    inline Elem Mul(Elem a, Elem b) const { return MUL(a, b); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE3QrtEj:
  137|  3.21k|    inline constexpr Elem Qrt(Elem val) const { return QRT->template Map<O>(val); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4BitsEv:
  119|   337k|    inline constexpr int Bits() const { return B; }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Mul2Ej:
  121|  9.98k|    inline constexpr Elem Mul2(Elem val) const { return L::Call(val); }
clmul_4bytes.cpp:_ZNK12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS_18MulWithClMulReduceIjLi32ETnT_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_13SQR2_TABLE_32EEEXadL_ZNS_13SQR4_TABLE_32EEEXadL_ZNS_13SQR8_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE8ToUint64Ej:
  159|  9.25k|    constexpr uint64_t ToUint64(Elem val) const { return uint64_t(SAVE->template Map<O>(val)); }

_Z22ConstructGeneric4Bytesii:
   96|  6.29k|{
   97|  6.29k|    switch (bits) {
   98|       |#ifdef ENABLE_FIELD_INT_25
   99|       |    case 25: return new SketchImpl<Field25>(implementation, 25);
  100|       |#endif
  101|       |#ifdef ENABLE_FIELD_INT_26
  102|       |    case 26: return new SketchImpl<Field26>(implementation, 26);
  103|       |#endif
  104|       |#ifdef ENABLE_FIELD_INT_27
  105|       |    case 27: return new SketchImpl<Field27>(implementation, 27);
  106|       |#endif
  107|       |#ifdef ENABLE_FIELD_INT_28
  108|       |    case 28: return new SketchImpl<Field28>(implementation, 28);
  109|       |#endif
  110|       |#ifdef ENABLE_FIELD_INT_29
  111|       |    case 29: return new SketchImpl<Field29>(implementation, 29);
  112|       |#endif
  113|       |#ifdef ENABLE_FIELD_INT_30
  114|       |    case 30: return new SketchImpl<Field30>(implementation, 30);
  115|       |#endif
  116|       |#ifdef ENABLE_FIELD_INT_31
  117|       |    case 31: return new SketchImpl<Field31>(implementation, 31);
  118|       |#endif
  119|      0|#ifdef ENABLE_FIELD_INT_32
  120|  6.29k|    case 32: return new SketchImpl<Field32>(implementation, 32);
  ------------------
  |  Branch (120:5): [True: 6.29k, False: 0]
  ------------------
  121|      0|#endif
  122|      0|    default: return nullptr;
  ------------------
  |  Branch (122:5): [True: 0, False: 6.29k]
  ------------------
  123|  6.29k|    }
  124|  6.29k|}

generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE8FromSeedEm:
   49|  11.0k|    Elem FromSeed(uint64_t seed) const {
   50|  11.0k|        uint64_t k0 = 0x496e744669656c64ull; // "IntField"
   51|  11.0k|        uint64_t k1 = seed;
   52|  11.0k|        uint64_t count = ((uint64_t)B) << 32;
   53|  11.0k|        Elem ret;
   54|  11.1k|        do {
   55|  11.1k|            ret = O::Mask(I(SipHash(k0, k1, count++)));
   56|  11.1k|        } while(ret == 0);
  ------------------
  |  Branch (56:17): [True: 12, False: 11.0k]
  ------------------
   57|  11.0k|        return ret;
   58|  11.0k|    }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE10FromUint64Em:
   64|  51.0k|    constexpr Elem FromUint64(uint64_t x) const { return O::Mask(I(x)); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE3SqrEj:
   40|  2.60M|    inline constexpr Elem Sqr(Elem a) const { return SQR->template Map<O>(a); }
generic_4bytes.cpp:_ZN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE10MultiplierC2ERKS4_j:
   33|  2.38M|        explicit Multiplier(const Field&, Elem a) { table.template Build<L::Call>(a); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE10MultiplierclEj:
   34|  73.5M|        constexpr inline Elem operator()(Elem a) const { return table.template Map<O>(a); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE9SerializeER9BitWriterj:
   62|   217k|    void Serialize(BitWriter& out, Elem val) const { out.template Write<B, I>(val); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE11DeserializeER9BitReader:
   60|   217k|    Elem Deserialize(BitReader& in) const { return in.template Read<B, I>(); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE3InvEj:
   46|  39.3k|    Elem Inv(Elem a) const { return InvExtGCD<I, O, B, MOD>(a); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE3MulEjj:
   37|  20.4k|    Elem Mul(Elem a, Elem b) const { return GFMul<I, B, L, O>(a, b); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE3QrtEj:
   43|  4.28k|    inline constexpr Elem Qrt(Elem a) const { return QRT->template Map<O>(a); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE4BitsEv:
   25|   363k|    constexpr int Bits() const { return B; }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE4Mul2Ej:
   27|  10.7k|    constexpr inline Elem Mul2(Elem val) const { return L::Call(val); }
generic_4bytes.cpp:_ZNK12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES1_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS_12SQR_TABLE_32EEEXadL_ZNS_12QRT_TABLE_32EEEE8ToUint64Ej:
   65|  12.0k|    constexpr uint64_t ToUint64(Elem val) const { return uint64_t(val); }

_Z7SipHashmmm:
   35|  17.6k|inline uint64_t SipHash(uint64_t k0, uint64_t k1, uint64_t data) {
   36|  17.6k|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
   37|  17.6k|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
   38|  17.6k|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
   39|  17.6k|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ data;
   40|  17.6k|    SipHashRound(v0, v1, v2, v3);
   41|  17.6k|    SipHashRound(v0, v1, v2, v3);
   42|  17.6k|    v0 ^= data;
   43|  17.6k|    v3 ^= 0x800000000000000ULL;
   44|  17.6k|    SipHashRound(v0, v1, v2, v3);
   45|  17.6k|    SipHashRound(v0, v1, v2, v3);
   46|  17.6k|    v0 ^= 0x800000000000000ULL;
   47|  17.6k|    v2 ^= 0xFF;
   48|  17.6k|    SipHashRound(v0, v1, v2, v3);
   49|  17.6k|    SipHashRound(v0, v1, v2, v3);
   50|  17.6k|    SipHashRound(v0, v1, v2, v3);
   51|  17.6k|    SipHashRound(v0, v1, v2, v3);
   52|  17.6k|    return v0 ^ v1 ^ v2 ^ v3;
   53|  17.6k|}
_ZN9BitWriterC2EPh:
   84|  4.00k|    BitWriter(unsigned char* output) : out(output) {}
_ZN9BitWriter5FlushEv:
   95|  4.00k|    inline void Flush() {
   96|  4.00k|        if (offset) {
  ------------------
  |  Branch (96:13): [True: 0, False: 4.00k]
  ------------------
   97|      0|            *(out++) = state;
   98|      0|            state = 0;
   99|      0|            offset = 0;
  100|      0|        }
  101|  4.00k|    }
_ZN9BitReaderC2EPKh:
  110|  4.00k|    BitReader(const unsigned char* input) : in(input) {}
_ZN7BitsIntIjLi32EE4MaskEj:
  198|   112k|    static constexpr inline I Mask(I val) { return val & MASK; }
generic_4bytes.cpp:_ZL12SipHashRoundRmS_S_S_:
   26|   141k|static inline void SipHashRound(uint64_t& v0, uint64_t& v1, uint64_t& v2, uint64_t& v3) {
   27|   141k|    v0 += v1; v1 = Rot<13>(v1); v1 ^= v0;
   28|   141k|    v0 = Rot<32>(v0);
   29|   141k|    v2 += v3; v3 = Rot<16>(v3); v3 ^= v2;
   30|   141k|    v0 += v3; v3 = Rot<21>(v3); v3 ^= v0;
   31|   141k|    v2 += v1; v1 = Rot<17>(v1); v1 ^= v2;
   32|   141k|    v2 = Rot<32>(v2);
   33|   141k|}
generic_4bytes.cpp:_ZL3RotILi13EEmm:
   24|   141k|static constexpr inline uint64_t Rot(uint64_t x) { return (x << bits) | (x >> (64 - bits)); }
generic_4bytes.cpp:_ZL3RotILi32EEmm:
   24|   282k|static constexpr inline uint64_t Rot(uint64_t x) { return (x << bits) | (x >> (64 - bits)); }
generic_4bytes.cpp:_ZL3RotILi16EEmm:
   24|   141k|static constexpr inline uint64_t Rot(uint64_t x) { return (x << bits) | (x >> (64 - bits)); }
generic_4bytes.cpp:_ZL3RotILi21EEmm:
   24|   141k|static constexpr inline uint64_t Rot(uint64_t x) { return (x << bits) | (x >> (64 - bits)); }
generic_4bytes.cpp:_ZL3RotILi17EEmm:
   24|   141k|static constexpr inline uint64_t Rot(uint64_t x) { return (x << bits) | (x >> (64 - bits)); }
_ZN7BitsIntIjLi32EE7MidBitsILi0ELi6EEEij:
  203|  5.00M|    static constexpr inline int MidBits(I val) {
  204|  5.00M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  5.00M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  5.00M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  5.00M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi6ELi6EEEij:
  203|  5.00M|    static constexpr inline int MidBits(I val) {
  204|  5.00M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  5.00M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  5.00M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  5.00M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi12ELi5EEEij:
  203|  5.00M|    static constexpr inline int MidBits(I val) {
  204|  5.00M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  5.00M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  5.00M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  5.00M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi17ELi5EEEij:
  203|  5.00M|    static constexpr inline int MidBits(I val) {
  204|  5.00M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  5.00M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  5.00M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  5.00M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi22ELi5EEEij:
  203|  5.00M|    static constexpr inline int MidBits(I val) {
  204|  5.00M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  5.00M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  5.00M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  5.00M|    }
_ZN7BitsIntIjLi32EE7TopBitsILi5EEEij:
  210|  5.00M|    static constexpr inline int TopBits(I val) {
  211|  5.00M|        static_assert(Count > 0, "BitsInt::TopBits needs Count > 0");
  212|  5.00M|        static_assert(Count <= BITS, "BitsInt::TopBits needs Offset <= BITS");
  213|  5.00M|        return static_cast<int>(val >> (BITS - Count));
  214|  5.00M|    }
_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKj:
  233|  74.7M|    static inline constexpr I Call(const I& a) {
  234|  74.7M|        return F::template CondXorWith<MOD>(F::Shift(a, 1), F::template TopBits<1>(a));
  235|  74.7M|    }
_ZN7BitsIntIjLi32EE11CondXorWithILj141EEEjjb:
  221|  74.7M|    static inline constexpr I CondXorWith(I val, bool cond) {
  222|  74.7M|        return val ^ (-I(cond) & MOD);
  223|  74.7M|    }
_ZN7BitsIntIjLi32EE5ShiftEji:
  199|  75.9M|    static constexpr inline I Shift(I val, int bits) { return ((val << bits) & MASK); }
_ZN7BitsIntIjLi32EE7TopBitsILi1EEEij:
  210|  74.7M|    static constexpr inline int TopBits(I val) {
  211|  74.7M|        static_assert(Count > 0, "BitsInt::TopBits needs Count > 0");
  212|  74.7M|        static_assert(Count <= BITS, "BitsInt::TopBits needs Offset <= BITS");
  213|  74.7M|        return static_cast<int>(val >> (BITS - Count));
  214|  74.7M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi0ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi4ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi8ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi12ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi16ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi20ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7MidBitsILi24ELi4EEEij:
  203|  73.5M|    static constexpr inline int MidBits(I val) {
  204|  73.5M|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  73.5M|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  73.5M|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  73.5M|    }
_ZN7BitsIntIjLi32EE7TopBitsILi4EEEij:
  210|  73.5M|    static constexpr inline int TopBits(I val) {
  211|  73.5M|        static_assert(Count > 0, "BitsInt::TopBits needs Count > 0");
  212|  73.5M|        static_assert(Count <= BITS, "BitsInt::TopBits needs Offset <= BITS");
  213|  73.5M|        return static_cast<int>(val >> (BITS - Count));
  214|  73.5M|    }
_ZN9BitWriter5WriteILi32EjEEvT0_:
   87|   361k|    inline void Write(I val) {
   88|       |        // If I is smaller than an unsigned int, invoke WriteInner with argument converted to unsigned.
   89|   361k|        using compute_type = typename std::conditional<
   90|   361k|            (std::numeric_limits<I>::digits < std::numeric_limits<unsigned>::digits),
   91|   361k|            unsigned, I>::type;
   92|   361k|        return WriteInner<BITS, compute_type>(val);
   93|   361k|    }
_ZN9BitWriter10WriteInnerILi32EjEEvT0_:
   61|   361k|    inline void WriteInner(I val) {
   62|       |        // We right shift by up to 8 bits below. Verify that's well defined for the type I.
   63|   361k|        static_assert(std::numeric_limits<I>::digits > 8, "BitWriter::WriteInner needs I > 8 bits");
   64|   361k|        int bits = BITS;
   65|   361k|        if (bits + offset >= 8) {
  ------------------
  |  Branch (65:13): [True: 361k, False: 0]
  ------------------
   66|   361k|            state |= ((val & ((I(1) << (8 - offset)) - 1)) << offset);
   67|   361k|            *(out++) = state;
   68|   361k|            val >>= (8 - offset);
   69|   361k|            bits -= 8 - offset;
   70|   361k|            offset = 0;
   71|   361k|            state = 0;
   72|   361k|        }
   73|  1.44M|        while (bits >= 8) {
  ------------------
  |  Branch (73:16): [True: 1.08M, False: 361k]
  ------------------
   74|  1.08M|            *(out++) = val & 255;
   75|  1.08M|            val >>= 8;
   76|  1.08M|            bits -= 8;
   77|  1.08M|        }
   78|   361k|        state |= ((val & ((I(1) << bits) - 1)) << offset);
   79|   361k|        offset += bits;
   80|   361k|    }
_ZN9BitReader4ReadILi32EjEET0_v:
  113|   361k|    inline I Read() {
  114|   361k|        int bits = BITS;
  115|   361k|        if (offset >= bits) {
  ------------------
  |  Branch (115:13): [True: 0, False: 361k]
  ------------------
  116|      0|            I ret = state & ((1 << bits) - 1);
  117|      0|            state >>= bits;
  118|      0|            offset -= bits;
  119|      0|            return ret;
  120|      0|        }
  121|   361k|        I val = state;
  122|   361k|        int out = offset;
  123|  1.80M|        while (out + 8 <= bits) {
  ------------------
  |  Branch (123:16): [True: 1.44M, False: 361k]
  ------------------
  124|  1.44M|            val |= ((I(*(in++))) << out);
  125|  1.44M|            out += 8;
  126|  1.44M|        }
  127|   361k|        if (out < bits) {
  ------------------
  |  Branch (127:13): [True: 0, False: 361k]
  ------------------
  128|      0|            unsigned char c = *(in++);
  129|      0|            val |= (c & ((I(1) << (bits - out)) - 1)) << out;
  130|      0|            state = c >> (bits - out);
  131|      0|            offset = 8 - (bits - out);
  132|   361k|        } else {
  133|   361k|            state = 0;
  134|   361k|            offset = 0;
  135|   361k|        }
  136|   361k|        return val;
  137|   361k|    }
_Z9InvExtGCDIj7BitsIntIjLi32EELi32ELj141EET_S2_:
  255|  39.3k|{
  256|  39.3k|    if (F::IsZero(x) || F::IsOne(x)) return x;
  ------------------
  |  Branch (256:9): [True: 0, False: 39.3k]
  |  Branch (256:25): [True: 37, False: 39.2k]
  ------------------
  257|  39.2k|    I t(0), newt(1);
  258|  39.2k|    I r(MOD), newr = x;
  259|  39.2k|    int rlen = BITS + 1, newrlen = F::Bits(newr, BITS);
  260|  1.26M|    while (newr) {
  ------------------
  |  Branch (260:12): [True: 1.22M, False: 39.2k]
  ------------------
  261|  1.22M|        int q = rlen - newrlen;
  262|  1.22M|        r ^= F::Shift(newr, q);
  263|  1.22M|        t ^= F::UnsafeShift(newt, q);
  264|  1.22M|        rlen = F::Bits(r, rlen - 1);
  265|  1.22M|        if (r < newr) {
  ------------------
  |  Branch (265:13): [True: 789k, False: 432k]
  ------------------
  266|   789k|            F::Swap(t, newt);
  267|   789k|            F::Swap(r, newr);
  268|   789k|            std::swap(rlen, newrlen);
  269|   789k|        }
  270|  1.22M|    }
  271|  39.2k|    return t;
  272|  39.3k|}
_ZN7BitsIntIjLi32EE6IsZeroEj:
  196|  39.3k|    static constexpr inline bool IsZero(I a) { return a == 0; }
_ZN7BitsIntIjLi32EE5IsOneEj:
  197|  39.3k|    static constexpr inline bool IsOne(I a) { return a == 1; }
_ZN7BitsIntIjLi32EE4BitsEji:
  225|  1.26M|    static inline int Bits(I val, int max) { return CountBits<I>(val, max); }
generic_4bytes.cpp:_ZL9CountBitsIjEiT_i:
  146|  1.26M|static inline int CountBits(I val, int max) {
  147|  1.26M|#if defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L
  148|       |    // c++20 impl
  149|  1.26M|    (void)max;
  150|  1.26M|    return std::bit_width(val);
  151|       |#elif defined(_MSC_VER)
  152|       |    (void)max;
  153|       |    unsigned long index;
  154|       |    unsigned char ret;
  155|       |    if (std::numeric_limits<I>::digits <= 32) {
  156|       |        ret = _BitScanReverse(&index, val);
  157|       |    } else {
  158|       |        ret = _BitScanReverse64(&index, val);
  159|       |    }
  160|       |    if (!ret) return 0;
  161|       |    return index + 1;
  162|       |#elif defined(HAVE_CLZ)
  163|       |    (void)max;
  164|       |    if (val == 0) return 0;
  165|       |    if (std::numeric_limits<unsigned>::digits >= std::numeric_limits<I>::digits) {
  166|       |        return std::numeric_limits<unsigned>::digits - __builtin_clz(val);
  167|       |    } else if (std::numeric_limits<unsigned long>::digits >= std::numeric_limits<I>::digits) {
  168|       |        return std::numeric_limits<unsigned long>::digits - __builtin_clzl(val);
  169|       |    } else {
  170|       |        return std::numeric_limits<unsigned long long>::digits - __builtin_clzll(val);
  171|       |    }
  172|       |#else
  173|       |    while (max && (val >> (max - 1) == 0)) --max;
  174|       |    return max;
  175|       |#endif
  176|  1.26M|}
_ZN7BitsIntIjLi32EE11UnsafeShiftEji:
  200|  1.22M|    static constexpr inline I UnsafeShift(I val, int bits) { return (val << bits); }
_ZN7BitsIntIjLi32EE4SwapERjS1_:
  192|  1.57M|    static void inline Swap(I& a, I& b) {
  193|  1.57M|        std::swap(a, b);
  194|  1.57M|    }
_Z5GFMulIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_ET_RKS4_S6_:
  250|  20.4k|template<typename I, int N, typename L, typename F> inline constexpr I GFMul(const I& a, const I& b) { return GFMulHelper<I, N, L, F, N>::Run(a, b); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li32EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN7BitsIntIjLi32EE11CondXorWithEjbj:
  216|   653k|    static inline constexpr I CondXorWith(I val, bool cond, I v) {
  217|   653k|        return val ^ (-I(cond) & v);
  218|   653k|    }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li31EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li30EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li29EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li28EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li27EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li26EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li25EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li24EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li23EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li22EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li21EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li20EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li19EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li18EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li17EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li16EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li15EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li14EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li13EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li12EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li11EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li10EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li9EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li8EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li7EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li6EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li5EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li4EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li3EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li2EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li1EE3RunERKjS6_:
  246|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return F::CondXorWith(GFMulHelper<I, N, L, F, K - 1>::Run(L::Call(a), b), F::template MidBits<N - K, 1>(b), a); }
_ZN11GFMulHelperIjLi32E4LFSRI7BitsIntIjLi32EELj141EES2_Li0EE3RunERKjS6_:
  242|  20.4k|    static inline constexpr I Run(const I& a, const I& b) { return I(0); }
_ZN7BitsIntIjLi32EE7MidBitsILi31ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi30ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi29ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi28ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi27ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi26ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi25ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi24ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi23ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi22ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi21ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi20ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi19ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi18ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi17ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi16ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi15ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi14ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi13ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi12ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi11ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi10ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi9ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi8ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi7ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi6ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi5ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi4ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi3ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi2ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi1ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
_ZN7BitsIntIjLi32EE7MidBitsILi0ELi1EEEij:
  203|  20.4k|    static constexpr inline int MidBits(I val) {
  204|  20.4k|        static_assert(Count > 0, "BITSInt::MidBits needs Count > 0");
  205|  20.4k|        static_assert(Count + Offset <= BITS, "BitsInt::MidBits overflow of Count+Offset");
  206|  20.4k|        return (val >> Offset) & ((I(1) << Count) - 1);
  207|  20.4k|    }
clmul_4bytes.cpp:_Z9InvLadderIj7BitsIntIjLi32EELi32ETnPFT_S2_S2_EXadL_ZN12_GLOBAL__N_118MulWithClMulReduceIjLi32ETnS2_Lj141EEES2_S2_S2_EETnPFS2_S2_EXadL_ZNS5_8GenFieldIjLi32ELj141EXadL_ZNS6_IjLi32ETnS2_Lj141EEES2_S2_S2_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS5_12SQR_TABLE_32EEEXadL_ZNS5_13SQR2_TABLE_32EEEXadL_ZNS5_13SQR4_TABLE_32EEEXadL_ZNS5_13SQR8_TABLE_32EEEXadL_ZNS5_12QRT_TABLE_32EEEXadL_ZNS5_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEE4Sqr1EjEETnS8_XadL_ZNSD_4Sqr2EjEETnS8_XadL_ZNSD_4Sqr4EjEETnS8_XadL_ZNSD_4Sqr8EjEETnS8_XadL_ZNSD_5Sqr16EjEEES2_S2_:
  281|  29.2k|{
  282|  29.2k|    static constexpr int INV_EXP = BITS - 1;
  283|  29.2k|    I x2 = (INV_EXP >= 2) ? MUL(SQR(x1), x1) : I();
  ------------------
  |  Branch (283:12): [Folded - Ignored]
  ------------------
  284|  29.2k|    I x4 = (INV_EXP >= 4) ? MUL(SQR2(x2), x2) : I();
  ------------------
  |  Branch (284:12): [Folded - Ignored]
  ------------------
  285|  29.2k|    I x8 = (INV_EXP >= 8) ? MUL(SQR4(x4), x4) : I();
  ------------------
  |  Branch (285:12): [Folded - Ignored]
  ------------------
  286|  29.2k|    I x16 = (INV_EXP >= 16) ? MUL(SQR8(x8), x8) : I();
  ------------------
  |  Branch (286:13): [Folded - Ignored]
  ------------------
  287|  29.2k|    I x32 = (INV_EXP >= 32) ? MUL(SQR16(x16), x16) : I();
  ------------------
  |  Branch (287:13): [Folded - Ignored]
  ------------------
  288|  29.2k|    I r;
  289|  29.2k|    if (INV_EXP >= 32) {
  ------------------
  |  Branch (289:9): [Folded - Ignored]
  ------------------
  290|      0|        r = x32;
  291|  29.2k|    } else if (INV_EXP >= 16) {
  ------------------
  |  Branch (291:16): [Folded - Ignored]
  ------------------
  292|  29.2k|        r = x16;
  293|  29.2k|    } else if (INV_EXP >= 8) {
  ------------------
  |  Branch (293:16): [Folded - Ignored]
  ------------------
  294|      0|        r = x8;
  295|      0|    } else if (INV_EXP >= 4) {
  ------------------
  |  Branch (295:16): [Folded - Ignored]
  ------------------
  296|      0|        r = x4;
  297|      0|    } else if (INV_EXP >= 2) {
  ------------------
  |  Branch (297:16): [Folded - Ignored]
  ------------------
  298|      0|        r = x2;
  299|      0|    } else {
  300|      0|        r = x1;
  301|      0|    }
  302|  29.2k|    if (INV_EXP >= 32 && (INV_EXP & 16)) r = MUL(SQR16(r), x16);
  ------------------
  |  Branch (302:9): [Folded - Ignored]
  |  Branch (302:26): [Folded - Ignored]
  ------------------
  303|  29.2k|    if (INV_EXP >= 16 && (INV_EXP & 8)) r = MUL(SQR8(r), x8);
  ------------------
  |  Branch (303:9): [Folded - Ignored]
  |  Branch (303:26): [Folded - Ignored]
  ------------------
  304|  29.2k|    if (INV_EXP >= 8 && (INV_EXP & 4)) r = MUL(SQR4(r), x4);
  ------------------
  |  Branch (304:9): [Folded - Ignored]
  |  Branch (304:25): [Folded - Ignored]
  ------------------
  305|  29.2k|    if (INV_EXP >= 4 && (INV_EXP & 2)) r = MUL(SQR2(r), x2);
  ------------------
  |  Branch (305:9): [Folded - Ignored]
  |  Branch (305:25): [Folded - Ignored]
  ------------------
  306|  29.2k|    if (INV_EXP >= 2 && (INV_EXP & 1)) r = MUL(SQR(r), x1);
  ------------------
  |  Branch (306:9): [Folded - Ignored]
  |  Branch (306:25): [Folded - Ignored]
  ------------------
  307|  29.2k|    return SQR(r);
  308|  29.2k|}

_ZNK11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEE3MapI7BitsIntIjLi32EELi0EEEjj:
  134|  5.00M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi6EE3MapI7BitsIntIjLi32EELi0EEEjj:
   99|  5.00M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi6ELi5ELi5ELi5ELi5EEE3MapI7BitsIntIjLi32EELi6EEEjj:
  134|  5.00M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi6EE3MapI7BitsIntIjLi32EELi6EEEjj:
   99|  5.00M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi5ELi5ELi5ELi5EEE3MapI7BitsIntIjLi32EELi12EEEjj:
  134|  5.00M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi5EE3MapI7BitsIntIjLi32EELi12EEEjj:
   99|  5.00M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi5ELi5ELi5EEE3MapI7BitsIntIjLi32EELi17EEEjj:
  134|  5.00M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi5EE3MapI7BitsIntIjLi32EELi17EEEjj:
   99|  5.00M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi5ELi5EEE3MapI7BitsIntIjLi32EELi22EEEjj:
  134|  5.00M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi5EE3MapI7BitsIntIjLi32EELi22EEEjj:
   99|  5.00M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi5EEE3MapI7BitsIntIjLi32EELi27EEEjj:
  118|  5.00M|    inline I constexpr Map(I a) const { return trans.template TopMap<O, P>(a); }
_ZNK8LinTransIjLi5EE6TopMapI7BitsIntIjLi32EELi27EEEjj:
  102|  5.00M|    inline I constexpr TopMap(I a) const { static_assert(P + N == O::SIZE, "TopMap inconsistency"); return table[O::template TopBits<N>(a)]; }
_ZN11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN8LinTransIjLi4EE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEj3NumILi4EEj:
   65|  19.1M|    {
   66|  19.1M|        I b = F(a), c = F(b), d = F(c);
   67|  19.1M|        table[0] = I(); table[1] = a; table[2] = b; table[3] = a ^ b; table[4] = c; table[5] = a ^ c; table[6] = b ^ c; table[7] = a ^ b ^ c;
   68|  19.1M|        table[8] = d; table[9] = a ^ d; table[10] = b ^ d; table[11] = a ^ b ^ d; table[12] = c ^ d; table[13] = a ^ c ^ d; table[14] = b ^ c ^ d; table[15] = a ^ b ^ c ^ d;
   69|  19.1M|        return d;
   70|  19.1M|    }
_ZN11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4ELi4ELi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4ELi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4ELi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4ELi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  137|  2.38M|    inline void Build(I a) { I n = trans.template Build<F>(Num<N>(), a); rec.template Build<F>(F(n)); }
_ZN11RecLinTransIjJLi4EEE5BuildIXadL_ZN4LFSRI7BitsIntIjLi32EELj141EE4CallERKjEEEEvj:
  121|  2.38M|    inline void Build(I a) { trans.template Build<F>(Num<N>(), a); }
_ZNK11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi0EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi0EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi4EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi4EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4ELi4ELi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi8EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi8EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4ELi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi12EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi12EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi16EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi16EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4ELi4EEE3MapI7BitsIntIjLi32EELi20EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi20EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4ELi4EEE3MapI7BitsIntIjLi32EELi24EEEjj:
  134|  73.5M|    inline I constexpr Map(I a) const { return trans.template Map<O, P>(a) ^ rec.template Map<O, P + N>(a); }
_ZNK8LinTransIjLi4EE3MapI7BitsIntIjLi32EELi24EEEjj:
   99|  73.5M|    inline I constexpr Map(I a) const { return table[O::template MidBits<P, N>(a)]; }
_ZNK11RecLinTransIjJLi4EEE3MapI7BitsIntIjLi32EELi28EEEjj:
  118|  73.5M|    inline I constexpr Map(I a) const { return trans.template TopMap<O, P>(a); }
_ZNK8LinTransIjLi4EE6TopMapI7BitsIntIjLi32EELi28EEEjj:
  102|  73.5M|    inline I constexpr TopMap(I a) const { static_assert(P + N == O::SIZE, "TopMap inconsistency"); return table[O::template TopBits<N>(a)]; }
_ZNK7IdTrans3MapI7BitsIntIjLi32EEjEET0_S3_:
  144|   349k|    inline I constexpr Map(I a) const { return a; }

minisketch_bits_supported:
  163|  2.00k|int minisketch_bits_supported(uint32_t bits) {
  164|       |#ifdef ENABLE_FIELD_INT_2
  165|       |    if (bits == 2) return true;
  166|       |#endif
  167|       |#ifdef ENABLE_FIELD_INT_3
  168|       |    if (bits == 3) return true;
  169|       |#endif
  170|       |#ifdef ENABLE_FIELD_INT_4
  171|       |    if (bits == 4) return true;
  172|       |#endif
  173|       |#ifdef ENABLE_FIELD_INT_5
  174|       |    if (bits == 5) return true;
  175|       |#endif
  176|       |#ifdef ENABLE_FIELD_INT_6
  177|       |    if (bits == 6) return true;
  178|       |#endif
  179|       |#ifdef ENABLE_FIELD_INT_7
  180|       |    if (bits == 7) return true;
  181|       |#endif
  182|       |#ifdef ENABLE_FIELD_INT_8
  183|       |    if (bits == 8) return true;
  184|       |#endif
  185|       |#ifdef ENABLE_FIELD_INT_9
  186|       |    if (bits == 9) return true;
  187|       |#endif
  188|       |#ifdef ENABLE_FIELD_INT_10
  189|       |    if (bits == 10) return true;
  190|       |#endif
  191|       |#ifdef ENABLE_FIELD_INT_11
  192|       |    if (bits == 11) return true;
  193|       |#endif
  194|       |#ifdef ENABLE_FIELD_INT_12
  195|       |    if (bits == 12) return true;
  196|       |#endif
  197|       |#ifdef ENABLE_FIELD_INT_13
  198|       |    if (bits == 13) return true;
  199|       |#endif
  200|       |#ifdef ENABLE_FIELD_INT_14
  201|       |    if (bits == 14) return true;
  202|       |#endif
  203|       |#ifdef ENABLE_FIELD_INT_15
  204|       |    if (bits == 15) return true;
  205|       |#endif
  206|       |#ifdef ENABLE_FIELD_INT_16
  207|       |    if (bits == 16) return true;
  208|       |#endif
  209|       |#ifdef ENABLE_FIELD_INT_17
  210|       |    if (bits == 17) return true;
  211|       |#endif
  212|       |#ifdef ENABLE_FIELD_INT_18
  213|       |    if (bits == 18) return true;
  214|       |#endif
  215|       |#ifdef ENABLE_FIELD_INT_19
  216|       |    if (bits == 19) return true;
  217|       |#endif
  218|       |#ifdef ENABLE_FIELD_INT_20
  219|       |    if (bits == 20) return true;
  220|       |#endif
  221|       |#ifdef ENABLE_FIELD_INT_21
  222|       |    if (bits == 21) return true;
  223|       |#endif
  224|       |#ifdef ENABLE_FIELD_INT_22
  225|       |    if (bits == 22) return true;
  226|       |#endif
  227|       |#ifdef ENABLE_FIELD_INT_23
  228|       |    if (bits == 23) return true;
  229|       |#endif
  230|       |#ifdef ENABLE_FIELD_INT_24
  231|       |    if (bits == 24) return true;
  232|       |#endif
  233|       |#ifdef ENABLE_FIELD_INT_25
  234|       |    if (bits == 25) return true;
  235|       |#endif
  236|       |#ifdef ENABLE_FIELD_INT_26
  237|       |    if (bits == 26) return true;
  238|       |#endif
  239|       |#ifdef ENABLE_FIELD_INT_27
  240|       |    if (bits == 27) return true;
  241|       |#endif
  242|       |#ifdef ENABLE_FIELD_INT_28
  243|       |    if (bits == 28) return true;
  244|       |#endif
  245|       |#ifdef ENABLE_FIELD_INT_29
  246|       |    if (bits == 29) return true;
  247|       |#endif
  248|       |#ifdef ENABLE_FIELD_INT_30
  249|       |    if (bits == 30) return true;
  250|       |#endif
  251|       |#ifdef ENABLE_FIELD_INT_31
  252|       |    if (bits == 31) return true;
  253|       |#endif
  254|  2.00k|#ifdef ENABLE_FIELD_INT_32
  255|  2.00k|    if (bits == 32) return true;
  ------------------
  |  Branch (255:9): [True: 2.00k, False: 0]
  ------------------
  256|      0|#endif
  257|       |#ifdef ENABLE_FIELD_INT_33
  258|       |    if (bits == 33) return true;
  259|       |#endif
  260|       |#ifdef ENABLE_FIELD_INT_34
  261|       |    if (bits == 34) return true;
  262|       |#endif
  263|       |#ifdef ENABLE_FIELD_INT_35
  264|       |    if (bits == 35) return true;
  265|       |#endif
  266|       |#ifdef ENABLE_FIELD_INT_36
  267|       |    if (bits == 36) return true;
  268|       |#endif
  269|       |#ifdef ENABLE_FIELD_INT_37
  270|       |    if (bits == 37) return true;
  271|       |#endif
  272|       |#ifdef ENABLE_FIELD_INT_38
  273|       |    if (bits == 38) return true;
  274|       |#endif
  275|       |#ifdef ENABLE_FIELD_INT_39
  276|       |    if (bits == 39) return true;
  277|       |#endif
  278|       |#ifdef ENABLE_FIELD_INT_40
  279|       |    if (bits == 40) return true;
  280|       |#endif
  281|       |#ifdef ENABLE_FIELD_INT_41
  282|       |    if (bits == 41) return true;
  283|       |#endif
  284|       |#ifdef ENABLE_FIELD_INT_42
  285|       |    if (bits == 42) return true;
  286|       |#endif
  287|       |#ifdef ENABLE_FIELD_INT_43
  288|       |    if (bits == 43) return true;
  289|       |#endif
  290|       |#ifdef ENABLE_FIELD_INT_44
  291|       |    if (bits == 44) return true;
  292|       |#endif
  293|       |#ifdef ENABLE_FIELD_INT_45
  294|       |    if (bits == 45) return true;
  295|       |#endif
  296|       |#ifdef ENABLE_FIELD_INT_46
  297|       |    if (bits == 46) return true;
  298|       |#endif
  299|       |#ifdef ENABLE_FIELD_INT_47
  300|       |    if (bits == 47) return true;
  301|       |#endif
  302|       |#ifdef ENABLE_FIELD_INT_48
  303|       |    if (bits == 48) return true;
  304|       |#endif
  305|       |#ifdef ENABLE_FIELD_INT_49
  306|       |    if (bits == 49) return true;
  307|       |#endif
  308|       |#ifdef ENABLE_FIELD_INT_50
  309|       |    if (bits == 50) return true;
  310|       |#endif
  311|       |#ifdef ENABLE_FIELD_INT_51
  312|       |    if (bits == 51) return true;
  313|       |#endif
  314|       |#ifdef ENABLE_FIELD_INT_52
  315|       |    if (bits == 52) return true;
  316|       |#endif
  317|       |#ifdef ENABLE_FIELD_INT_53
  318|       |    if (bits == 53) return true;
  319|       |#endif
  320|       |#ifdef ENABLE_FIELD_INT_54
  321|       |    if (bits == 54) return true;
  322|       |#endif
  323|       |#ifdef ENABLE_FIELD_INT_55
  324|       |    if (bits == 55) return true;
  325|       |#endif
  326|       |#ifdef ENABLE_FIELD_INT_56
  327|       |    if (bits == 56) return true;
  328|       |#endif
  329|       |#ifdef ENABLE_FIELD_INT_57
  330|       |    if (bits == 57) return true;
  331|       |#endif
  332|       |#ifdef ENABLE_FIELD_INT_58
  333|       |    if (bits == 58) return true;
  334|       |#endif
  335|       |#ifdef ENABLE_FIELD_INT_59
  336|       |    if (bits == 59) return true;
  337|       |#endif
  338|       |#ifdef ENABLE_FIELD_INT_60
  339|       |    if (bits == 60) return true;
  340|       |#endif
  341|       |#ifdef ENABLE_FIELD_INT_61
  342|       |    if (bits == 61) return true;
  343|       |#endif
  344|       |#ifdef ENABLE_FIELD_INT_62
  345|       |    if (bits == 62) return true;
  346|       |#endif
  347|       |#ifdef ENABLE_FIELD_INT_63
  348|       |    if (bits == 63) return true;
  349|       |#endif
  350|       |#ifdef ENABLE_FIELD_INT_64
  351|       |    if (bits == 64) return true;
  352|       |#endif
  353|      0|    return false;
  354|  2.00k|}
minisketch_implementation_max:
  356|  4.00k|uint32_t minisketch_implementation_max() {
  357|  4.00k|    uint32_t ret = 0;
  358|  4.00k|#ifdef HAVE_CLMUL
  359|  4.00k|    ret += 2;
  360|  4.00k|#endif
  361|  4.00k|    return ret;
  362|  4.00k|}
minisketch_implementation_supported:
  364|  2.00k|int minisketch_implementation_supported(uint32_t bits, uint32_t implementation) {
  365|  2.00k|    if (!minisketch_bits_supported(bits) || implementation > minisketch_implementation_max()) {
  ------------------
  |  Branch (365:9): [True: 0, False: 2.00k]
  |  Branch (365:45): [True: 0, False: 2.00k]
  ------------------
  366|      0|        return 0;
  367|      0|    }
  368|  2.00k|    try {
  369|  2.00k|        Sketch* sketch = Construct(bits, implementation);
  370|  2.00k|        if (sketch) {
  ------------------
  |  Branch (370:13): [True: 2.00k, False: 2]
  ------------------
  371|  2.00k|            delete sketch;
  372|  2.00k|            return 1;
  373|  2.00k|        }
  374|  2.00k|    } catch (const std::bad_alloc&) {}
  375|      2|    return 0;
  376|  2.00k|}
minisketch_create:
  378|  8.00k|minisketch* minisketch_create(uint32_t bits, uint32_t implementation, size_t capacity) {
  379|  8.00k|    try {
  380|  8.00k|        Sketch* sketch = Construct(bits, implementation);
  381|  8.00k|        if (sketch) {
  ------------------
  |  Branch (381:13): [True: 8.00k, False: 0]
  ------------------
  382|  8.00k|            try {
  383|  8.00k|                sketch->Init(capacity);
  384|  8.00k|            } catch (const std::bad_alloc&) {
  385|      0|                delete sketch;
  386|      0|                throw;
  387|      0|            }
  388|  8.00k|            sketch->Ready();
  389|  8.00k|        }
  390|  8.00k|        return (minisketch*)sketch;
  391|  8.00k|    } catch (const std::bad_alloc&) {
  392|      0|        return nullptr;
  393|      0|    }
  394|  8.00k|}
minisketch_destroy:
  424|  8.00k|void minisketch_destroy(minisketch* sketch) {
  425|  8.00k|    if (sketch) {
  ------------------
  |  Branch (425:9): [True: 8.00k, False: 0]
  ------------------
  426|  8.00k|        Sketch* s = (Sketch*)sketch;
  427|  8.00k|        s->UnReady();
  428|  8.00k|        delete s;
  429|  8.00k|    }
  430|  8.00k|}
minisketch_serialized_size:
  432|  8.00k|size_t minisketch_serialized_size(const minisketch* sketch) {
  433|  8.00k|    const Sketch* s = (const Sketch*)sketch;
  434|  8.00k|    s->Check();
  435|  8.00k|    size_t bits = s->Bits();
  436|  8.00k|    size_t syndromes = s->Syndromes();
  437|  8.00k|    return (bits * syndromes + 7) / 8;
  438|  8.00k|}
minisketch_serialize:
  440|  4.00k|void minisketch_serialize(const minisketch* sketch, unsigned char* output) {
  441|  4.00k|    const Sketch* s = (const Sketch*)sketch;
  442|  4.00k|    s->Check();
  443|  4.00k|    s->Serialize(output);
  444|  4.00k|}
minisketch_deserialize:
  446|  4.00k|void minisketch_deserialize(minisketch* sketch, const unsigned char* input) {
  447|  4.00k|    Sketch* s = (Sketch*)sketch;
  448|  4.00k|    s->Check();
  449|  4.00k|    s->Deserialize(input);
  450|  4.00k|}
minisketch_add_uint64:
  452|  95.0k|void minisketch_add_uint64(minisketch* sketch, uint64_t element) {
  453|  95.0k|    Sketch* s = (Sketch*)sketch;
  454|  95.0k|    s->Check();
  455|  95.0k|    s->Add(element);
  456|  95.0k|}
minisketch_merge:
  458|  2.00k|size_t minisketch_merge(minisketch* sketch, const minisketch* other_sketch) {
  459|  2.00k|    Sketch* s1 = (Sketch*)sketch;
  460|  2.00k|    const Sketch* s2 = (const Sketch*)other_sketch;
  461|  2.00k|    s1->Check();
  462|  2.00k|    s2->Check();
  463|  2.00k|    if (s1->Bits() != s2->Bits()) return 0;
  ------------------
  |  Branch (463:9): [True: 0, False: 2.00k]
  ------------------
  464|  2.00k|    if (s1->Implementation() != s2->Implementation()) return 0;
  ------------------
  |  Branch (464:9): [True: 0, False: 2.00k]
  ------------------
  465|  2.00k|    return s1->Merge(s2);
  466|  2.00k|}
minisketch_decode:
  468|  1.96k|ssize_t minisketch_decode(const minisketch* sketch, size_t max_elements, uint64_t* output) {
  469|  1.96k|    const Sketch* s = (const Sketch*)sketch;
  470|  1.96k|    s->Check();
  471|  1.96k|    return s->Decode(static_cast<int>(max_elements), output);
  472|  1.96k|}
minisketch_set_seed:
  474|  8.00k|void minisketch_set_seed(minisketch* sketch, uint64_t seed) {
  475|  8.00k|    Sketch* s = (Sketch*)sketch;
  476|  8.00k|    s->Check();
  477|  8.00k|    s->SetSeed(seed);
  478|  8.00k|}
minisketch.cpp:_ZN12_GLOBAL__N_19ConstructEii:
   81|  10.0k|{
   82|  10.0k|    switch (FieldImpl(impl)) {
  ------------------
  |  Branch (82:13): [True: 0, False: 10.0k]
  ------------------
   83|  6.29k|    case FieldImpl::GENERIC:
  ------------------
  |  Branch (83:5): [True: 6.29k, False: 3.71k]
  ------------------
   84|  6.29k|        switch ((bits + 7) / 8) {
   85|      0|        case 1:
  ------------------
  |  Branch (85:9): [True: 0, False: 6.29k]
  ------------------
   86|      0|            return ConstructGeneric1Byte(bits, impl);
   87|      0|        case 2:
  ------------------
  |  Branch (87:9): [True: 0, False: 6.29k]
  ------------------
   88|      0|            return ConstructGeneric2Bytes(bits, impl);
   89|      0|        case 3:
  ------------------
  |  Branch (89:9): [True: 0, False: 6.29k]
  ------------------
   90|      0|            return ConstructGeneric3Bytes(bits, impl);
   91|  6.29k|        case 4:
  ------------------
  |  Branch (91:9): [True: 6.29k, False: 0]
  ------------------
   92|  6.29k|            return ConstructGeneric4Bytes(bits, impl);
   93|      0|        case 5:
  ------------------
  |  Branch (93:9): [True: 0, False: 6.29k]
  ------------------
   94|      0|            return ConstructGeneric5Bytes(bits, impl);
   95|      0|        case 6:
  ------------------
  |  Branch (95:9): [True: 0, False: 6.29k]
  ------------------
   96|      0|            return ConstructGeneric6Bytes(bits, impl);
   97|      0|        case 7:
  ------------------
  |  Branch (97:9): [True: 0, False: 6.29k]
  ------------------
   98|      0|            return ConstructGeneric7Bytes(bits, impl);
   99|      0|        case 8:
  ------------------
  |  Branch (99:9): [True: 0, False: 6.29k]
  ------------------
  100|      0|            return ConstructGeneric8Bytes(bits, impl);
  101|      0|        default:
  ------------------
  |  Branch (101:9): [True: 0, False: 6.29k]
  ------------------
  102|      0|            return nullptr;
  103|  6.29k|        }
  104|      0|        break;
  105|      0|#ifdef HAVE_CLMUL
  106|  3.71k|    case FieldImpl::CLMUL:
  ------------------
  |  Branch (106:5): [True: 3.71k, False: 6.29k]
  ------------------
  107|  3.71k|        if (EnableClmul()) {
  ------------------
  |  Branch (107:13): [True: 3.71k, False: 0]
  ------------------
  108|  3.71k|            switch ((bits + 7) / 8) {
  109|      0|            case 1:
  ------------------
  |  Branch (109:13): [True: 0, False: 3.71k]
  ------------------
  110|      0|                return ConstructClMul1Byte(bits, impl);
  111|      0|            case 2:
  ------------------
  |  Branch (111:13): [True: 0, False: 3.71k]
  ------------------
  112|      0|                return ConstructClMul2Bytes(bits, impl);
  113|      0|            case 3:
  ------------------
  |  Branch (113:13): [True: 0, False: 3.71k]
  ------------------
  114|      0|                return ConstructClMul3Bytes(bits, impl);
  115|  3.71k|            case 4:
  ------------------
  |  Branch (115:13): [True: 3.71k, False: 0]
  ------------------
  116|  3.71k|                return ConstructClMul4Bytes(bits, impl);
  117|      0|            case 5:
  ------------------
  |  Branch (117:13): [True: 0, False: 3.71k]
  ------------------
  118|      0|                return ConstructClMul5Bytes(bits, impl);
  119|      0|            case 6:
  ------------------
  |  Branch (119:13): [True: 0, False: 3.71k]
  ------------------
  120|      0|                return ConstructClMul6Bytes(bits, impl);
  121|      0|            case 7:
  ------------------
  |  Branch (121:13): [True: 0, False: 3.71k]
  ------------------
  122|      0|                return ConstructClMul7Bytes(bits, impl);
  123|      0|            case 8:
  ------------------
  |  Branch (123:13): [True: 0, False: 3.71k]
  ------------------
  124|      0|                return ConstructClMul8Bytes(bits, impl);
  125|      0|            default:
  ------------------
  |  Branch (125:13): [True: 0, False: 3.71k]
  ------------------
  126|      0|                return nullptr;
  127|  3.71k|            }
  128|  3.71k|        }
  129|      0|        break;
  130|      2|    case FieldImpl::CLMUL_TRI:
  ------------------
  |  Branch (130:5): [True: 2, False: 10.0k]
  ------------------
  131|      2|        if (EnableClmul()) {
  ------------------
  |  Branch (131:13): [True: 2, False: 0]
  ------------------
  132|      2|            switch ((bits + 7) / 8) {
  133|      0|            case 1:
  ------------------
  |  Branch (133:13): [True: 0, False: 2]
  ------------------
  134|      0|                return ConstructClMulTri1Byte(bits, impl);
  135|      0|            case 2:
  ------------------
  |  Branch (135:13): [True: 0, False: 2]
  ------------------
  136|      0|                return ConstructClMulTri2Bytes(bits, impl);
  137|      0|            case 3:
  ------------------
  |  Branch (137:13): [True: 0, False: 2]
  ------------------
  138|      0|                return ConstructClMulTri3Bytes(bits, impl);
  139|      2|            case 4:
  ------------------
  |  Branch (139:13): [True: 2, False: 0]
  ------------------
  140|      2|                return ConstructClMulTri4Bytes(bits, impl);
  141|      0|            case 5:
  ------------------
  |  Branch (141:13): [True: 0, False: 2]
  ------------------
  142|      0|                return ConstructClMulTri5Bytes(bits, impl);
  143|      0|            case 6:
  ------------------
  |  Branch (143:13): [True: 0, False: 2]
  ------------------
  144|      0|                return ConstructClMulTri6Bytes(bits, impl);
  145|      0|            case 7:
  ------------------
  |  Branch (145:13): [True: 0, False: 2]
  ------------------
  146|      0|                return ConstructClMulTri7Bytes(bits, impl);
  147|      0|            case 8:
  ------------------
  |  Branch (147:13): [True: 0, False: 2]
  ------------------
  148|      0|                return ConstructClMulTri8Bytes(bits, impl);
  149|      0|            default:
  ------------------
  |  Branch (149:13): [True: 0, False: 2]
  ------------------
  150|      0|                return nullptr;
  151|      2|            }
  152|      2|        }
  153|      0|        break;
  154|  10.0k|#endif
  155|  10.0k|    }
  156|      0|    return nullptr;
  157|  10.0k|}
minisketch.cpp:_ZN12_GLOBAL__N_111EnableClmulEv:
   68|  3.71k|{
   69|       |#ifdef _MSC_VER
   70|       |    int regs[4];
   71|       |    __cpuid(regs, 1);
   72|       |    return (regs[2] & 0x2);
   73|       |#else
   74|  3.71k|    uint32_t eax, ebx, ecx, edx;
   75|  3.71k|    return (__get_cpuid(1, &eax, &ebx, &ecx, &edx) && (ecx & 0x2));
  ------------------
  |  Branch (75:13): [True: 3.71k, False: 0]
  |  Branch (75:55): [True: 3.71k, False: 0]
  ------------------
   76|  3.71k|#endif
   77|  3.71k|}

_ZN6Sketch5ReadyEv:
   23|  8.00k|    void Ready() { m_canary = 0x6d496e536b65LU; }
_ZNK6Sketch5CheckEv:
   24|   124k|    void Check() const { if (m_canary != 0x6d496e536b65LU) abort(); }
  ------------------
  |  Branch (24:30): [True: 0, False: 124k]
  ------------------
_ZNK6Sketch4BitsEv:
   27|  12.0k|    int Bits() const { return m_bits; }
_ZNK6Sketch14ImplementationEv:
   26|  4.00k|    int Implementation() const { return m_implementation; }
_ZN6Sketch7UnReadyEv:
   25|  8.00k|    void UnReady() { m_canary = 1; }
_ZN6SketchC2Eii:
   21|  10.0k|    Sketch(int implementation, int bits) : m_implementation(implementation), m_bits(bits) {}
_ZN6SketchD2Ev:
   29|  10.0k|    virtual ~Sketch() {}

generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEC2IJEEEiiDpRKT_:
  363|  6.29k|    SketchImpl(int implementation, int bits, const Args&... args) : Sketch(implementation, bits), m_field(args...) {
  364|  6.29k|        std::random_device rng;
  365|  6.29k|        std::uniform_int_distribution<uint64_t> dist;
  366|  6.29k|        m_basis = m_field.FromSeed(dist(rng));
  367|  6.29k|    }
generic_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE9SyndromesEv:
  369|  5.03k|    size_t Syndromes() const override { return m_syndromes.size(); }
generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE4InitEm:
  370|  5.03k|    void Init(size_t count) override { m_syndromes.assign(count, 0); }
generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE3AddEm:
  373|  51.0k|    {
  374|  51.0k|        auto elem = m_field.FromUint64(val);
  375|  51.0k|        AddToOddSyndromes(m_syndromes, elem, m_field);
  376|  51.0k|    }
generic_4bytes.cpp:_Z17AddToOddSyndromesIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEES9_RKS8_:
  337|  51.0k|void AddToOddSyndromes(std::vector<typename F::Elem>& osyndromes, typename F::Elem data, const F& field) {
  338|  51.0k|    auto sqr = field.Sqr(data);
  339|  51.0k|    typename F::Multiplier mul(field, sqr);
  340|  4.34M|    for (auto& osyndrome : osyndromes) {
  ------------------
  |  Branch (340:26): [True: 4.34M, False: 51.0k]
  ------------------
  341|  4.34M|        osyndrome ^= data;
  342|  4.34M|        data = mul(data);
  343|  4.34M|    }
  344|  51.0k|}
generic_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE9SerializeEPh:
  379|  2.51k|    {
  380|  2.51k|        BitWriter writer(ptr);
  381|   217k|        for (const auto& val : m_syndromes) {
  ------------------
  |  Branch (381:30): [True: 217k, False: 2.51k]
  ------------------
  382|   217k|            m_field.Serialize(writer, val);
  383|   217k|        }
  384|  2.51k|        writer.Flush();
  385|  2.51k|    }
generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE11DeserializeEPKh:
  388|  2.51k|    {
  389|  2.51k|        BitReader reader(ptr);
  390|   217k|        for (auto& val : m_syndromes) {
  ------------------
  |  Branch (390:24): [True: 217k, False: 2.51k]
  ------------------
  391|   217k|            val = m_field.Deserialize(reader);
  392|   217k|        }
  393|  2.51k|    }
generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE5MergeEPK6Sketch:
  413|  1.25k|    {
  414|       |        // Sad cast. This is safe only because the caller code in minisketch.cpp checks
  415|       |        // that implementation and field size match.
  416|  1.25k|        const SketchImpl* other = static_cast<const SketchImpl*>(other_sketch);
  417|  1.25k|        m_syndromes.resize(std::min(m_syndromes.size(), other->m_syndromes.size()));
  418|   109k|        for (size_t i = 0; i < m_syndromes.size(); ++i) {
  ------------------
  |  Branch (418:28): [True: 108k, False: 1.25k]
  ------------------
  419|   108k|            m_syndromes[i] ^= other->m_syndromes[i];
  420|   108k|        }
  421|  1.25k|        return m_syndromes.size();
  422|  1.25k|    }
generic_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE7SetSeedEm:
  425|  5.03k|    {
  426|  5.03k|        if (seed == (uint64_t)-1) {
  ------------------
  |  Branch (426:13): [True: 226, False: 4.80k]
  ------------------
  427|    226|            m_basis = 1;
  428|  4.80k|        } else {
  429|  4.80k|            m_basis = m_field.FromSeed(seed);
  430|  4.80k|        }
  431|  5.03k|    }
generic_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEE6DecodeEiPm:
  396|  1.23k|    {
  397|  1.23k|        auto all_syndromes = ReconstructAllSyndromes(m_syndromes, m_field);
  398|  1.23k|        auto poly = BerlekampMassey(all_syndromes, max_count, m_field);
  399|  1.23k|        if (poly.size() == 0) return -1;
  ------------------
  |  Branch (399:13): [True: 0, False: 1.23k]
  ------------------
  400|  1.23k|        if (poly.size() == 1) return 0;
  ------------------
  |  Branch (400:13): [True: 197, False: 1.04k]
  ------------------
  401|  1.04k|        if ((int)poly.size() > 1 + max_count) return -1;
  ------------------
  |  Branch (401:13): [True: 0, False: 1.04k]
  ------------------
  402|  1.04k|        std::reverse(poly.begin(), poly.end());
  403|  1.04k|        auto roots = FindRoots(poly, m_basis, m_field);
  404|  1.04k|        if (roots.size() == 0) return -1;
  ------------------
  |  Branch (404:13): [True: 0, False: 1.04k]
  ------------------
  405|       |
  406|  12.0k|        for (const auto& root : roots) {
  ------------------
  |  Branch (406:31): [True: 12.0k, False: 1.04k]
  ------------------
  407|  12.0k|            *(out++) = m_field.ToUint64(root);
  408|  12.0k|        }
  409|  1.04k|        return static_cast<int>(roots.size());
  410|  1.04k|    }
generic_4bytes.cpp:_Z23ReconstructAllSyndromesIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEENSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERKSC_RKS8_:
  326|  1.23k|std::vector<typename F::Elem> ReconstructAllSyndromes(const std::vector<typename F::Elem>& odd_syndromes, const F& field) {
  327|  1.23k|    std::vector<typename F::Elem> all_syndromes;
  328|  1.23k|    all_syndromes.resize(odd_syndromes.size() * 2);
  329|   108k|    for (size_t i = 0; i < odd_syndromes.size(); ++i) {
  ------------------
  |  Branch (329:24): [True: 107k, False: 1.23k]
  ------------------
  330|   107k|        all_syndromes[i * 2] = odd_syndromes[i];
  331|   107k|        all_syndromes[i * 2 + 1] = field.Sqr(all_syndromes[i]);
  332|   107k|    }
  333|  1.23k|    return all_syndromes;
  334|  1.23k|}
generic_4bytes.cpp:_Z15BerlekampMasseyIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEENSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERKSC_mRKS8_:
  282|  1.23k|std::vector<typename F::Elem> BerlekampMassey(const std::vector<typename F::Elem>& syndromes, size_t max_degree, const F& field) {
  283|  1.23k|    std::vector<typename F::Multiplier> table;
  284|  1.23k|    std::vector<typename F::Elem> current, prev, tmp;
  285|  1.23k|    current.reserve(syndromes.size() / 2 + 1);
  286|  1.23k|    prev.reserve(syndromes.size() / 2 + 1);
  287|  1.23k|    tmp.reserve(syndromes.size() / 2 + 1);
  288|  1.23k|    current.resize(1);
  289|  1.23k|    current[0] = 1;
  290|  1.23k|    prev.resize(1);
  291|  1.23k|    prev[0] = 1;
  292|  1.23k|    typename F::Elem b = 1, b_inv = 1;
  293|  1.23k|    bool b_have_inv = true;
  294|  1.23k|    table.reserve(syndromes.size());
  295|       |
  296|   215k|    for (size_t n = 0; n != syndromes.size(); ++n) {
  ------------------
  |  Branch (296:24): [True: 214k, False: 1.23k]
  ------------------
  297|   214k|        table.emplace_back(field, syndromes[n]);
  298|   214k|        auto discrepancy = syndromes[n];
  299|  2.97M|        for (size_t i = 1; i < current.size(); ++i) discrepancy ^= table[n - i](current[i]);
  ------------------
  |  Branch (299:28): [True: 2.76M, False: 214k]
  ------------------
  300|   214k|        if (discrepancy != 0) {
  ------------------
  |  Branch (300:13): [True: 11.8k, False: 202k]
  ------------------
  301|  11.8k|            int x = static_cast<int>(n + 1 - (current.size() - 1) - (prev.size() - 1));
  302|  11.8k|            if (!b_have_inv) {
  ------------------
  |  Branch (302:17): [True: 10.6k, False: 1.25k]
  ------------------
  303|  10.6k|                b_inv = field.Inv(b);
  304|  10.6k|                b_have_inv = true;
  305|  10.6k|            }
  306|  11.8k|            bool swap = 2 * (current.size() - 1) <= n;
  307|  11.8k|            if (swap) {
  ------------------
  |  Branch (307:17): [True: 11.6k, False: 219]
  ------------------
  308|  11.6k|                if (prev.size() + x - 1 > max_degree) return {}; // We'd exceed maximum degree
  ------------------
  |  Branch (308:21): [True: 0, False: 11.6k]
  ------------------
  309|  11.6k|                tmp = current;
  310|  11.6k|                current.resize(prev.size() + x);
  311|  11.6k|            }
  312|  11.8k|            typename F::Multiplier mul(field, field.Mul(discrepancy, b_inv));
  313|   462k|            for (size_t i = 0; i < prev.size(); ++i) current[i + x] ^= mul(prev[i]);
  ------------------
  |  Branch (313:32): [True: 451k, False: 11.8k]
  ------------------
  314|  11.8k|            if (swap) {
  ------------------
  |  Branch (314:17): [True: 11.6k, False: 219]
  ------------------
  315|  11.6k|                std::swap(prev, tmp);
  316|  11.6k|                b = discrepancy;
  317|  11.6k|                b_have_inv = false;
  318|  11.6k|            }
  319|  11.8k|        }
  320|   214k|    }
  321|  1.23k|    CHECK_RETURN(current.size() && current.back() != 0, {});
  ------------------
  |  |   67|  1.23k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  1.23k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  2.47k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 1.23k]
  |  |  |  |  |  Branch (24:39): [True: 1.23k, False: 0]
  |  |  |  |  |  Branch (24:39): [True: 1.23k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  1.23k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  322|  1.23k|    return current;
  323|  1.23k|}
generic_4bytes.cpp:_Z9FindRootsIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEENSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERKSC_S9_RKS8_:
  264|  1.04k|std::vector<typename F::Elem> FindRoots(const std::vector<typename F::Elem>& poly, typename F::Elem basis, const F& field) {
  265|  1.04k|    std::vector<typename F::Elem> roots;
  266|  1.04k|    CHECK_RETURN(poly.size() != 0, {});
  ------------------
  |  |   67|  1.04k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  1.04k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  1.04k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  1.04k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  267|  1.04k|    CHECK_RETURN(basis != 0, {});
  ------------------
  |  |   67|  1.04k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  1.04k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  1.04k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  1.04k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  268|  1.04k|    if (poly.size() == 1) return roots; // No roots when the polynomial is a constant.
  ------------------
  |  Branch (268:9): [True: 0, False: 1.04k]
  ------------------
  269|  1.04k|    roots.reserve(poly.size() - 1);
  270|  1.04k|    std::vector<std::vector<typename F::Elem>> stack = {poly};
  271|       |
  272|       |    // Invoke the recursive factorization algorithm.
  273|  1.04k|    if (!RecFindRoots(stack, 0, roots, false, 0, basis, field)) {
  ------------------
  |  Branch (273:9): [True: 0, False: 1.04k]
  ------------------
  274|       |        // Not fully factorizable.
  275|      0|        return {};
  276|      0|    }
  277|  1.04k|    CHECK_RETURN(poly.size() - 1 == roots.size(), {});
  ------------------
  |  |   67|  1.04k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  1.04k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  1.04k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  1.04k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  278|  1.04k|    return roots;
  279|  1.04k|}
generic_4bytes.cpp:_Z12RecFindRootsIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEbRNSt3__16vectorINS7_INT_4ElemENS6_9allocatorIS9_EEEENSA_ISC_EEEEmRSC_biS9_RKS8_:
  129|  14.5k|bool RecFindRoots(std::vector<std::vector<typename F::Elem>>& stack, size_t pos, std::vector<typename F::Elem>& roots, bool fully_factorizable, int depth, typename F::Elem randv, const F& field) {
  130|  14.5k|    auto& ppoly = stack[pos];
  131|       |    // We assert ppoly.size() > 1 (instead of just ppoly.size() > 0) to additionally exclude
  132|       |    // constants polynomials because
  133|       |    //  - ppoly is not constant initially (this is ensured by FindRoots()), and
  134|       |    //  - we never recurse on a constant polynomial.
  135|  14.5k|    CHECK_SAFE(ppoly.size() > 1 && ppoly.back() == 1);
  136|       |    /* 1st degree input: constant term is the root. */
  137|  14.5k|    if (ppoly.size() == 2) {
  ------------------
  |  Branch (137:9): [True: 3.52k, False: 11.0k]
  ------------------
  138|  3.52k|        roots.push_back(ppoly[0]);
  139|  3.52k|        return true;
  140|  3.52k|    }
  141|       |    /* 2nd degree input: use direct quadratic solver. */
  142|  11.0k|    if (ppoly.size() == 3) {
  ------------------
  |  Branch (142:9): [True: 4.28k, False: 6.76k]
  ------------------
  143|  4.28k|        CHECK_RETURN(ppoly[1] != 0, false); // Equations of the form (x^2 + a) have two identical solutions; contradicts square-free assumption. */
  ------------------
  |  |   67|  4.28k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  4.28k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  4.28k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 4.28k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  4.28k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  144|  4.28k|        auto input = field.Mul(ppoly[0], field.Sqr(field.Inv(ppoly[1])));
  145|  4.28k|        auto root = field.Qrt(input);
  146|  4.28k|        if ((field.Sqr(root) ^ root) != input) {
  ------------------
  |  Branch (146:13): [True: 0, False: 4.28k]
  ------------------
  147|      0|            CHECK_SAFE(!fully_factorizable);
  148|      0|            return false; // No root found.
  149|      0|        }
  150|  4.28k|        auto sol = field.Mul(root, ppoly[1]);
  151|  4.28k|        roots.push_back(sol);
  152|  4.28k|        roots.push_back(sol ^ ppoly[1]);
  153|  4.28k|        return true;
  154|  4.28k|    }
  155|       |    /* 3rd degree input and more: recurse further. */
  156|  6.76k|    if (pos + 3 > stack.size()) {
  ------------------
  |  Branch (156:9): [True: 546, False: 6.21k]
  ------------------
  157|       |        // Allocate memory if necessary.
  158|    546|        stack.resize((pos + 3) * 2);
  159|    546|    }
  160|  6.76k|    auto& poly = stack[pos];
  161|  6.76k|    auto& tmp = stack[pos + 1];
  162|  6.76k|    auto& trace = stack[pos + 2];
  163|  6.76k|    trace.clear();
  164|  6.76k|    tmp.clear();
  165|  10.7k|    for (int iter = 0;; ++iter) {
  166|       |        // Compute the polynomial (trace(x*randv) mod poly(x)) symbolically,
  167|       |        // and put the result in `trace`.
  168|  10.7k|        TraceMod(poly, trace, randv, field);
  169|       |
  170|  10.7k|        if (iter >= 1 && !fully_factorizable) {
  ------------------
  |  Branch (170:13): [True: 3.98k, False: 6.76k]
  |  Branch (170:26): [True: 180, False: 3.80k]
  ------------------
  171|       |            // If the polynomial cannot be factorized completely (it has an
  172|       |            // irreducible factor of degree higher than 1), we want to avoid
  173|       |            // the case where this is only detected after trying all BITS
  174|       |            // independent split attempts fail (see the assert below).
  175|       |            //
  176|       |            // Observe that if we call y = randv*x, it is true that:
  177|       |            //
  178|       |            //   trace = y + y^2 + y^4 + y^8 + ... y^(FIELDSIZE/2) mod poly
  179|       |            //
  180|       |            // Due to the Frobenius endomorphism, this means:
  181|       |            //
  182|       |            //   trace^2 = y^2 + y^4 + y^8 + ... + y^FIELDSIZE mod poly
  183|       |            //
  184|       |            // Or, adding them up:
  185|       |            //
  186|       |            //   trace + trace^2 = y + y^FIELDSIZE mod poly.
  187|       |            //                   = randv*x + randv^FIELDSIZE*x^FIELDSIZE
  188|       |            //                   = randv*x + randv*x^FIELDSIZE
  189|       |            //                   = randv*(x + x^FIELDSIZE).
  190|       |            //     (all mod poly)
  191|       |            //
  192|       |            // x + x^FIELDSIZE is the polynomial which has every field element
  193|       |            // as root once. Whenever x + x^FIELDSIZE is multiple of poly,
  194|       |            // this means it only has unique first degree factors. The same
  195|       |            // holds for its constant multiple randv*(x + x^FIELDSIZE) =
  196|       |            // trace + trace^2.
  197|       |            //
  198|       |            // We use this test to quickly verify whether the polynomial is
  199|       |            // fully factorizable after already having computed a trace.
  200|       |            // We don't invoke it immediately; only when splitting has failed
  201|       |            // at least once, which avoids it for most polynomials that are
  202|       |            // fully factorizable (or at least pushes the test down the
  203|       |            // recursion to factors which are smaller and thus faster).
  204|    180|            tmp = trace;
  205|    180|            Sqr(tmp, field);
  206|  1.49k|            for (size_t i = 0; i < trace.size(); ++i) {
  ------------------
  |  Branch (206:32): [True: 1.31k, False: 180]
  ------------------
  207|  1.31k|                tmp[i] ^= trace[i];
  208|  1.31k|            }
  209|    227|            while (tmp.size() && tmp.back() == 0) tmp.pop_back();
  ------------------
  |  Branch (209:20): [True: 152, False: 75]
  |  Branch (209:34): [True: 47, False: 105]
  ------------------
  210|    180|            PolyMod(poly, tmp, field);
  211|       |
  212|       |            // Whenever the test fails, we can immediately abort the root
  213|       |            // finding. Whenever it succeeds, we can remember and pass down
  214|       |            // the information that it is in fact fully factorizable, avoiding
  215|       |            // the need to run the test again.
  216|    180|            if (tmp.size() != 0) return false;
  ------------------
  |  Branch (216:17): [True: 0, False: 180]
  ------------------
  217|    180|            fully_factorizable = true;
  218|    180|        }
  219|       |
  220|  10.7k|        if (fully_factorizable) {
  ------------------
  |  Branch (220:13): [True: 9.66k, False: 1.08k]
  ------------------
  221|       |            // Every successful iteration of this algorithm splits the input
  222|       |            // polynomial further into buckets, each corresponding to a subset
  223|       |            // of 2^(BITS-depth) roots. If after depth splits the degree of
  224|       |            // the polynomial is >= 2^(BITS-depth), something is wrong.
  225|  9.66k|            CHECK_RETURN(field.Bits() - depth >= std::numeric_limits<decltype(poly.size())>::digits ||
  ------------------
  |  |   67|  9.66k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  9.66k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  19.3k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 9.66k]
  |  |  |  |  |  Branch (24:39): [True: 0, False: 9.66k]
  |  |  |  |  |  Branch (24:39): [True: 9.66k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  9.66k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  226|  9.66k|                (poly.size() - 2) >> (field.Bits() - depth) == 0, false);
  227|  9.66k|        }
  228|       |
  229|  10.7k|        depth++;
  230|       |        // In every iteration we multiply randv by 2. As a result, the set
  231|       |        // of randv values forms a GF(2)-linearly independent basis of splits.
  232|  10.7k|        randv = field.Mul2(randv);
  233|  10.7k|        tmp = poly;
  234|  10.7k|        GCD(trace, tmp, field);
  235|  10.7k|        if (trace.size() != poly.size() && trace.size() > 1) break;
  ------------------
  |  Branch (235:13): [True: 8.34k, False: 2.39k]
  |  Branch (235:44): [True: 6.76k, False: 1.58k]
  ------------------
  236|  10.7k|    }
  237|  6.76k|    MakeMonic(trace, field);
  238|  6.76k|    DivMod(trace, poly, tmp, field);
  239|       |    // At this point, the stack looks like [... (poly) tmp trace], and we want to recursively
  240|       |    // find roots of trace and tmp (= poly/trace). As we don't care about poly anymore, move
  241|       |    // trace into its position first.
  242|  6.76k|    std::swap(poly, trace);
  243|       |    // Now the stack is [... (trace) tmp ...]. First we factor tmp (at pos = pos+1), and then
  244|       |    // we factor trace (at pos = pos).
  245|  6.76k|    if (!RecFindRoots(stack, pos + 1, roots, fully_factorizable, depth, randv, field)) return false;
  ------------------
  |  Branch (245:9): [True: 0, False: 6.76k]
  ------------------
  246|       |    // The stack position pos contains trace, the polynomial with all of poly's roots which (after
  247|       |    // multiplication with randv) have trace 0. This is never the case for irreducible factors
  248|       |    // (which always end up in tmp), so we can set fully_factorizable to true when recursing.
  249|  6.76k|    bool ret = RecFindRoots(stack, pos, roots, true, depth, randv, field);
  250|       |    // Because of the above, recursion can never fail here.
  251|  6.76k|    CHECK_SAFE(ret);
  252|  6.76k|    return ret;
  253|  6.76k|}
generic_4bytes.cpp:_Z8TraceModIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRKNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERSC_RKS9_RKS8_:
  103|  10.7k|void TraceMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& out, const typename F::Elem& param, const F& field) {
  104|  10.7k|    out.reserve(mod.size() * 2);
  105|  10.7k|    out.resize(2);
  106|  10.7k|    out[0] = 0;
  107|  10.7k|    out[1] = param;
  108|       |
  109|   343k|    for (int i = 0; i < field.Bits() - 1; ++i) {
  ------------------
  |  Branch (109:21): [True: 333k, False: 10.7k]
  ------------------
  110|   333k|        Sqr(out, field);
  111|   333k|        if (out.size() < 2) out.resize(2);
  ------------------
  |  Branch (111:13): [True: 2, False: 333k]
  ------------------
  112|   333k|        out[1] = param;
  113|   333k|        PolyMod(mod, out, field);
  114|   333k|    }
  115|  10.7k|}
generic_4bytes.cpp:_Z3SqrIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERKS8_:
   92|   333k|void Sqr(std::vector<typename F::Elem>& poly, const F& field) {
   93|   333k|    if (poly.size() == 0) return;
  ------------------
  |  Branch (93:9): [True: 28, False: 333k]
  ------------------
   94|   333k|    poly.resize(poly.size() * 2 - 1);
   95|  4.87M|    for (size_t i = 0; i < poly.size(); ++i) {
  ------------------
  |  Branch (95:24): [True: 4.54M, False: 333k]
  ------------------
   96|  4.54M|        auto x = poly.size() - i - 1;
   97|  4.54M|        poly[x] = (x & 1) ? 0 : field.Sqr(poly[x / 2]);
  ------------------
  |  Branch (97:19): [True: 2.10M, False: 2.43M]
  ------------------
   98|  4.54M|    }
   99|   333k|}
generic_4bytes.cpp:_Z7PolyModIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRKNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERSC_RKS8_:
   18|   357k|void PolyMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& val, const F& field) {
   19|   357k|    size_t modsize = mod.size();
   20|   357k|    CHECK_SAFE(modsize > 0 && mod.back() == 1);
   21|   357k|    if (val.size() < modsize) return;
  ------------------
  |  Branch (21:9): [True: 18.7k, False: 338k]
  ------------------
   22|   338k|    CHECK_SAFE(val.back() != 0);
   23|  2.38M|    while (val.size() >= modsize) {
  ------------------
  |  Branch (23:12): [True: 2.05M, False: 338k]
  ------------------
   24|  2.05M|        auto term = val.back();
   25|  2.05M|        val.pop_back();
   26|  2.05M|        if (term != 0) {
  ------------------
  |  Branch (26:13): [True: 2.04M, False: 3.60k]
  ------------------
   27|  2.04M|            typename F::Multiplier mul(field, term);
   28|  66.9M|            for (size_t x = 0; x < mod.size() - 1; ++x) {
  ------------------
  |  Branch (28:32): [True: 64.8M, False: 2.04M]
  ------------------
   29|  64.8M|                val[val.size() - modsize + 1 + x] ^= mul(mod[x]);
   30|  64.8M|            }
   31|  2.04M|        }
   32|  2.05M|    }
   33|   449k|    while (val.size() > 0 && val.back() == 0) val.pop_back();
  ------------------
  |  Branch (33:12): [True: 440k, False: 9.26k]
  |  Branch (33:30): [True: 110k, False: 329k]
  ------------------
   34|   338k|}
generic_4bytes.cpp:_Z3GCDIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEESD_RKS8_:
   76|  10.7k|void GCD(std::vector<typename F::Elem>& a, std::vector<typename F::Elem>& b, const F& field) {
   77|  10.7k|    if (a.size() < b.size()) std::swap(a, b);
  ------------------
  |  Branch (77:9): [True: 10.7k, False: 0]
  ------------------
   78|  35.1k|    while (b.size() > 0) {
  ------------------
  |  Branch (78:12): [True: 25.9k, False: 9.15k]
  ------------------
   79|  25.9k|        if (b.size() == 1) {
  ------------------
  |  Branch (79:13): [True: 1.58k, False: 24.4k]
  ------------------
   80|  1.58k|            a.resize(1);
   81|  1.58k|            a[0] = 1;
   82|  1.58k|            return;
   83|  1.58k|        }
   84|  24.4k|        MakeMonic(b, field);
   85|  24.4k|        PolyMod(b, a, field);
   86|  24.4k|        std::swap(a, b);
   87|  24.4k|    }
   88|  10.7k|}
generic_4bytes.cpp:_Z9MakeMonicIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEENT_4ElemERNSt3__16vectorIS7_NS8_9allocatorIS7_EEEERKS6_:
   62|  31.1k|typename F::Elem MakeMonic(std::vector<typename F::Elem>& a, const F& field) {
   63|  31.1k|    CHECK_SAFE(a.back() != 0);
   64|  31.1k|    if (a.back() == 1) return 0;
  ------------------
  |  Branch (64:9): [True: 6.76k, False: 24.4k]
  ------------------
   65|  24.4k|    auto inv = field.Inv(a.back());
   66|  24.4k|    typename F::Multiplier mul(field, inv);
   67|  24.4k|    a.back() = 1;
   68|   615k|    for (size_t i = 0; i < a.size() - 1; ++i) {
  ------------------
  |  Branch (68:24): [True: 591k, False: 24.4k]
  ------------------
   69|   591k|        a[i] = mul(a[i]);
   70|   591k|    }
   71|  24.4k|    return inv;
   72|  31.1k|}
generic_4bytes.cpp:_Z6DivModIN12_GLOBAL__N_15FieldIjLi32ELj141E11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEES2_IjJLi4ELi4ELi4ELi4ELi4ELi4ELi4ELi4EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEEEEvRKNSt3__16vectorINT_4ElemENS6_9allocatorIS9_EEEERSC_SF_RKS8_:
   38|  6.76k|void DivMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& val, std::vector<typename F::Elem>& div, const F& field) {
   39|  6.76k|    size_t modsize = mod.size();
   40|  6.76k|    CHECK_SAFE(mod.size() > 0 && mod.back() == 1);
   41|  6.76k|    if (val.size() < mod.size()) {
  ------------------
  |  Branch (41:9): [True: 0, False: 6.76k]
  ------------------
   42|      0|        div.clear();
   43|      0|        return;
   44|      0|    }
   45|  6.76k|    CHECK_SAFE(val.back() != 0);
   46|  6.76k|    div.resize(val.size() - mod.size() + 1);
   47|  48.4k|    while (val.size() >= modsize) {
  ------------------
  |  Branch (47:12): [True: 41.6k, False: 6.76k]
  ------------------
   48|  41.6k|        auto term = val.back();
   49|  41.6k|        div[val.size() - modsize] = term;
   50|  41.6k|        val.pop_back();
   51|  41.6k|        if (term != 0) {
  ------------------
  |  Branch (51:13): [True: 40.8k, False: 748]
  ------------------
   52|  40.8k|            typename F::Multiplier mul(field, term);
   53|   522k|            for (size_t x = 0; x < mod.size() - 1; ++x) {
  ------------------
  |  Branch (53:32): [True: 481k, False: 40.8k]
  ------------------
   54|   481k|                val[val.size() - modsize + 1 + x] ^= mul(mod[x]);
   55|   481k|            }
   56|  40.8k|        }
   57|  41.6k|    }
   58|  6.76k|}
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEC2IJEEEiiDpRKT_:
  363|  3.71k|    SketchImpl(int implementation, int bits, const Args&... args) : Sketch(implementation, bits), m_field(args...) {
  364|  3.71k|        std::random_device rng;
  365|  3.71k|        std::uniform_int_distribution<uint64_t> dist;
  366|  3.71k|        m_basis = m_field.FromSeed(dist(rng));
  367|  3.71k|    }
clmul_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE9SyndromesEv:
  369|  2.97k|    size_t Syndromes() const override { return m_syndromes.size(); }
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE4InitEm:
  370|  2.97k|    void Init(size_t count) override { m_syndromes.assign(count, 0); }
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE3AddEm:
  373|  43.9k|    {
  374|  43.9k|        auto elem = m_field.FromUint64(val);
  375|  43.9k|        AddToOddSyndromes(m_syndromes, elem, m_field);
  376|  43.9k|    }
clmul_4bytes.cpp:_Z17AddToOddSyndromesIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEESA_RKS3_:
  337|  43.9k|void AddToOddSyndromes(std::vector<typename F::Elem>& osyndromes, typename F::Elem data, const F& field) {
  338|  43.9k|    auto sqr = field.Sqr(data);
  339|  43.9k|    typename F::Multiplier mul(field, sqr);
  340|  4.96M|    for (auto& osyndrome : osyndromes) {
  ------------------
  |  Branch (340:26): [True: 4.96M, False: 43.9k]
  ------------------
  341|  4.96M|        osyndrome ^= data;
  342|  4.96M|        data = mul(data);
  343|  4.96M|    }
  344|  43.9k|}
clmul_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE9SerializeEPh:
  379|  1.48k|    {
  380|  1.48k|        BitWriter writer(ptr);
  381|   144k|        for (const auto& val : m_syndromes) {
  ------------------
  |  Branch (381:30): [True: 144k, False: 1.48k]
  ------------------
  382|   144k|            m_field.Serialize(writer, val);
  383|   144k|        }
  384|  1.48k|        writer.Flush();
  385|  1.48k|    }
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE11DeserializeEPKh:
  388|  1.48k|    {
  389|  1.48k|        BitReader reader(ptr);
  390|   144k|        for (auto& val : m_syndromes) {
  ------------------
  |  Branch (390:24): [True: 144k, False: 1.48k]
  ------------------
  391|   144k|            val = m_field.Deserialize(reader);
  392|   144k|        }
  393|  1.48k|    }
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE5MergeEPK6Sketch:
  413|    743|    {
  414|       |        // Sad cast. This is safe only because the caller code in minisketch.cpp checks
  415|       |        // that implementation and field size match.
  416|    743|        const SketchImpl* other = static_cast<const SketchImpl*>(other_sketch);
  417|    743|        m_syndromes.resize(std::min(m_syndromes.size(), other->m_syndromes.size()));
  418|  73.1k|        for (size_t i = 0; i < m_syndromes.size(); ++i) {
  ------------------
  |  Branch (418:28): [True: 72.4k, False: 743]
  ------------------
  419|  72.4k|            m_syndromes[i] ^= other->m_syndromes[i];
  420|  72.4k|        }
  421|    743|        return m_syndromes.size();
  422|    743|    }
clmul_4bytes.cpp:_ZN10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE7SetSeedEm:
  425|  2.97k|    {
  426|  2.97k|        if (seed == (uint64_t)-1) {
  ------------------
  |  Branch (426:13): [True: 126, False: 2.84k]
  ------------------
  427|    126|            m_basis = 1;
  428|  2.84k|        } else {
  429|  2.84k|            m_basis = m_field.FromSeed(seed);
  430|  2.84k|        }
  431|  2.97k|    }
clmul_4bytes.cpp:_ZNK10SketchImplIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEE6DecodeEiPm:
  396|    727|    {
  397|    727|        auto all_syndromes = ReconstructAllSyndromes(m_syndromes, m_field);
  398|    727|        auto poly = BerlekampMassey(all_syndromes, max_count, m_field);
  399|    727|        if (poly.size() == 0) return -1;
  ------------------
  |  Branch (399:13): [True: 0, False: 727]
  ------------------
  400|    727|        if (poly.size() == 1) return 0;
  ------------------
  |  Branch (400:13): [True: 169, False: 558]
  ------------------
  401|    558|        if ((int)poly.size() > 1 + max_count) return -1;
  ------------------
  |  Branch (401:13): [True: 0, False: 558]
  ------------------
  402|    558|        std::reverse(poly.begin(), poly.end());
  403|    558|        auto roots = FindRoots(poly, m_basis, m_field);
  404|    558|        if (roots.size() == 0) return -1;
  ------------------
  |  Branch (404:13): [True: 0, False: 558]
  ------------------
  405|       |
  406|  9.25k|        for (const auto& root : roots) {
  ------------------
  |  Branch (406:31): [True: 9.25k, False: 558]
  ------------------
  407|  9.25k|            *(out++) = m_field.ToUint64(root);
  408|  9.25k|        }
  409|    558|        return static_cast<int>(roots.size());
  410|    558|    }
clmul_4bytes.cpp:_Z23ReconstructAllSyndromesIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEENSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERKSD_RKS3_:
  326|    727|std::vector<typename F::Elem> ReconstructAllSyndromes(const std::vector<typename F::Elem>& odd_syndromes, const F& field) {
  327|    727|    std::vector<typename F::Elem> all_syndromes;
  328|    727|    all_syndromes.resize(odd_syndromes.size() * 2);
  329|  72.0k|    for (size_t i = 0; i < odd_syndromes.size(); ++i) {
  ------------------
  |  Branch (329:24): [True: 71.3k, False: 727]
  ------------------
  330|  71.3k|        all_syndromes[i * 2] = odd_syndromes[i];
  331|  71.3k|        all_syndromes[i * 2 + 1] = field.Sqr(all_syndromes[i]);
  332|  71.3k|    }
  333|    727|    return all_syndromes;
  334|    727|}
clmul_4bytes.cpp:_Z15BerlekampMasseyIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEENSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERKSD_mRKS3_:
  282|    727|std::vector<typename F::Elem> BerlekampMassey(const std::vector<typename F::Elem>& syndromes, size_t max_degree, const F& field) {
  283|    727|    std::vector<typename F::Multiplier> table;
  284|    727|    std::vector<typename F::Elem> current, prev, tmp;
  285|    727|    current.reserve(syndromes.size() / 2 + 1);
  286|    727|    prev.reserve(syndromes.size() / 2 + 1);
  287|    727|    tmp.reserve(syndromes.size() / 2 + 1);
  288|    727|    current.resize(1);
  289|    727|    current[0] = 1;
  290|    727|    prev.resize(1);
  291|    727|    prev[0] = 1;
  292|    727|    typename F::Elem b = 1, b_inv = 1;
  293|    727|    bool b_have_inv = true;
  294|    727|    table.reserve(syndromes.size());
  295|       |
  296|   143k|    for (size_t n = 0; n != syndromes.size(); ++n) {
  ------------------
  |  Branch (296:24): [True: 142k, False: 727]
  ------------------
  297|   142k|        table.emplace_back(field, syndromes[n]);
  298|   142k|        auto discrepancy = syndromes[n];
  299|  2.29M|        for (size_t i = 1; i < current.size(); ++i) discrepancy ^= table[n - i](current[i]);
  ------------------
  |  Branch (299:28): [True: 2.15M, False: 142k]
  ------------------
  300|   142k|        if (discrepancy != 0) {
  ------------------
  |  Branch (300:13): [True: 8.84k, False: 133k]
  ------------------
  301|  8.84k|            int x = static_cast<int>(n + 1 - (current.size() - 1) - (prev.size() - 1));
  302|  8.84k|            if (!b_have_inv) {
  ------------------
  |  Branch (302:17): [True: 7.88k, False: 962]
  ------------------
  303|  7.88k|                b_inv = field.Inv(b);
  304|  7.88k|                b_have_inv = true;
  305|  7.88k|            }
  306|  8.84k|            bool swap = 2 * (current.size() - 1) <= n;
  307|  8.84k|            if (swap) {
  ------------------
  |  Branch (307:17): [True: 8.43k, False: 409]
  ------------------
  308|  8.43k|                if (prev.size() + x - 1 > max_degree) return {}; // We'd exceed maximum degree
  ------------------
  |  Branch (308:21): [True: 0, False: 8.43k]
  ------------------
  309|  8.43k|                tmp = current;
  310|  8.43k|                current.resize(prev.size() + x);
  311|  8.43k|            }
  312|  8.84k|            typename F::Multiplier mul(field, field.Mul(discrepancy, b_inv));
  313|   296k|            for (size_t i = 0; i < prev.size(); ++i) current[i + x] ^= mul(prev[i]);
  ------------------
  |  Branch (313:32): [True: 287k, False: 8.84k]
  ------------------
  314|  8.84k|            if (swap) {
  ------------------
  |  Branch (314:17): [True: 8.43k, False: 409]
  ------------------
  315|  8.43k|                std::swap(prev, tmp);
  316|  8.43k|                b = discrepancy;
  317|  8.43k|                b_have_inv = false;
  318|  8.43k|            }
  319|  8.84k|        }
  320|   142k|    }
  321|    727|    CHECK_RETURN(current.size() && current.back() != 0, {});
  ------------------
  |  |   67|    727|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|    727|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  1.45k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 727]
  |  |  |  |  |  Branch (24:39): [True: 727, False: 0]
  |  |  |  |  |  Branch (24:39): [True: 727, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|    727|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  322|    727|    return current;
  323|    727|}
clmul_4bytes.cpp:_Z9FindRootsIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEENSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERKSD_SA_RKS3_:
  264|    558|std::vector<typename F::Elem> FindRoots(const std::vector<typename F::Elem>& poly, typename F::Elem basis, const F& field) {
  265|    558|    std::vector<typename F::Elem> roots;
  266|    558|    CHECK_RETURN(poly.size() != 0, {});
  ------------------
  |  |   67|    558|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|    558|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|    558|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 558]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|    558|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  267|    558|    CHECK_RETURN(basis != 0, {});
  ------------------
  |  |   67|    558|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|    558|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|    558|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 558]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|    558|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  268|    558|    if (poly.size() == 1) return roots; // No roots when the polynomial is a constant.
  ------------------
  |  Branch (268:9): [True: 0, False: 558]
  ------------------
  269|    558|    roots.reserve(poly.size() - 1);
  270|    558|    std::vector<std::vector<typename F::Elem>> stack = {poly};
  271|       |
  272|       |    // Invoke the recursive factorization algorithm.
  273|    558|    if (!RecFindRoots(stack, 0, roots, false, 0, basis, field)) {
  ------------------
  |  Branch (273:9): [True: 0, False: 558]
  ------------------
  274|       |        // Not fully factorizable.
  275|      0|        return {};
  276|      0|    }
  277|    558|    CHECK_RETURN(poly.size() - 1 == roots.size(), {});
  ------------------
  |  |   67|    558|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|    558|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|    558|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 558]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|    558|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  278|    558|    return roots;
  279|    558|}
clmul_4bytes.cpp:_Z12RecFindRootsIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEbRNSt3__16vectorINS9_INS3_4ElemENS8_9allocatorISA_EEEENSB_ISD_EEEEmRSD_biSA_RKS3_:
  129|  11.5k|bool RecFindRoots(std::vector<std::vector<typename F::Elem>>& stack, size_t pos, std::vector<typename F::Elem>& roots, bool fully_factorizable, int depth, typename F::Elem randv, const F& field) {
  130|  11.5k|    auto& ppoly = stack[pos];
  131|       |    // We assert ppoly.size() > 1 (instead of just ppoly.size() > 0) to additionally exclude
  132|       |    // constants polynomials because
  133|       |    //  - ppoly is not constant initially (this is ensured by FindRoots()), and
  134|       |    //  - we never recurse on a constant polynomial.
  135|  11.5k|    CHECK_SAFE(ppoly.size() > 1 && ppoly.back() == 1);
  136|       |    /* 1st degree input: constant term is the root. */
  137|  11.5k|    if (ppoly.size() == 2) {
  ------------------
  |  Branch (137:9): [True: 2.82k, False: 8.69k]
  ------------------
  138|  2.82k|        roots.push_back(ppoly[0]);
  139|  2.82k|        return true;
  140|  2.82k|    }
  141|       |    /* 2nd degree input: use direct quadratic solver. */
  142|  8.69k|    if (ppoly.size() == 3) {
  ------------------
  |  Branch (142:9): [True: 3.21k, False: 5.47k]
  ------------------
  143|  3.21k|        CHECK_RETURN(ppoly[1] != 0, false); // Equations of the form (x^2 + a) have two identical solutions; contradicts square-free assumption. */
  ------------------
  |  |   67|  3.21k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  144|  3.21k|        auto input = field.Mul(ppoly[0], field.Sqr(field.Inv(ppoly[1])));
  145|  3.21k|        auto root = field.Qrt(input);
  146|  3.21k|        if ((field.Sqr(root) ^ root) != input) {
  ------------------
  |  Branch (146:13): [True: 0, False: 3.21k]
  ------------------
  147|      0|            CHECK_SAFE(!fully_factorizable);
  148|      0|            return false; // No root found.
  149|      0|        }
  150|  3.21k|        auto sol = field.Mul(root, ppoly[1]);
  151|  3.21k|        roots.push_back(sol);
  152|  3.21k|        roots.push_back(sol ^ ppoly[1]);
  153|  3.21k|        return true;
  154|  3.21k|    }
  155|       |    /* 3rd degree input and more: recurse further. */
  156|  5.47k|    if (pos + 3 > stack.size()) {
  ------------------
  |  Branch (156:9): [True: 512, False: 4.96k]
  ------------------
  157|       |        // Allocate memory if necessary.
  158|    512|        stack.resize((pos + 3) * 2);
  159|    512|    }
  160|  5.47k|    auto& poly = stack[pos];
  161|  5.47k|    auto& tmp = stack[pos + 1];
  162|  5.47k|    auto& trace = stack[pos + 2];
  163|  5.47k|    trace.clear();
  164|  5.47k|    tmp.clear();
  165|  9.98k|    for (int iter = 0;; ++iter) {
  166|       |        // Compute the polynomial (trace(x*randv) mod poly(x)) symbolically,
  167|       |        // and put the result in `trace`.
  168|  9.98k|        TraceMod(poly, trace, randv, field);
  169|       |
  170|  9.98k|        if (iter >= 1 && !fully_factorizable) {
  ------------------
  |  Branch (170:13): [True: 4.50k, False: 5.47k]
  |  Branch (170:26): [True: 216, False: 4.28k]
  ------------------
  171|       |            // If the polynomial cannot be factorized completely (it has an
  172|       |            // irreducible factor of degree higher than 1), we want to avoid
  173|       |            // the case where this is only detected after trying all BITS
  174|       |            // independent split attempts fail (see the assert below).
  175|       |            //
  176|       |            // Observe that if we call y = randv*x, it is true that:
  177|       |            //
  178|       |            //   trace = y + y^2 + y^4 + y^8 + ... y^(FIELDSIZE/2) mod poly
  179|       |            //
  180|       |            // Due to the Frobenius endomorphism, this means:
  181|       |            //
  182|       |            //   trace^2 = y^2 + y^4 + y^8 + ... + y^FIELDSIZE mod poly
  183|       |            //
  184|       |            // Or, adding them up:
  185|       |            //
  186|       |            //   trace + trace^2 = y + y^FIELDSIZE mod poly.
  187|       |            //                   = randv*x + randv^FIELDSIZE*x^FIELDSIZE
  188|       |            //                   = randv*x + randv*x^FIELDSIZE
  189|       |            //                   = randv*(x + x^FIELDSIZE).
  190|       |            //     (all mod poly)
  191|       |            //
  192|       |            // x + x^FIELDSIZE is the polynomial which has every field element
  193|       |            // as root once. Whenever x + x^FIELDSIZE is multiple of poly,
  194|       |            // this means it only has unique first degree factors. The same
  195|       |            // holds for its constant multiple randv*(x + x^FIELDSIZE) =
  196|       |            // trace + trace^2.
  197|       |            //
  198|       |            // We use this test to quickly verify whether the polynomial is
  199|       |            // fully factorizable after already having computed a trace.
  200|       |            // We don't invoke it immediately; only when splitting has failed
  201|       |            // at least once, which avoids it for most polynomials that are
  202|       |            // fully factorizable (or at least pushes the test down the
  203|       |            // recursion to factors which are smaller and thus faster).
  204|    216|            tmp = trace;
  205|    216|            Sqr(tmp, field);
  206|  1.64k|            for (size_t i = 0; i < trace.size(); ++i) {
  ------------------
  |  Branch (206:32): [True: 1.43k, False: 216]
  ------------------
  207|  1.43k|                tmp[i] ^= trace[i];
  208|  1.43k|            }
  209|    262|            while (tmp.size() && tmp.back() == 0) tmp.pop_back();
  ------------------
  |  Branch (209:20): [True: 153, False: 109]
  |  Branch (209:34): [True: 46, False: 107]
  ------------------
  210|    216|            PolyMod(poly, tmp, field);
  211|       |
  212|       |            // Whenever the test fails, we can immediately abort the root
  213|       |            // finding. Whenever it succeeds, we can remember and pass down
  214|       |            // the information that it is in fact fully factorizable, avoiding
  215|       |            // the need to run the test again.
  216|    216|            if (tmp.size() != 0) return false;
  ------------------
  |  Branch (216:17): [True: 0, False: 216]
  ------------------
  217|    216|            fully_factorizable = true;
  218|    216|        }
  219|       |
  220|  9.98k|        if (fully_factorizable) {
  ------------------
  |  Branch (220:13): [True: 8.91k, False: 1.06k]
  ------------------
  221|       |            // Every successful iteration of this algorithm splits the input
  222|       |            // polynomial further into buckets, each corresponding to a subset
  223|       |            // of 2^(BITS-depth) roots. If after depth splits the degree of
  224|       |            // the polynomial is >= 2^(BITS-depth), something is wrong.
  225|  8.91k|            CHECK_RETURN(field.Bits() - depth >= std::numeric_limits<decltype(poly.size())>::digits ||
  ------------------
  |  |   67|  8.91k|#define CHECK_RETURN(cond, rvar) do { \
  |  |   68|  8.91k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |   24|  17.8k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (24:21): [True: 0, False: 8.91k]
  |  |  |  |  |  Branch (24:39): [True: 0, False: 8.91k]
  |  |  |  |  |  Branch (24:39): [True: 8.91k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|        return rvar; \
  |  |   70|      0|    } \
  |  |   71|  8.91k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  226|  8.91k|                (poly.size() - 2) >> (field.Bits() - depth) == 0, false);
  227|  8.91k|        }
  228|       |
  229|  9.98k|        depth++;
  230|       |        // In every iteration we multiply randv by 2. As a result, the set
  231|       |        // of randv values forms a GF(2)-linearly independent basis of splits.
  232|  9.98k|        randv = field.Mul2(randv);
  233|  9.98k|        tmp = poly;
  234|  9.98k|        GCD(trace, tmp, field);
  235|  9.98k|        if (trace.size() != poly.size() && trace.size() > 1) break;
  ------------------
  |  Branch (235:13): [True: 7.35k, False: 2.62k]
  |  Branch (235:44): [True: 5.47k, False: 1.87k]
  ------------------
  236|  9.98k|    }
  237|  5.47k|    MakeMonic(trace, field);
  238|  5.47k|    DivMod(trace, poly, tmp, field);
  239|       |    // At this point, the stack looks like [... (poly) tmp trace], and we want to recursively
  240|       |    // find roots of trace and tmp (= poly/trace). As we don't care about poly anymore, move
  241|       |    // trace into its position first.
  242|  5.47k|    std::swap(poly, trace);
  243|       |    // Now the stack is [... (trace) tmp ...]. First we factor tmp (at pos = pos+1), and then
  244|       |    // we factor trace (at pos = pos).
  245|  5.47k|    if (!RecFindRoots(stack, pos + 1, roots, fully_factorizable, depth, randv, field)) return false;
  ------------------
  |  Branch (245:9): [True: 0, False: 5.47k]
  ------------------
  246|       |    // The stack position pos contains trace, the polynomial with all of poly's roots which (after
  247|       |    // multiplication with randv) have trace 0. This is never the case for irreducible factors
  248|       |    // (which always end up in tmp), so we can set fully_factorizable to true when recursing.
  249|  5.47k|    bool ret = RecFindRoots(stack, pos, roots, true, depth, randv, field);
  250|       |    // Because of the above, recursion can never fail here.
  251|  5.47k|    CHECK_SAFE(ret);
  252|  5.47k|    return ret;
  253|  5.47k|}
clmul_4bytes.cpp:_Z8TraceModIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRKNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERSD_RKSA_RKS3_:
  103|  9.98k|void TraceMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& out, const typename F::Elem& param, const F& field) {
  104|  9.98k|    out.reserve(mod.size() * 2);
  105|  9.98k|    out.resize(2);
  106|  9.98k|    out[0] = 0;
  107|  9.98k|    out[1] = param;
  108|       |
  109|   319k|    for (int i = 0; i < field.Bits() - 1; ++i) {
  ------------------
  |  Branch (109:21): [True: 309k, False: 9.98k]
  ------------------
  110|   309k|        Sqr(out, field);
  111|   309k|        if (out.size() < 2) out.resize(2);
  ------------------
  |  Branch (111:13): [True: 1, False: 309k]
  ------------------
  112|   309k|        out[1] = param;
  113|   309k|        PolyMod(mod, out, field);
  114|   309k|    }
  115|  9.98k|}
clmul_4bytes.cpp:_Z3SqrIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERKS3_:
   92|   309k|void Sqr(std::vector<typename F::Elem>& poly, const F& field) {
   93|   309k|    if (poly.size() == 0) return;
  ------------------
  |  Branch (93:9): [True: 63, False: 309k]
  ------------------
   94|   309k|    poly.resize(poly.size() * 2 - 1);
   95|  4.02M|    for (size_t i = 0; i < poly.size(); ++i) {
  ------------------
  |  Branch (95:24): [True: 3.71M, False: 309k]
  ------------------
   96|  3.71M|        auto x = poly.size() - i - 1;
   97|  3.71M|        poly[x] = (x & 1) ? 0 : field.Sqr(poly[x / 2]);
  ------------------
  |  Branch (97:19): [True: 1.70M, False: 2.01M]
  ------------------
   98|  3.71M|    }
   99|   309k|}
clmul_4bytes.cpp:_Z7PolyModIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRKNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERSD_RKS3_:
   18|   327k|void PolyMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& val, const F& field) {
   19|   327k|    size_t modsize = mod.size();
   20|   327k|    CHECK_SAFE(modsize > 0 && mod.back() == 1);
   21|   327k|    if (val.size() < modsize) return;
  ------------------
  |  Branch (21:9): [True: 16.3k, False: 311k]
  ------------------
   22|   311k|    CHECK_SAFE(val.back() != 0);
   23|  1.96M|    while (val.size() >= modsize) {
  ------------------
  |  Branch (23:12): [True: 1.65M, False: 311k]
  ------------------
   24|  1.65M|        auto term = val.back();
   25|  1.65M|        val.pop_back();
   26|  1.65M|        if (term != 0) {
  ------------------
  |  Branch (26:13): [True: 1.65M, False: 3.72k]
  ------------------
   27|  1.65M|            typename F::Multiplier mul(field, term);
   28|  51.3M|            for (size_t x = 0; x < mod.size() - 1; ++x) {
  ------------------
  |  Branch (28:32): [True: 49.7M, False: 1.65M]
  ------------------
   29|  49.7M|                val[val.size() - modsize + 1 + x] ^= mul(mod[x]);
   30|  49.7M|            }
   31|  1.65M|        }
   32|  1.65M|    }
   33|   401k|    while (val.size() > 0 && val.back() == 0) val.pop_back();
  ------------------
  |  Branch (33:12): [True: 393k, False: 8.21k]
  |  Branch (33:30): [True: 90.4k, False: 303k]
  ------------------
   34|   311k|}
clmul_4bytes.cpp:_Z3GCDIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEESE_RKS3_:
   76|  9.98k|void GCD(std::vector<typename F::Elem>& a, std::vector<typename F::Elem>& b, const F& field) {
   77|  9.98k|    if (a.size() < b.size()) std::swap(a, b);
  ------------------
  |  Branch (77:9): [True: 9.98k, False: 0]
  ------------------
   78|  28.1k|    while (b.size() > 0) {
  ------------------
  |  Branch (78:12): [True: 20.0k, False: 8.10k]
  ------------------
   79|  20.0k|        if (b.size() == 1) {
  ------------------
  |  Branch (79:13): [True: 1.87k, False: 18.1k]
  ------------------
   80|  1.87k|            a.resize(1);
   81|  1.87k|            a[0] = 1;
   82|  1.87k|            return;
   83|  1.87k|        }
   84|  18.1k|        MakeMonic(b, field);
   85|  18.1k|        PolyMod(b, a, field);
   86|  18.1k|        std::swap(a, b);
   87|  18.1k|    }
   88|  9.98k|}
clmul_4bytes.cpp:_Z9MakeMonicIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEENS3_4ElemERNSt3__16vectorIS8_NS9_9allocatorIS8_EEEERKS3_:
   62|  23.6k|typename F::Elem MakeMonic(std::vector<typename F::Elem>& a, const F& field) {
   63|  23.6k|    CHECK_SAFE(a.back() != 0);
   64|  23.6k|    if (a.back() == 1) return 0;
  ------------------
  |  Branch (64:9): [True: 5.48k, False: 18.1k]
  ------------------
   65|  18.1k|    auto inv = field.Inv(a.back());
   66|  18.1k|    typename F::Multiplier mul(field, inv);
   67|  18.1k|    a.back() = 1;
   68|   397k|    for (size_t i = 0; i < a.size() - 1; ++i) {
  ------------------
  |  Branch (68:24): [True: 379k, False: 18.1k]
  ------------------
   69|   379k|        a[i] = mul(a[i]);
   70|   379k|    }
   71|  18.1k|    return inv;
   72|  23.6k|}
clmul_4bytes.cpp:_Z6DivModIN12_GLOBAL__N_18GenFieldIjLi32ELj141EXadL_ZNS0_18MulWithClMulReduceIjLi32ETnT_Lj141EEES3_S3_S3_EE11RecLinTransIjJLi6ELi6ELi5ELi5ELi5ELi5EEEXadL_ZNS0_12SQR_TABLE_32EEEXadL_ZNS0_13SQR2_TABLE_32EEEXadL_ZNS0_13SQR4_TABLE_32EEEXadL_ZNS0_13SQR8_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEEXadL_ZNS0_12QRT_TABLE_32EEE7IdTransXadL_ZL8ID_TRANSEEXadL_ZL8ID_TRANSEEEEEvRKNSt3__16vectorINS3_4ElemENS8_9allocatorISA_EEEERSD_SG_RKS3_:
   38|  5.47k|void DivMod(const std::vector<typename F::Elem>& mod, std::vector<typename F::Elem>& val, std::vector<typename F::Elem>& div, const F& field) {
   39|  5.47k|    size_t modsize = mod.size();
   40|  5.47k|    CHECK_SAFE(mod.size() > 0 && mod.back() == 1);
   41|  5.47k|    if (val.size() < mod.size()) {
  ------------------
  |  Branch (41:9): [True: 0, False: 5.47k]
  ------------------
   42|      0|        div.clear();
   43|      0|        return;
   44|      0|    }
   45|  5.47k|    CHECK_SAFE(val.back() != 0);
   46|  5.47k|    div.resize(val.size() - mod.size() + 1);
   47|  38.0k|    while (val.size() >= modsize) {
  ------------------
  |  Branch (47:12): [True: 32.5k, False: 5.47k]
  ------------------
   48|  32.5k|        auto term = val.back();
   49|  32.5k|        div[val.size() - modsize] = term;
   50|  32.5k|        val.pop_back();
   51|  32.5k|        if (term != 0) {
  ------------------
  |  Branch (51:13): [True: 32.0k, False: 554]
  ------------------
   52|  32.0k|            typename F::Multiplier mul(field, term);
   53|   361k|            for (size_t x = 0; x < mod.size() - 1; ++x) {
  ------------------
  |  Branch (53:32): [True: 329k, False: 32.0k]
  ------------------
   54|   329k|                val[val.size() - modsize + 1 + x] ^= mul(mod[x]);
   55|   329k|            }
   56|  32.0k|        }
   57|  32.5k|    }
   58|  5.47k|}

_ZN18FuzzedDataProviderC2EPKhm:
   37|  2.00k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|  8.00k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  8.00k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  8.00k|                                std::numeric_limits<T>::max());
  198|  8.00k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|   105k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   105k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   105k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   105k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 105k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   105k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   105k|  uint64_t result = 0;
  215|   105k|  size_t offset = 0;
  216|       |
  217|   234k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 230k, False: 4.15k]
  |  Branch (217:43): [True: 135k, False: 94.7k]
  ------------------
  218|   234k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 128k, False: 6.80k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|   128k|    --remaining_bytes_;
  226|   128k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   128k|    offset += CHAR_BIT;
  228|   128k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   105k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 97.7k, False: 8.00k]
  ------------------
  232|  97.7k|    result = result % (range + 1);
  233|       |
  234|   105k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   105k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  95.7k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  95.7k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  95.7k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  95.7k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 95.7k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  95.7k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  95.7k|  uint64_t result = 0;
  215|  95.7k|  size_t offset = 0;
  216|       |
  217|   470k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 377k, False: 92.9k]
  |  Branch (217:43): [True: 375k, False: 1.98k]
  ------------------
  218|   470k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 374k, False: 872]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|   374k|    --remaining_bytes_;
  226|   374k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   374k|    offset += CHAR_BIT;
  228|   374k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  95.7k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 95.7k, False: 0]
  ------------------
  232|  95.7k|    result = result % (range + 1);
  233|       |
  234|  95.7k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  95.7k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  99.7k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  99.7k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  99.7k|                                std::numeric_limits<T>::max());
  198|  99.7k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  99.7k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  99.7k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  99.7k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  99.7k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 99.7k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  99.7k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  99.7k|  uint64_t result = 0;
  215|  99.7k|  size_t offset = 0;
  216|       |
  217|   194k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 99.7k, False: 94.5k]
  |  Branch (217:43): [True: 99.7k, False: 0]
  ------------------
  218|   194k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 94.5k, False: 5.17k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  94.5k|    --remaining_bytes_;
  226|  94.5k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  94.5k|    offset += CHAR_BIT;
  228|  94.5k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  99.7k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 99.7k, False: 0]
  ------------------
  232|  99.7k|    result = result % (range + 1);
  233|       |
  234|  99.7k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  99.7k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  99.7k|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  99.7k|  return 1 & ConsumeIntegral<uint8_t>();
  291|  99.7k|}

LLVMFuzzerTestOneInput:
  222|  2.00k|{
  223|  2.00k|    test_one_input({data, size});
  224|  2.00k|    return 0;
  225|  2.00k|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   83|  2.00k|{
   84|  2.00k|    CheckGlobals check{};
   85|  2.00k|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |   85|  2.00k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   86|  2.00k|}

_Z22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   25|  2.00k|{
   26|  2.00k|    FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
   27|       |
   28|  2.00k|    const auto capacity{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 200)};
   29|  2.00k|    const uint32_t impl{fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, Minisketch::MaxImplementation())};
   30|  2.00k|    if (!Minisketch::ImplementationSupported(32, impl)) return;
  ------------------
  |  Branch (30:9): [True: 2, False: 2.00k]
  ------------------
   31|       |
   32|  2.00k|    Minisketch sketch_a{MakeFuzzMinisketch32(capacity, impl)};
   33|  2.00k|    Minisketch sketch_b{MakeFuzzMinisketch32(capacity, impl)};
   34|  2.00k|    sketch_a.SetSeed(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   35|  2.00k|    sketch_b.SetSeed(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   36|       |
   37|       |    // Fill two sets and keep the difference in a map
   38|  2.00k|    std::map<uint32_t, bool> diff;
   39|  2.00k|    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000)
  ------------------
  |  |   23|  95.7k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 93.7k, False: 1.99k]
  |  |  |  Branch (23:49): [True: 93.7k, False: 3]
  |  |  ------------------
  ------------------
   40|  93.7k|    {
   41|  93.7k|        const auto entry{fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(1, std::numeric_limits<uint32_t>::max() - 1)};
   42|  93.7k|        const auto KeepDiff{[&] {
   43|  93.7k|            bool& mut{diff[entry]};
   44|  93.7k|            mut = !mut;
   45|  93.7k|        }};
   46|  93.7k|        CallOneOf(
   47|  93.7k|            fuzzed_data_provider,
   48|  93.7k|            [&] {
   49|  93.7k|                sketch_a.Add(entry);
   50|  93.7k|                KeepDiff();
   51|  93.7k|            },
   52|  93.7k|            [&] {
   53|  93.7k|                sketch_b.Add(entry);
   54|  93.7k|                KeepDiff();
   55|  93.7k|            },
   56|  93.7k|            [&] {
   57|  93.7k|                sketch_a.Add(entry);
   58|  93.7k|                sketch_b.Add(entry);
   59|  93.7k|            });
   60|  93.7k|    }
   61|  2.00k|    const auto num_diff{std::accumulate(diff.begin(), diff.end(), size_t{0}, [](auto n, const auto& e) { return n + e.second; })};
   62|       |
   63|  2.00k|    Minisketch sketch_ar{MakeFuzzMinisketch32(capacity, impl)};
   64|  2.00k|    Minisketch sketch_br{MakeFuzzMinisketch32(capacity, impl)};
   65|  2.00k|    sketch_ar.SetSeed(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   66|  2.00k|    sketch_br.SetSeed(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   67|       |
   68|  2.00k|    sketch_ar.Deserialize(sketch_a.Serialize());
   69|  2.00k|    sketch_br.Deserialize(sketch_b.Serialize());
   70|       |
   71|  2.00k|    Minisketch sketch_diff{std::move(fuzzed_data_provider.ConsumeBool() ? sketch_a : sketch_ar)};
  ------------------
  |  Branch (71:38): [True: 183, False: 1.81k]
  ------------------
   72|  2.00k|    sketch_diff.Merge(fuzzed_data_provider.ConsumeBool() ? sketch_b : sketch_br);
  ------------------
  |  Branch (72:23): [True: 103, False: 1.89k]
  ------------------
   73|       |
   74|  2.00k|    if (capacity >= num_diff) {
  ------------------
  |  Branch (74:9): [True: 1.96k, False: 35]
  ------------------
   75|  1.96k|        const auto max_elements{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(num_diff, capacity)};
   76|  1.96k|        const auto dec{*Assert(sketch_diff.Decode(max_elements))};
  ------------------
  |  |   85|  1.96k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   77|  1.96k|        Assert(dec.size() == num_diff);
  ------------------
  |  |   85|  1.96k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   78|  21.3k|        for (auto d : dec) {
  ------------------
  |  Branch (78:21): [True: 21.3k, False: 1.96k]
  ------------------
   79|  21.3k|            Assert(diff.at(d));
  ------------------
  |  |   85|  21.3k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   80|  21.3k|        }
   81|  1.96k|    }
   82|  2.00k|}
minisketch.cpp:_ZN12_GLOBAL__N_120MakeFuzzMinisketch32Emj:
   18|  8.00k|{
   19|  8.00k|    return Assert(Minisketch(32, impl, capacity));
  ------------------
  |  |   85|  8.00k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   20|  8.00k|}
minisketch.cpp:_ZZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clImNS_4pairIKjbEEEEDaT_RKT0_:
   61|  28.0k|    const auto num_diff{std::accumulate(diff.begin(), diff.end(), size_t{0}, [](auto n, const auto& e) { return n + e.second; })};
minisketch.cpp:_ZZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
   48|  33.3k|            [&] {
   49|  33.3k|                sketch_a.Add(entry);
   50|  33.3k|                KeepDiff();
   51|  33.3k|            },
minisketch.cpp:_ZZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
   42|  92.5k|        const auto KeepDiff{[&] {
   43|  92.5k|            bool& mut{diff[entry]};
   44|  92.5k|            mut = !mut;
   45|  92.5k|        }};
minisketch.cpp:_ZZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
   52|  59.1k|            [&] {
   53|  59.1k|                sketch_b.Add(entry);
   54|  59.1k|                KeepDiff();
   55|  59.1k|            },
minisketch.cpp:_ZZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
   56|  1.24k|            [&] {
   57|  1.24k|                sketch_a.Add(entry);
   58|  1.24k|                sketch_b.Add(entry);
   59|  1.24k|            });

minisketch.cpp:_Z9CallOneOfIJZ22minisketch_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_2Z22minisketch_fuzz_targetS3_E3$_3Z22minisketch_fuzz_targetS3_E3$_4EEmR18FuzzedDataProviderDpT_:
   36|  93.7k|{
   37|  93.7k|    constexpr size_t call_size{sizeof...(callables)};
   38|  93.7k|    static_assert(call_size >= 1);
   39|  93.7k|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|  93.7k|    size_t i{0};
   42|   281k|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 33.3k, False: 60.3k]
  |  Branch (42:7): [True: 59.1k, False: 34.6k]
  |  Branch (42:7): [True: 1.24k, False: 92.5k]
  ------------------
   43|  93.7k|    return call_size;
   44|  93.7k|}

_ZN12CheckGlobalsC2Ev:
   56|  2.00k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|  2.00k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  2.00k|    {
   18|  2.00k|        g_used_g_prng = false;
   19|  2.00k|        g_seeded_g_prng_zero = false;
   20|  2.00k|        g_used_system_time = false;
   21|  2.00k|        SetMockTime(0s);
   22|  2.00k|    }
_ZN16CheckGlobalsImplD2Ev:
   24|  2.00k|    {
   25|  2.00k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 0, False: 2.00k]
  |  Branch (25:30): [True: 0, False: 0]
  ------------------
   26|      0|            std::cerr << "\n\n"
   27|      0|                         "The current fuzz target used the global random state.\n\n"
   28|       |
   29|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   30|      0|                         "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n"
   31|      0|                         "of the FUZZ_TARGET function.\n\n"
   32|       |
   33|      0|                         "An alternative solution would be to avoid any use of globals.\n\n"
   34|       |
   35|      0|                         "Without a solution, fuzz instability and non-determinism can lead \n"
   36|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   37|      0|                      << std::endl;
   38|      0|            std::abort(); // Abort, because AFL may try to recover from a std::exit
   39|      0|        }
   40|       |
   41|  2.00k|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 2.00k]
  ------------------
   42|      0|            std::cerr << "\n\n"
   43|      0|                         "The current fuzz target accessed system time.\n\n"
   44|       |
   45|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   46|      0|                         "SetMockTime() at the beginning of processing the fuzz input.\n\n"
   47|       |
   48|      0|                         "Without setting mock time, time-dependent behavior can lead \n"
   49|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   50|      0|                      << std::endl;
   51|      0|            std::abort();
   52|      0|        }
   53|  2.00k|    }

_Z22inline_assertion_checkILb1E10MinisketchEOT0_S2_PKciS4_S4_:
   52|  8.00k|{
   53|  8.00k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  8.00k|    ) {
   58|  8.00k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 8.00k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  8.00k|    }
   62|  8.00k|    return std::forward<T>(val);
   63|  8.00k|}
_Z22inline_assertion_checkILb1ENSt3__18optionalINS0_6vectorImNS0_9allocatorImEEEEEEEOT0_S8_PKciSA_SA_:
   52|  1.96k|{
   53|  1.96k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  1.96k|    ) {
   58|  1.96k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.96k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.96k|    }
   62|  1.96k|    return std::forward<T>(val);
   63|  1.96k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  3.96k|{
   53|  3.96k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  3.96k|    ) {
   58|  3.96k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 3.96k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  3.96k|    }
   62|  3.96k|    return std::forward<T>(val);
   63|  3.96k|}
_Z22inline_assertion_checkILb1ERbEOT0_S2_PKciS4_S4_:
   52|  21.3k|{
   53|  21.3k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  21.3k|    ) {
   58|  21.3k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 21.3k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  21.3k|    }
   62|  21.3k|    return std::forward<T>(val);
   63|  21.3k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  2.00k|{
   53|  2.00k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  2.00k|    ) {
   58|  2.00k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 2.00k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  2.00k|    }
   62|  2.00k|    return std::forward<T>(val);
   63|  2.00k|}

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  2.00k|{
   43|  2.00k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  2.00k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  2.00k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  2.00k|}