_ZNK9base_uintILj256EE9getdoubleEv:
  129|  1.72k|{
  130|  1.72k|    double ret = 0.0;
  131|  1.72k|    double fact = 1.0;
  132|  15.4k|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (132:21): [True: 13.7k, False: 1.72k]
  ------------------
  133|  13.7k|        ret += fact * pn[i];
  134|  13.7k|        fact *= 4294967296.0;
  135|  13.7k|    }
  136|  1.72k|    return ret;
  137|  1.72k|}
_ZN9base_uintILj256EElSEj:
   15|    368|{
   16|    368|    base_uint<BITS> a(*this);
   17|  3.31k|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (17:21): [True: 2.94k, False: 368]
  ------------------
   18|  2.94k|        pn[i] = 0;
   19|    368|    int k = shift / 32;
   20|    368|    shift = shift % 32;
   21|  3.31k|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (21:21): [True: 2.94k, False: 368]
  ------------------
   22|  2.94k|        if (i + k + 1 < WIDTH && shift != 0)
  ------------------
  |  Branch (22:13): [True: 388, False: 2.55k]
  |  Branch (22:34): [True: 261, False: 127]
  ------------------
   23|    261|            pn[i + k + 1] |= (a.pn[i] >> (32 - shift));
   24|  2.94k|        if (i + k < WIDTH)
  ------------------
  |  Branch (24:13): [True: 583, False: 2.36k]
  ------------------
   25|    583|            pn[i + k] |= (a.pn[i] << shift);
   26|  2.94k|    }
   27|    368|    return *this;
   28|    368|}
_ZN9base_uintILj256EErSEj:
   32|  3.41k|{
   33|  3.41k|    base_uint<BITS> a(*this);
   34|  30.7k|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (34:21): [True: 27.2k, False: 3.41k]
  ------------------
   35|  27.2k|        pn[i] = 0;
   36|  3.41k|    int k = shift / 32;
   37|  3.41k|    shift = shift % 32;
   38|  30.7k|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (38:21): [True: 27.2k, False: 3.41k]
  ------------------
   39|  27.2k|        if (i - k - 1 >= 0 && shift != 0)
  ------------------
  |  Branch (39:13): [True: 1.31k, False: 25.9k]
  |  Branch (39:31): [True: 1.09k, False: 216]
  ------------------
   40|  1.09k|            pn[i - k - 1] |= (a.pn[i] << (32 - shift));
   41|  27.2k|        if (i - k >= 0)
  ------------------
  |  Branch (41:13): [True: 4.72k, False: 22.5k]
  ------------------
   42|  4.72k|            pn[i - k] |= (a.pn[i] >> shift);
   43|  27.2k|    }
   44|  3.41k|    return *this;
   45|  3.41k|}
_ZNK9base_uintILj256EE9CompareToERKS0_:
  103|    247|{
  104|    322|    for (int i = WIDTH - 1; i >= 0; i--) {
  ------------------
  |  Branch (104:29): [True: 320, False: 2]
  ------------------
  105|    320|        if (pn[i] < b.pn[i])
  ------------------
  |  Branch (105:13): [True: 128, False: 192]
  ------------------
  106|    128|            return -1;
  107|    192|        if (pn[i] > b.pn[i])
  ------------------
  |  Branch (107:13): [True: 117, False: 75]
  ------------------
  108|    117|            return 1;
  109|    192|    }
  110|      2|    return 0;
  111|    247|}
_ZNK9base_uintILj256EE7EqualToEm:
  115|  1.51k|{
  116|  10.2k|    for (int i = WIDTH - 1; i >= 2; i--) {
  ------------------
  |  Branch (116:29): [True: 8.82k, False: 1.43k]
  ------------------
  117|  8.82k|        if (pn[i])
  ------------------
  |  Branch (117:13): [True: 81, False: 8.74k]
  ------------------
  118|     81|            return false;
  119|  8.82k|    }
  120|  1.43k|    if (pn[1] != (b >> 32))
  ------------------
  |  Branch (120:9): [True: 27, False: 1.40k]
  ------------------
  121|     27|        return false;
  122|  1.40k|    if (pn[0] != (b & 0xfffffffful))
  ------------------
  |  Branch (122:9): [True: 27, False: 1.38k]
  ------------------
  123|     27|        return false;
  124|  1.38k|    return true;
  125|  1.40k|}
_ZNK9base_uintILj256EE6GetHexEv:
  141|  5.16k|{
  142|  5.16k|    base_blob<BITS> b;
  143|  46.4k|    for (int x = 0; x < this->WIDTH; ++x) {
  ------------------
  |  Branch (143:21): [True: 41.3k, False: 5.16k]
  ------------------
  144|  41.3k|        WriteLE32(b.begin() + x*4, this->pn[x]);
  145|  41.3k|    }
  146|  5.16k|    return b.GetHex();
  147|  5.16k|}
_ZNK9base_uintILj256EE8ToStringEv:
  151|  1.72k|{
  152|  1.72k|    return GetHex();
  153|  1.72k|}
_ZNK9base_uintILj256EE4bitsEv:
  157|  5.16k|{
  158|  6.77k|    for (int pos = WIDTH - 1; pos >= 0; pos--) {
  ------------------
  |  Branch (158:31): [True: 6.75k, False: 24]
  ------------------
  159|  6.75k|        if (pn[pos]) {
  ------------------
  |  Branch (159:13): [True: 5.14k, False: 1.60k]
  ------------------
  160|  32.2k|            for (int nbits = 31; nbits > 0; nbits--) {
  ------------------
  |  Branch (160:34): [True: 32.1k, False: 54]
  ------------------
  161|  32.1k|                if (pn[pos] & 1U << nbits)
  ------------------
  |  Branch (161:21): [True: 5.08k, False: 27.0k]
  ------------------
  162|  5.08k|                    return 32 * pos + nbits + 1;
  163|  32.1k|            }
  164|     54|            return 32 * pos + 1;
  165|  5.14k|        }
  166|  6.75k|    }
  167|     24|    return 0;
  168|  5.16k|}
_ZN13arith_uint25610SetCompactEjPbS0_:
  176|  1.72k|{
  177|  1.72k|    int nSize = nCompact >> 24;
  178|  1.72k|    uint32_t nWord = nCompact & 0x007fffff;
  179|  1.72k|    if (nSize <= 3) {
  ------------------
  |  Branch (179:9): [True: 1.35k, False: 368]
  ------------------
  180|  1.35k|        nWord >>= 8 * (3 - nSize);
  181|  1.35k|        *this = nWord;
  182|  1.35k|    } else {
  183|    368|        *this = nWord;
  184|    368|        *this <<= 8 * (nSize - 3);
  185|    368|    }
  186|  1.72k|    if (pfNegative)
  ------------------
  |  Branch (186:9): [True: 1.72k, False: 0]
  ------------------
  187|  1.72k|        *pfNegative = nWord != 0 && (nCompact & 0x00800000) != 0;
  ------------------
  |  Branch (187:23): [True: 407, False: 1.31k]
  |  Branch (187:37): [True: 207, False: 200]
  ------------------
  188|  1.72k|    if (pfOverflow)
  ------------------
  |  Branch (188:9): [True: 1.72k, False: 0]
  ------------------
  189|  1.72k|        *pfOverflow = nWord != 0 && ((nSize > 34) ||
  ------------------
  |  Branch (189:23): [True: 407, False: 1.31k]
  |  Branch (189:38): [True: 165, False: 242]
  ------------------
  190|    407|                                     (nWord > 0xff && nSize > 33) ||
  ------------------
  |  Branch (190:39): [True: 221, False: 21]
  |  Branch (190:55): [True: 25, False: 196]
  ------------------
  191|    407|                                     (nWord > 0xffff && nSize > 32));
  ------------------
  |  Branch (191:39): [True: 158, False: 59]
  |  Branch (191:57): [True: 30, False: 128]
  ------------------
  192|  1.72k|    return *this;
  193|  1.72k|}
_ZNK13arith_uint25610GetCompactEb:
  196|  3.44k|{
  197|  3.44k|    int nSize = (bits() + 7) / 8;
  198|  3.44k|    uint32_t nCompact = 0;
  199|  3.44k|    if (nSize <= 3) {
  ------------------
  |  Branch (199:9): [True: 32, False: 3.41k]
  ------------------
  200|     32|        nCompact = GetLow64() << 8 * (3 - nSize);
  201|  3.41k|    } else {
  202|  3.41k|        arith_uint256 bn = *this >> 8 * (nSize - 3);
  203|  3.41k|        nCompact = bn.GetLow64();
  204|  3.41k|    }
  205|       |    // The 0x00800000 bit denotes the sign.
  206|       |    // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
  207|  3.44k|    if (nCompact & 0x00800000) {
  ------------------
  |  Branch (207:9): [True: 1.74k, False: 1.70k]
  ------------------
  208|  1.74k|        nCompact >>= 8;
  209|  1.74k|        nSize++;
  210|  1.74k|    }
  211|  3.44k|    assert((nCompact & ~0x007fffffU) == 0);
  212|  3.44k|    assert(nSize < 256);
  213|  3.44k|    nCompact |= nSize << 24;
  214|  3.44k|    nCompact |= (fNegative && (nCompact & 0x007fffff) ? 0x00800000 : 0);
  ------------------
  |  Branch (214:18): [True: 1.72k, False: 1.72k]
  |  Branch (214:31): [True: 1.71k, False: 8]
  ------------------
  215|  3.44k|    return nCompact;
  216|  3.44k|}
_Z14ArithToUint256RK13arith_uint256:
  219|  1.72k|{
  220|  1.72k|    uint256 b;
  221|  15.4k|    for(int x=0; x<a.WIDTH; ++x)
  ------------------
  |  Branch (221:18): [True: 13.7k, False: 1.72k]
  ------------------
  222|  13.7k|        WriteLE32(b.begin() + x*4, a.pn[x]);
  223|  1.72k|    return b;
  224|  1.72k|}
_Z14UintToArith256RK7uint256:
  226|  1.96k|{
  227|  1.96k|    arith_uint256 b;
  228|  17.7k|    for(int x=0; x<b.WIDTH; ++x)
  ------------------
  |  Branch (228:18): [True: 15.7k, False: 1.96k]
  ------------------
  229|  15.7k|        b.pn[x] = ReadLE32(a.begin() + x*4);
  230|  1.96k|    return b;
  231|  1.96k|}

_ZN13arith_uint256C2ERK9base_uintILj256EE:
  249|  3.41k|    arith_uint256(const base_uint<256>& b) : base_uint<256>(b) {}
_ZN13arith_uint256C2Em:
  250|  1.72k|    arith_uint256(uint64_t b) : base_uint<256>(b) {}
_ZN9base_uintILj256EEaSERKS0_:
   46|  1.72k|    {
   47|  1.72k|        if (this != &b) {
  ------------------
  |  Branch (47:13): [True: 1.72k, False: 0]
  ------------------
   48|  15.4k|            for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (48:29): [True: 13.7k, False: 1.72k]
  ------------------
   49|  13.7k|                pn[i] = b.pn[i];
   50|  1.72k|        }
   51|  1.72k|        return *this;
   52|  1.72k|    }
_ZN13arith_uint256C2Ev:
  248|  3.69k|    arith_uint256() = default;
_ZN9base_uintILj256EEC2Ev:
   34|  3.69k|    {
   35|  33.2k|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (35:25): [True: 29.5k, False: 3.69k]
  ------------------
   36|  29.5k|            pn[i] = 0;
   37|  3.69k|    }
_ZN9base_uintILj256EEC2ERKS0_:
   40|  14.1k|    {
   41|   127k|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (41:25): [True: 113k, False: 14.1k]
  ------------------
   42|   113k|            pn[i] = b.pn[i];
   43|  14.1k|    }
_ZNK9base_uintILj256EE8GetLow64Ev:
  239|  5.16k|    {
  240|  5.16k|        static_assert(WIDTH >= 2, "Assertion WIDTH >= 2 failed (WIDTH = BITS / 32). BITS is a template parameter.");
  241|  5.16k|        return pn[0] | (uint64_t)pn[1] << 32;
  242|  5.16k|    }
_ZNK9base_uintILj256EE4sizeEv:
  228|  1.72k|    {
  229|  1.72k|        return sizeof(pn);
  230|  1.72k|    }
_ZN9base_uintILj256EEC2Em:
   55|  1.72k|    {
   56|  1.72k|        pn[0] = (unsigned int)b;
   57|  1.72k|        pn[1] = (unsigned int)(b >> 32);
   58|  12.0k|        for (int i = 2; i < WIDTH; i++)
  ------------------
  |  Branch (58:25): [True: 10.3k, False: 1.72k]
  ------------------
   59|  10.3k|            pn[i] = 0;
   60|  1.72k|    }
_ZgtRK9base_uintILj256EES2_:
  216|    247|    friend inline bool operator>(const base_uint& a, const base_uint& b) { return a.CompareTo(b) > 0; }
_ZeqRK9base_uintILj256EEm:
  220|  1.51k|    friend inline bool operator==(const base_uint& a, uint64_t b) { return a.EqualTo(b); }
_ZrsRK9base_uintILj256EEi:
  211|  3.41k|    friend inline base_uint operator>>(const base_uint& a, int shift) { return base_uint(a) >>= shift; }

_Z6Paramsv:
  105|  1.72k|const CChainParams &Params() {
  106|  1.72k|    assert(globalChainParams);
  107|  1.72k|    return *globalChainParams;
  108|  1.72k|}

_Z17FormatFullVersionv:
   57|  1.64k|{
   58|  1.64k|    static const std::string CLIENT_BUILD(BUILD_DESC BUILD_SUFFIX);
  ------------------
  |  |   39|  1.64k|    #define BUILD_DESC "v" CLIENT_VERSION_STRING
  ------------------
                  static const std::string CLIENT_BUILD(BUILD_DESC BUILD_SUFFIX);
  ------------------
  |  |   43|  1.64k|        #define BUILD_SUFFIX "-" BUILD_GIT_COMMIT
  |  |  ------------------
  |  |  |  |    1|  1.64k|#define BUILD_GIT_COMMIT "43e71f74988b-dirty"
  |  |  ------------------
  ------------------
   59|  1.64k|    return CLIENT_BUILD;
   60|  1.64k|}

_Z12IsSwitchCharc:
   44|  1.72k|{
   45|       |#ifdef WIN32
   46|       |    return c == '-' || c == '/';
   47|       |#else
   48|  1.72k|    return c == '-';
   49|  1.72k|#endif
   50|  1.72k|}

_Z17internal_bswap_16t:
   45|  3.44k|{
   46|  3.44k|#ifdef bitcoin_builtin_bswap16
   47|  3.44k|    return bitcoin_builtin_bswap16(x);
  ------------------
  |  |   21|  3.44k|#      define bitcoin_builtin_bswap16(x) __builtin_bswap16(x)
  ------------------
   48|       |#else
   49|       |    return (x >> 8) | (x << 8);
   50|       |#endif
   51|  3.44k|}
_Z17internal_bswap_32j:
   54|   127k|{
   55|   127k|#ifdef bitcoin_builtin_bswap32
   56|   127k|    return bitcoin_builtin_bswap32(x);
  ------------------
  |  |   24|   127k|#      define bitcoin_builtin_bswap32(x) __builtin_bswap32(x)
  ------------------
   57|       |#else
   58|       |    return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >>  8) |
   59|       |            ((x & 0x0000ff00U) <<  8) | ((x & 0x000000ffU) << 24));
   60|       |#endif
   61|   127k|}

_Z16htobe16_internalt:
   14|  1.72k|{
   15|  1.72k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(host_16bits);
   16|       |        else return host_16bits;
   17|  1.72k|}
_Z16htole16_internalt:
   19|  5.22k|{
   20|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
   21|  5.22k|        else return host_16bits;
   22|  5.22k|}
_Z16be16toh_internalt:
   24|  1.72k|{
   25|  1.72k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(big_endian_16bits);
   26|       |        else return big_endian_16bits;
   27|  1.72k|}
_Z16le16toh_internalt:
   29|  5.22k|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|  5.22k|        else return little_endian_16bits;
   32|  5.22k|}
_Z16htobe32_internalj:
   34|  43.0k|{
   35|  43.0k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|  43.0k|}
_Z16htole32_internalj:
   39|  60.4k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  60.4k|        else return host_32bits;
   42|  60.4k|}
_Z16be32toh_internalj:
   44|  84.3k|{
   45|  84.3k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
   46|       |        else return big_endian_32bits;
   47|  84.3k|}
_Z16le32toh_internalj:
   49|  21.0k|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|  21.0k|        else return little_endian_32bits;
   52|  21.0k|}
_Z16htole64_internalm:
   59|  6.56k|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  6.56k|        else return host_64bits;
   62|  6.56k|}
_Z16le64toh_internalm:
   69|  20.3k|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|  20.3k|        else return little_endian_64bits;
   72|  20.3k|}

_Z20GetSpecialScriptSizej:
   87|  1.72k|{
   88|  1.72k|    if (nSize == 0 || nSize == 1)
  ------------------
  |  Branch (88:9): [True: 983, False: 739]
  |  Branch (88:23): [True: 86, False: 653]
  ------------------
   89|  1.06k|        return 20;
   90|    653|    if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
  ------------------
  |  Branch (90:9): [True: 24, False: 629]
  |  Branch (90:23): [True: 5, False: 624]
  |  Branch (90:37): [True: 5, False: 619]
  |  Branch (90:51): [True: 4, False: 615]
  ------------------
   91|     38|        return 32;
   92|    615|    return 0;
   93|    653|}
_Z14CompressAmountm:
  150|  1.72k|{
  151|  1.72k|    if (n == 0)
  ------------------
  |  Branch (151:9): [True: 110, False: 1.61k]
  ------------------
  152|    110|        return 0;
  153|  1.61k|    int e = 0;
  154|  1.91k|    while (((n % 10) == 0) && e < 9) {
  ------------------
  |  Branch (154:12): [True: 298, False: 1.61k]
  |  Branch (154:31): [True: 297, False: 1]
  ------------------
  155|    297|        n /= 10;
  156|    297|        e++;
  157|    297|    }
  158|  1.61k|    if (e < 9) {
  ------------------
  |  Branch (158:9): [True: 1.61k, False: 3]
  ------------------
  159|  1.61k|        int d = (n % 10);
  160|  1.61k|        assert(d >= 1 && d <= 9);
  161|  1.61k|        n /= 10;
  162|  1.61k|        return 1 + (n*9 + d - 1)*10 + e;
  163|  1.61k|    } else {
  164|      3|        return 1 + (n - 1)*10 + 9;
  165|      3|    }
  166|  1.61k|}
_Z16DecompressAmountm:
  169|  2.24k|{
  170|       |    // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
  171|  2.24k|    if (x == 0)
  ------------------
  |  Branch (171:9): [True: 220, False: 2.02k]
  ------------------
  172|    220|        return 0;
  173|  2.02k|    x--;
  174|       |    // x = 10*(9*n + d - 1) + e
  175|  2.02k|    int e = x % 10;
  176|  2.02k|    x /= 10;
  177|  2.02k|    uint64_t n = 0;
  178|  2.02k|    if (e < 9) {
  ------------------
  |  Branch (178:9): [True: 1.83k, False: 198]
  ------------------
  179|       |        // x = 9*n + d - 1
  180|  1.83k|        int d = (x % 9) + 1;
  181|  1.83k|        x /= 9;
  182|       |        // x = n
  183|  1.83k|        n = x*10 + d;
  184|  1.83k|    } else {
  185|    198|        n = x+1;
  186|    198|    }
  187|  9.73k|    while (e) {
  ------------------
  |  Branch (187:12): [True: 7.70k, False: 2.02k]
  ------------------
  188|  7.70k|        n *= 10;
  189|  7.70k|        e--;
  190|  7.70k|    }
  191|  2.02k|    return n;
  192|  2.24k|}

_Z10MoneyRangeRKl:
   27|  2.21k|inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  ------------------
  |  Branch (27:57): [True: 1.03k, False: 1.17k]
  |  Branch (27:72): [True: 468, False: 568]
  ------------------

_Z17ComputeMerkleRootNSt3__16vectorI7uint256NS_9allocatorIS1_EEEEPb:
   46|  1.72k|uint256 ComputeMerkleRoot(std::vector<uint256> hashes, bool* mutated) {
   47|  1.72k|    bool mutation = false;
   48|  5.16k|    while (hashes.size() > 1) {
  ------------------
  |  Branch (48:12): [True: 3.44k, False: 1.72k]
  ------------------
   49|  3.44k|        if (mutated) {
  ------------------
  |  Branch (49:13): [True: 0, False: 3.44k]
  ------------------
   50|      0|            for (size_t pos = 0; pos + 1 < hashes.size(); pos += 2) {
  ------------------
  |  Branch (50:34): [True: 0, False: 0]
  ------------------
   51|      0|                if (hashes[pos] == hashes[pos + 1]) mutation = true;
  ------------------
  |  Branch (51:21): [True: 0, False: 0]
  ------------------
   52|      0|            }
   53|      0|        }
   54|  3.44k|        if (hashes.size() & 1) {
  ------------------
  |  Branch (54:13): [True: 1.72k, False: 1.72k]
  ------------------
   55|  1.72k|            hashes.push_back(hashes.back());
   56|  1.72k|        }
   57|  3.44k|        SHA256D64(hashes[0].begin(), hashes[0].begin(), hashes.size() / 2);
   58|  3.44k|        hashes.resize(hashes.size() / 2);
   59|  3.44k|    }
   60|  1.72k|    if (mutated) *mutated = mutation;
  ------------------
  |  Branch (60:9): [True: 0, False: 1.72k]
  ------------------
   61|  1.72k|    if (hashes.size() == 0) return uint256();
  ------------------
  |  Branch (61:9): [True: 0, False: 1.72k]
  ------------------
   62|  1.72k|    return hashes[0];
   63|  1.72k|}

_Z15ValueFromAmountl:
   27|  1.72k|{
   28|  1.72k|    static_assert(COIN > 1);
   29|  1.72k|    int64_t quotient = amount / COIN;
   30|  1.72k|    int64_t remainder = amount % COIN;
   31|  1.72k|    if (amount < 0) {
  ------------------
  |  Branch (31:9): [True: 1.17k, False: 546]
  ------------------
   32|  1.17k|        quotient = -quotient;
   33|  1.17k|        remainder = -remainder;
   34|  1.17k|    }
   35|  1.72k|    return UniValue(UniValue::VNUM,
   36|  1.72k|            strprintf("%s%d.%08d", amount < 0 ? "-" : "", quotient, remainder));
  ------------------
  |  | 1172|  1.72k|#define strprintf tfm::format
  ------------------
  |  Branch (36:36): [True: 1.17k, False: 546]
  ------------------
   37|  1.72k|}
_Z12SighashToStrh:
   85|  1.72k|{
   86|  1.72k|    const auto& it = mapSigHashTypes.find(sighash_type);
   87|  1.72k|    if (it == mapSigHashTypes.end()) return "";
  ------------------
  |  Branch (87:9): [True: 1.70k, False: 15]
  ------------------
   88|     15|    return it->second;
   89|  1.72k|}

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  13.7k|{
   37|  13.7k|    uint64_t x;
   38|  13.7k|    memcpy(&x, ptr, 8);
   39|  13.7k|    return le64toh_internal(x);
   40|  13.7k|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|  55.1k|{
   52|  55.1k|    uint32_t v = htole32_internal(x);
   53|  55.1k|    memcpy(ptr, &v, 4);
   54|  55.1k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|  15.7k|{
   29|  15.7k|    uint32_t x;
   30|  15.7k|    memcpy(&x, ptr, 4);
   31|  15.7k|    return le32toh_internal(x);
   32|  15.7k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  41.3k|{
   97|  41.3k|    uint32_t v = htobe32_internal(x);
   98|  41.3k|    memcpy(ptr, &v, 4);
   99|  41.3k|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  82.6k|{
   74|  82.6k|    uint32_t x;
   75|  82.6k|    memcpy(&x, ptr, 4);
   76|  82.6k|    return be32toh_internal(x);
   77|  82.6k|}

_Z6HexStr4SpanIKhE:
   30|  5.16k|{
   31|  5.16k|    std::string rv(s.size() * 2, '\0');
   32|  5.16k|    static constexpr auto byte_to_hex = CreateByteToHexMap();
   33|  5.16k|    static_assert(sizeof(byte_to_hex) == 512);
   34|       |
   35|  5.16k|    char* it = rv.data();
   36|   165k|    for (uint8_t v : s) {
  ------------------
  |  Branch (36:20): [True: 165k, False: 5.16k]
  ------------------
   37|   165k|        std::memcpy(it, byte_to_hex[v].data(), 2);
   38|   165k|        it += 2;
   39|   165k|    }
   40|       |
   41|  5.16k|    assert(it == rv.data() + rv.size());
   42|  5.16k|    return rv;
   43|  5.16k|}
_Z8HexDigitc:
   64|   332k|{
   65|   332k|    return p_util_hexdigit[(unsigned char)c];
   66|   332k|}

_Z9SHA256D64PhPKhm:
  752|  3.44k|{
  753|  3.44k|    if (TransformD64_8way) {
  ------------------
  |  Branch (753:9): [True: 0, False: 3.44k]
  ------------------
  754|      0|        while (blocks >= 8) {
  ------------------
  |  Branch (754:16): [True: 0, False: 0]
  ------------------
  755|      0|            TransformD64_8way(out, in);
  756|      0|            out += 256;
  757|      0|            in += 512;
  758|      0|            blocks -= 8;
  759|      0|        }
  760|      0|    }
  761|  3.44k|    if (TransformD64_4way) {
  ------------------
  |  Branch (761:9): [True: 0, False: 3.44k]
  ------------------
  762|      0|        while (blocks >= 4) {
  ------------------
  |  Branch (762:16): [True: 0, False: 0]
  ------------------
  763|      0|            TransformD64_4way(out, in);
  764|      0|            out += 128;
  765|      0|            in += 256;
  766|      0|            blocks -= 4;
  767|      0|        }
  768|      0|    }
  769|  3.44k|    if (TransformD64_2way) {
  ------------------
  |  Branch (769:9): [True: 0, False: 3.44k]
  ------------------
  770|      0|        while (blocks >= 2) {
  ------------------
  |  Branch (770:16): [True: 0, False: 0]
  ------------------
  771|      0|            TransformD64_2way(out, in);
  772|      0|            out += 64;
  773|      0|            in += 128;
  774|      0|            blocks -= 2;
  775|      0|        }
  776|      0|    }
  777|  8.61k|    while (blocks) {
  ------------------
  |  Branch (777:12): [True: 5.16k, False: 3.44k]
  ------------------
  778|  5.16k|        TransformD64(out, in);
  779|  5.16k|        out += 32;
  780|  5.16k|        in += 64;
  781|  5.16k|        --blocks;
  782|  5.16k|    }
  783|  3.44k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2565RoundEjjjRjjjjS1_j:
   80|   991k|{
   81|   991k|    uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
   82|   991k|    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
   83|   991k|    d += t1;
   84|   991k|    h = t1 + t2;
   85|   991k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma1Ej:
   74|   991k|uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2562ChEjjj:
   71|   991k|uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma0Ej:
   73|   991k|uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2563MajEjjj:
   72|   991k|uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma1Ej:
   76|   485k|uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); }
sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma0Ej:
   75|   454k|uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); }
sha256.cpp:_ZN12_GLOBAL__N_16sha25612TransformD64EPhPKh:
  188|  5.16k|{
  189|       |    // Transform 1
  190|  5.16k|    uint32_t a = 0x6a09e667ul;
  191|  5.16k|    uint32_t b = 0xbb67ae85ul;
  192|  5.16k|    uint32_t c = 0x3c6ef372ul;
  193|  5.16k|    uint32_t d = 0xa54ff53aul;
  194|  5.16k|    uint32_t e = 0x510e527ful;
  195|  5.16k|    uint32_t f = 0x9b05688cul;
  196|  5.16k|    uint32_t g = 0x1f83d9abul;
  197|  5.16k|    uint32_t h = 0x5be0cd19ul;
  198|       |
  199|  5.16k|    uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
  200|       |
  201|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x428a2f98ul + (w0 = ReadBE32(in + 0)));
  202|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x71374491ul + (w1 = ReadBE32(in + 4)));
  203|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful + (w2 = ReadBE32(in + 8)));
  204|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul + (w3 = ReadBE32(in + 12)));
  205|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x3956c25bul + (w4 = ReadBE32(in + 16)));
  206|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x59f111f1ul + (w5 = ReadBE32(in + 20)));
  207|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x923f82a4ul + (w6 = ReadBE32(in + 24)));
  208|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul + (w7 = ReadBE32(in + 28)));
  209|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xd807aa98ul + (w8 = ReadBE32(in + 32)));
  210|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x12835b01ul + (w9 = ReadBE32(in + 36)));
  211|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x243185beul + (w10 = ReadBE32(in + 40)));
  212|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul + (w11 = ReadBE32(in + 44)));
  213|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x72be5d74ul + (w12 = ReadBE32(in + 48)));
  214|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x80deb1feul + (w13 = ReadBE32(in + 52)));
  215|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul + (w14 = ReadBE32(in + 56)));
  216|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc19bf174ul + (w15 = ReadBE32(in + 60)));
  217|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xe49b69c1ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  218|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xefbe4786ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  219|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x0fc19dc6ul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  220|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x240ca1ccul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  221|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x2de92c6ful + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  222|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x4a7484aaul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  223|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  224|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x76f988daul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  225|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x983e5152ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  226|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xa831c66dul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  227|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb00327c8ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  228|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xbf597fc7ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  229|  5.16k|    Round(e, f, g, h, a, b, c, d, 0xc6e00bf3ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  230|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xd5a79147ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  231|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x06ca6351ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  232|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x14292967ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  233|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x27b70a85ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  234|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x2e1b2138ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  235|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x4d2c6dfcul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  236|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x53380d13ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  237|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x650a7354ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  238|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x766a0abbul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  239|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x81c2c92eul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  240|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x92722c85ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  241|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  242|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xa81a664bul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  243|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xc24b8b70ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  244|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xc76c51a3ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  245|  5.16k|    Round(e, f, g, h, a, b, c, d, 0xd192e819ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  246|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xd6990624ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  247|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xf40e3585ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  248|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x106aa070ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  249|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x19a4c116ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  250|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x1e376c08ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  251|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x2748774cul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  252|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x34b0bcb5ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  253|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x391c0cb3ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  254|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x4ed8aa4aul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  255|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x5b9cca4ful + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  256|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x682e6ff3ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  257|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x748f82eeul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  258|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x78a5636ful + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  259|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x84c87814ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  260|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x8cc70208ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  261|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x90befffaul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  262|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xa4506cebul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  263|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xbef9a3f7ul + (w14 + sigma1(w12) + w7 + sigma0(w15)));
  264|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc67178f2ul + (w15 + sigma1(w13) + w8 + sigma0(w0)));
  265|       |
  266|  5.16k|    a += 0x6a09e667ul;
  267|  5.16k|    b += 0xbb67ae85ul;
  268|  5.16k|    c += 0x3c6ef372ul;
  269|  5.16k|    d += 0xa54ff53aul;
  270|  5.16k|    e += 0x510e527ful;
  271|  5.16k|    f += 0x9b05688cul;
  272|  5.16k|    g += 0x1f83d9abul;
  273|  5.16k|    h += 0x5be0cd19ul;
  274|       |
  275|  5.16k|    uint32_t t0 = a, t1 = b, t2 = c, t3 = d, t4 = e, t5 = f, t6 = g, t7 = h;
  276|       |
  277|       |    // Transform 2
  278|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xc28a2f98ul);
  279|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x71374491ul);
  280|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful);
  281|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul);
  282|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x3956c25bul);
  283|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x59f111f1ul);
  284|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x923f82a4ul);
  285|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul);
  286|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xd807aa98ul);
  287|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x12835b01ul);
  288|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x243185beul);
  289|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul);
  290|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x72be5d74ul);
  291|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x80deb1feul);
  292|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul);
  293|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc19bf374ul);
  294|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x649b69c1ul);
  295|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xf0fe4786ul);
  296|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x0fe1edc6ul);
  297|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x240cf254ul);
  298|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x4fe9346ful);
  299|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x6cc984beul);
  300|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x61b9411eul);
  301|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x16f988faul);
  302|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xf2c65152ul);
  303|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xa88e5a6dul);
  304|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb019fc65ul);
  305|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xb9d99ec7ul);
  306|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x9a1231c3ul);
  307|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xe70eeaa0ul);
  308|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xfdb1232bul);
  309|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc7353eb0ul);
  310|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x3069bad5ul);
  311|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xcb976d5ful);
  312|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x5a0f118ful);
  313|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xdc1eeefdul);
  314|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x0a35b689ul);
  315|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xde0b7a04ul);
  316|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x58f4ca9dul);
  317|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xe15d5b16ul);
  318|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x007f3e86ul);
  319|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x37088980ul);
  320|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xa507ea32ul);
  321|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x6fab9537ul);
  322|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x17406110ul);
  323|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x0d8cd6f1ul);
  324|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xcdaa3b6dul);
  325|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc0bbbe37ul);
  326|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x83613bdaul);
  327|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xdb48a363ul);
  328|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x0b02e931ul);
  329|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x6fd15ca7ul);
  330|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x521afacaul);
  331|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x31338431ul);
  332|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x6ed41a95ul);
  333|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x6d437890ul);
  334|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xc39c91f2ul);
  335|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x9eccabbdul);
  336|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb5c9a0e6ul);
  337|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x532fb63cul);
  338|  5.16k|    Round(e, f, g, h, a, b, c, d, 0xd2c741c6ul);
  339|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x07237ea3ul);
  340|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xa4954b68ul);
  341|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x4c191d76ul);
  342|       |
  343|  5.16k|    w0 = t0 + a;
  344|  5.16k|    w1 = t1 + b;
  345|  5.16k|    w2 = t2 + c;
  346|  5.16k|    w3 = t3 + d;
  347|  5.16k|    w4 = t4 + e;
  348|  5.16k|    w5 = t5 + f;
  349|  5.16k|    w6 = t6 + g;
  350|  5.16k|    w7 = t7 + h;
  351|       |
  352|       |    // Transform 3
  353|  5.16k|    a = 0x6a09e667ul;
  354|  5.16k|    b = 0xbb67ae85ul;
  355|  5.16k|    c = 0x3c6ef372ul;
  356|  5.16k|    d = 0xa54ff53aul;
  357|  5.16k|    e = 0x510e527ful;
  358|  5.16k|    f = 0x9b05688cul;
  359|  5.16k|    g = 0x1f83d9abul;
  360|  5.16k|    h = 0x5be0cd19ul;
  361|       |
  362|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x428a2f98ul + w0);
  363|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x71374491ul + w1);
  364|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful + w2);
  365|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul + w3);
  366|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x3956c25bul + w4);
  367|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x59f111f1ul + w5);
  368|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x923f82a4ul + w6);
  369|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul + w7);
  370|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x5807aa98ul);
  371|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x12835b01ul);
  372|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x243185beul);
  373|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul);
  374|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x72be5d74ul);
  375|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x80deb1feul);
  376|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul);
  377|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc19bf274ul);
  378|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xe49b69c1ul + (w0 += sigma0(w1)));
  379|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xefbe4786ul + (w1 += 0xa00000ul + sigma0(w2)));
  380|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x0fc19dc6ul + (w2 += sigma1(w0) + sigma0(w3)));
  381|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x240ca1ccul + (w3 += sigma1(w1) + sigma0(w4)));
  382|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x2de92c6ful + (w4 += sigma1(w2) + sigma0(w5)));
  383|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x4a7484aaul + (w5 += sigma1(w3) + sigma0(w6)));
  384|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcul + (w6 += sigma1(w4) + 0x100ul + sigma0(w7)));
  385|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x76f988daul + (w7 += sigma1(w5) + w0 + 0x11002000ul));
  386|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x983e5152ul + (w8 = 0x80000000ul + sigma1(w6) + w1));
  387|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xa831c66dul + (w9 = sigma1(w7) + w2));
  388|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xb00327c8ul + (w10 = sigma1(w8) + w3));
  389|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xbf597fc7ul + (w11 = sigma1(w9) + w4));
  390|  5.16k|    Round(e, f, g, h, a, b, c, d, 0xc6e00bf3ul + (w12 = sigma1(w10) + w5));
  391|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xd5a79147ul + (w13 = sigma1(w11) + w6));
  392|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x06ca6351ul + (w14 = sigma1(w12) + w7 + 0x400022ul));
  393|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x14292967ul + (w15 = 0x100ul + sigma1(w13) + w8 + sigma0(w0)));
  394|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x27b70a85ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  395|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x2e1b2138ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  396|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x4d2c6dfcul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  397|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x53380d13ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  398|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x650a7354ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  399|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x766a0abbul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  400|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x81c2c92eul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  401|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x92722c85ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  402|  5.16k|    Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  403|  5.16k|    Round(h, a, b, c, d, e, f, g, 0xa81a664bul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  404|  5.16k|    Round(g, h, a, b, c, d, e, f, 0xc24b8b70ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  405|  5.16k|    Round(f, g, h, a, b, c, d, e, 0xc76c51a3ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  406|  5.16k|    Round(e, f, g, h, a, b, c, d, 0xd192e819ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  407|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xd6990624ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  408|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xf40e3585ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
  409|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x106aa070ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
  410|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x19a4c116ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
  411|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x1e376c08ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
  412|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x2748774cul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
  413|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x34b0bcb5ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
  414|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x391c0cb3ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
  415|  5.16k|    Round(d, e, f, g, h, a, b, c, 0x4ed8aa4aul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
  416|  5.16k|    Round(c, d, e, f, g, h, a, b, 0x5b9cca4ful + (w6 += sigma1(w4) + w15 + sigma0(w7)));
  417|  5.16k|    Round(b, c, d, e, f, g, h, a, 0x682e6ff3ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
  418|  5.16k|    Round(a, b, c, d, e, f, g, h, 0x748f82eeul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
  419|  5.16k|    Round(h, a, b, c, d, e, f, g, 0x78a5636ful + (w9 += sigma1(w7) + w2 + sigma0(w10)));
  420|  5.16k|    Round(g, h, a, b, c, d, e, f, 0x84c87814ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
  421|  5.16k|    Round(f, g, h, a, b, c, d, e, 0x8cc70208ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
  422|  5.16k|    Round(e, f, g, h, a, b, c, d, 0x90befffaul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
  423|  5.16k|    Round(d, e, f, g, h, a, b, c, 0xa4506cebul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
  424|  5.16k|    Round(c, d, e, f, g, h, a, b, 0xbef9a3f7ul + (w14 + sigma1(w12) + w7 + sigma0(w15)));
  425|  5.16k|    Round(b, c, d, e, f, g, h, a, 0xc67178f2ul + (w15 + sigma1(w13) + w8 + sigma0(w0)));
  426|       |
  427|       |    // Output
  428|  5.16k|    WriteBE32(out + 0, a + 0x6a09e667ul);
  429|  5.16k|    WriteBE32(out + 4, b + 0xbb67ae85ul);
  430|  5.16k|    WriteBE32(out + 8, c + 0x3c6ef372ul);
  431|  5.16k|    WriteBE32(out + 12, d + 0xa54ff53aul);
  432|  5.16k|    WriteBE32(out + 16, e + 0x510e527ful);
  433|  5.16k|    WriteBE32(out + 20, f + 0x9b05688cul);
  434|  5.16k|    WriteBE32(out + 24, g + 0x1f83d9abul);
  435|  5.16k|    WriteBE32(out + 28, h + 0x5be0cd19ul);
  436|  5.16k|}

_Z14SipHashUint256mmRK7uint256:
   96|  1.72k|{
   97|       |    /* Specialized implementation for efficiency */
   98|  1.72k|    uint64_t d = val.GetUint64(0);
   99|       |
  100|  1.72k|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
  101|  1.72k|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
  102|  1.72k|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
  103|  1.72k|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
  104|       |
  105|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  106|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|  1.72k|    v0 ^= d;
  108|  1.72k|    d = val.GetUint64(1);
  109|  1.72k|    v3 ^= d;
  110|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  111|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|  1.72k|    v0 ^= d;
  113|  1.72k|    d = val.GetUint64(2);
  114|  1.72k|    v3 ^= d;
  115|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  117|  1.72k|    v0 ^= d;
  118|  1.72k|    d = val.GetUint64(3);
  119|  1.72k|    v3 ^= d;
  120|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  121|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  122|  1.72k|    v0 ^= d;
  123|  1.72k|    v3 ^= (uint64_t{4}) << 59;
  124|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  125|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  126|  1.72k|    v0 ^= (uint64_t{4}) << 59;
  127|  1.72k|    v2 ^= 0xFF;
  128|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  130|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  131|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  132|  1.72k|    return v0 ^ v1 ^ v2 ^ v3;
  133|  1.72k|}
_Z19SipHashUint256ExtrammRK7uint256j:
  136|  1.72k|{
  137|       |    /* Specialized implementation for efficiency */
  138|  1.72k|    uint64_t d = val.GetUint64(0);
  139|       |
  140|  1.72k|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
  141|  1.72k|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
  142|  1.72k|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
  143|  1.72k|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
  144|       |
  145|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  147|  1.72k|    v0 ^= d;
  148|  1.72k|    d = val.GetUint64(1);
  149|  1.72k|    v3 ^= d;
  150|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  151|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  152|  1.72k|    v0 ^= d;
  153|  1.72k|    d = val.GetUint64(2);
  154|  1.72k|    v3 ^= d;
  155|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  156|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|  1.72k|    v0 ^= d;
  158|  1.72k|    d = val.GetUint64(3);
  159|  1.72k|    v3 ^= d;
  160|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  161|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  162|  1.72k|    v0 ^= d;
  163|  1.72k|    d = ((uint64_t{36}) << 56) | extra;
  164|  1.72k|    v3 ^= d;
  165|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  166|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  167|  1.72k|    v0 ^= d;
  168|  1.72k|    v2 ^= 0xFF;
  169|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  170|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  171|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  172|  1.72k|    SIPROUND;
  ------------------
  |  |    9|  1.72k|#define SIPROUND do { \
  |  |   10|  1.72k|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  1.72k|    v0 = std::rotl(v0, 32); \
  |  |   12|  1.72k|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  1.72k|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  1.72k|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  1.72k|    v2 = std::rotl(v2, 32); \
  |  |   16|  1.72k|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  173|  1.72k|    return v0 ^ v1 ^ v2 ^ v3;
  174|  1.72k|}

_ZNK12CChainParams12GetConsensusEv:
   93|  1.72k|    const Consensus::Params& GetConsensus() const { return consensus; }

integer.cpp:_ZN8memusageL12DynamicUsageERKi:
   35|  3.44k|static inline size_t DynamicUsage(const int32_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKs:
   33|  1.72k|static inline size_t DynamicUsage(const int16_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKl:
   37|  1.72k|static inline size_t DynamicUsage(const int64_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKa:
   31|  1.72k|static inline size_t DynamicUsage(const int8_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKt:
   34|  1.72k|static inline size_t DynamicUsage(const uint16_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKj:
   36|  1.72k|static inline size_t DynamicUsage(const uint32_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKm:
   38|  1.72k|static inline size_t DynamicUsage(const uint64_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageERKh:
   32|  3.44k|static inline size_t DynamicUsage(const uint8_t& v) { return 0; }
integer.cpp:_ZN8memusageL12DynamicUsageIlNSt3__14lessIlEEEEmRKNS1_3setIT_T0_NS1_9allocatorIS5_EEEE:
  114|  1.72k|{
  115|  1.72k|    return MallocUsage(sizeof(stl_tree_node<X>)) * s.size();
  116|  1.72k|}
integer.cpp:_ZN8memusageL11MallocUsageEm:
   53|  3.44k|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  3.44k|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 0, False: 3.44k]
  ------------------
   56|      0|        return 0;
   57|  3.44k|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|  3.44k|        return ((alloc + 31) >> 4) << 4;
   59|  3.44k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|  3.44k|}
integer.cpp:_ZN8memusageL23IncrementalDynamicUsageIlNSt3__14lessIlEEEEmRKNS1_3setIT_T0_NS1_9allocatorIS5_EEEE:
  120|  1.72k|{
  121|  1.72k|    return MallocUsage(sizeof(stl_tree_node<X>));
  122|  1.72k|}

_Z25GetVirtualTransactionSizellj:
  313|  1.19k|{
  314|  1.19k|    return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
  315|  1.19k|}

_Z12DeriveTargetj7uint256:
  147|  1.72k|{
  148|  1.72k|    bool fNegative;
  149|  1.72k|    bool fOverflow;
  150|  1.72k|    arith_uint256 bnTarget;
  151|       |
  152|  1.72k|    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
  153|       |
  154|       |    // Check range
  155|  1.72k|    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(pow_limit))
  ------------------
  |  Branch (155:9): [True: 207, False: 1.51k]
  |  Branch (155:9): [True: 1.60k, False: 117]
  |  Branch (155:22): [True: 1.38k, False: 135]
  |  Branch (155:39): [True: 5, False: 130]
  |  Branch (155:52): [True: 13, False: 117]
  ------------------
  156|  1.60k|        return {};
  157|       |
  158|    117|    return bnTarget;
  159|  1.72k|}
_Z20CheckProofOfWorkImpl7uint256jRKN9Consensus6ParamsE:
  162|  1.72k|{
  163|  1.72k|    auto bnTarget{DeriveTarget(nBits, params.powLimit)};
  164|  1.72k|    if (!bnTarget) return false;
  ------------------
  |  Branch (164:9): [True: 1.60k, False: 117]
  ------------------
  165|       |
  166|       |    // Check proof of work matches claimed amount
  167|    117|    if (UintToArith256(hash) > bnTarget)
  ------------------
  |  Branch (167:9): [True: 104, False: 13]
  ------------------
  168|    104|        return false;
  169|       |
  170|     13|    return true;
  171|    117|}

integer.cpp:_ZL22MayHaveUsefulAddressDB12ServiceFlags:
  361|  1.72k|{
  362|  1.72k|    return (services & NODE_NETWORK) || (services & NODE_NETWORK_LIMITED);
  ------------------
  |  Branch (362:12): [True: 725, False: 997]
  |  Branch (362:41): [True: 274, False: 723]
  ------------------
  363|  1.72k|}

_ZN6CKeyIDC2ERK7uint160:
   27|  1.72k|    explicit CKeyID(const uint160& in) : uint160(in) {}

_ZN10CScriptNumC2ERKl:
  239|  1.72k|    {
  240|  1.72k|        m_value = n;
  241|  1.72k|    }
_ZNK10CScriptNum6getintEv:
  334|  1.72k|    {
  335|  1.72k|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (335:13): [True: 493, False: 1.22k]
  ------------------
  336|    493|            return std::numeric_limits<int>::max();
  337|  1.22k|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (337:18): [True: 1.07k, False: 152]
  ------------------
  338|  1.07k|            return std::numeric_limits<int>::min();
  339|    152|        return m_value;
  340|  1.72k|    }
_ZNK10CScriptNum6getvchEv:
  345|  1.72k|    {
  346|  1.72k|        return serialize(m_value);
  347|  1.72k|    }
_ZN10CScriptNum9serializeERKl:
  350|  1.72k|    {
  351|  1.72k|        if(value == 0)
  ------------------
  |  Branch (351:12): [True: 2, False: 1.72k]
  ------------------
  352|      2|            return std::vector<unsigned char>();
  353|       |
  354|  1.72k|        std::vector<unsigned char> result;
  355|  1.72k|        const bool neg = value < 0;
  356|  1.72k|        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
  ------------------
  |  Branch (356:29): [True: 1.17k, False: 544]
  ------------------
  357|       |
  358|  14.1k|        while(absvalue)
  ------------------
  |  Branch (358:15): [True: 12.4k, False: 1.72k]
  ------------------
  359|  12.4k|        {
  360|  12.4k|            result.push_back(absvalue & 0xff);
  361|  12.4k|            absvalue >>= 8;
  362|  12.4k|        }
  363|       |
  364|       |//    - If the most significant byte is >= 0x80 and the value is positive, push a
  365|       |//    new zero-byte to make the significant byte < 0x80 again.
  366|       |
  367|       |//    - If the most significant byte is >= 0x80 and the value is negative, push a
  368|       |//    new 0x80 byte that will be popped off when converting to an integral.
  369|       |
  370|       |//    - If the most significant byte is < 0x80 and the value is negative, add
  371|       |//    0x80 to it, since it will be subtracted and interpreted as a negative when
  372|       |//    converting to an integral.
  373|       |
  374|  1.72k|        if (result.back() & 0x80)
  ------------------
  |  Branch (374:13): [True: 703, False: 1.01k]
  ------------------
  375|    703|            result.push_back(neg ? 0x80 : 0);
  ------------------
  |  Branch (375:30): [True: 672, False: 31]
  ------------------
  376|  1.01k|        else if (neg)
  ------------------
  |  Branch (376:18): [True: 504, False: 513]
  ------------------
  377|    504|            result.back() |= 0x80;
  378|       |
  379|  1.72k|        return result;
  380|  1.72k|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  518|      8|    {
  519|      8|        if (opcode == OP_0)
  ------------------
  |  Branch (519:13): [True: 1, False: 7]
  ------------------
  520|      1|            return 0;
  521|      7|        assert(opcode >= OP_1 && opcode <= OP_16);
  522|      7|        return (int)opcode - (int)(OP_1 - 1);
  523|      7|    }
_ZN7CScript10EncodeOP_NEi:
  525|      8|    {
  526|      8|        assert(n >= 0 && n <= 16);
  527|      8|        if (n == 0)
  ------------------
  |  Branch (527:13): [True: 1, False: 7]
  ------------------
  528|      1|            return OP_0;
  529|      7|        return (opcodetype)(OP_1+n-1);
  530|      8|    }
_ZN9CScriptIDC2ERK7uint160:
  606|  1.72k|    explicit CScriptID(const uint160& in) : BaseHash(in) {}

_Z20GetSizeOfCompactSizem:
  298|  1.72k|{
  299|  1.72k|    if (nSize < 253)             return sizeof(unsigned char);
  ------------------
  |  Branch (299:9): [True: 136, False: 1.58k]
  ------------------
  300|  1.58k|    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
  ------------------
  |  Branch (300:14): [True: 54, False: 1.53k]
  ------------------
  301|  1.53k|    else if (nSize <= std::numeric_limits<unsigned int>::max())  return sizeof(unsigned char) + sizeof(unsigned int);
  ------------------
  |  Branch (301:14): [True: 136, False: 1.39k]
  ------------------
  302|  1.39k|    else                         return sizeof(unsigned char) + sizeof(uint64_t);
  303|  1.72k|}
_Z11UnserializeI10DataStreamEvRT_Ri:
  276|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); }
_Z14ser_readdata32I10DataStreamEjRT_:
  102|  5.30k|{
  103|  5.30k|    uint32_t obj;
  104|  5.30k|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|  5.30k|    return le32toh_internal(obj);
  106|  5.30k|}
_Z11UnserializeI10DataStreamR7uint256Q14UnserializableIT0_T_EEvRS4_OS3_:
  762|  1.72k|{
  763|  1.72k|    a.Unserialize(is);
  764|  1.72k|}
_Z11UnserializeI10DataStreamEvRT_Rj:
  277|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|  1.72k|{
  341|  1.72k|    uint8_t chSize = ser_readdata8(is);
  342|  1.72k|    uint64_t nSizeRet = 0;
  343|  1.72k|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 136, False: 1.58k]
  ------------------
  344|    136|    {
  345|    136|        nSizeRet = chSize;
  346|    136|    }
  347|  1.58k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 54, False: 1.53k]
  ------------------
  348|     54|    {
  349|     54|        nSizeRet = ser_readdata16(is);
  350|     54|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 0, False: 54]
  ------------------
  351|      0|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     54|    }
  353|  1.53k|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 136, False: 1.39k]
  ------------------
  354|    136|    {
  355|    136|        nSizeRet = ser_readdata32(is);
  356|    136|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 0, False: 136]
  ------------------
  357|      0|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    136|    }
  359|  1.39k|    else
  360|  1.39k|    {
  361|  1.39k|        nSizeRet = ser_readdata64(is);
  362|  1.39k|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 0, False: 1.39k]
  ------------------
  363|      0|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|  1.39k|    }
  365|  1.72k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 1.72k, False: 0]
  |  Branch (365:24): [True: 1.46k, False: 259]
  ------------------
  366|  1.46k|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|  1.46k|    }
  368|    259|    return nSizeRet;
  369|  1.72k|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|  8.61k|{
   85|  8.61k|    uint8_t obj;
   86|  8.61k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  8.61k|    return obj;
   88|  8.61k|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|  5.22k|{
   91|  5.22k|    uint16_t obj;
   92|  5.22k|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|  5.22k|    return le16toh_internal(obj);
   94|  5.22k|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|  6.56k|{
  115|  6.56k|    uint64_t obj;
  116|  6.56k|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|  6.56k|    return le64toh_internal(obj);
  118|  6.56k|}
_Z11UnserializeI10DataStreamEvRT_Rh:
  273|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_Z9SerializeI10DataStreamEvRT_h:
  258|  1.72k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z14ser_writedata8I10DataStreamEvRT_h:
   55|  8.61k|{
   56|  8.61k|    s.write(AsBytes(Span{&obj, 1}));
   57|  8.61k|}
_Z9SerializeI10DataStream7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|  1.72k|{
  754|  1.72k|    a.Serialize(os);
  755|  1.72k|}
_Z9SerializeI10DataStreamTk9BasicByteKhEvRT_4SpanIT0_E:
  268|  3.44k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z16WriteCompactSizeI10DataStreamEvRT_m:
  309|  1.72k|{
  310|  1.72k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 136, False: 1.58k]
  ------------------
  311|    136|    {
  312|    136|        ser_writedata8(os, nSize);
  313|    136|    }
  314|  1.58k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 54, False: 1.53k]
  ------------------
  315|     54|    {
  316|     54|        ser_writedata8(os, 253);
  317|     54|        ser_writedata16(os, nSize);
  318|     54|    }
  319|  1.53k|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 136, False: 1.39k]
  ------------------
  320|    136|    {
  321|    136|        ser_writedata8(os, 254);
  322|    136|        ser_writedata32(os, nSize);
  323|    136|    }
  324|  1.39k|    else
  325|  1.39k|    {
  326|  1.39k|        ser_writedata8(os, 255);
  327|  1.39k|        ser_writedata64(os, nSize);
  328|  1.39k|    }
  329|  1.72k|    return;
  330|  1.72k|}
_Z15ser_writedata16I10DataStreamEvRT_t:
   59|  5.22k|{
   60|  5.22k|    obj = htole16_internal(obj);
   61|  5.22k|    s.write(AsBytes(Span{&obj, 1}));
   62|  5.22k|}
_Z15ser_writedata32I10DataStreamEvRT_j:
   69|  5.30k|{
   70|  5.30k|    obj = htole32_internal(obj);
   71|  5.30k|    s.write(AsBytes(Span{&obj, 1}));
   72|  5.30k|}
_Z15ser_writedata64I10DataStreamEvRT_m:
   79|  6.56k|{
   80|  6.56k|    obj = htole64_internal(obj);
   81|  6.56k|    s.write(AsBytes(Span{&obj, 1}));
   82|  6.56k|}
_Z11UnserializeI10DataStreamEvRT_Rm:
  279|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a) { a = ser_readdata64(s); }
_Z9SerializeI10DataStreamEvRT_i:
  261|  1.72k|template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
_Z9SerializeI10DataStreamEvRT_j:
  262|  1.72k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z9SerializeI10DataStreamEvRT_m:
  264|  1.72k|template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
_Z11UnserializeI10DataStreamEvRT_Rl:
  278|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
_Z9SerializeI10DataStreamEvRT_l:
  263|  1.72k|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_Z11UnserializeI10DataStreamEvRT_Rt:
  275|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, uint16_t& a) { a = ser_readdata16(s); }
_Z9SerializeI10DataStreamEvRT_t:
  260|  1.72k|template<typename Stream> inline void Serialize(Stream& s, uint16_t a) { ser_writedata16(s, a); }
_Z11UnserializeI10DataStreamR7uint160Q14UnserializableIT0_T_EEvRS4_OS3_:
  762|  1.72k|{
  763|  1.72k|    a.Unserialize(is);
  764|  1.72k|}
_Z9SerializeI10DataStream7uint160Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|  1.72k|{
  754|  1.72k|    a.Serialize(os);
  755|  1.72k|}
_Z9SerializeI10DataStreamEvRT_s:
  259|  1.72k|template<typename Stream> inline void Serialize(Stream& s, int16_t a ) { ser_writedata16(s, a); }
_Z11UnserializeI10DataStreamEvRT_Rs:
  274|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, int16_t& a ) { a = ser_readdata16(s); }
_Z9SerializeI10DataStreamEvRT_a:
  257|  1.72k|template<typename Stream> inline void Serialize(Stream& s, int8_t a  ) { ser_writedata8(s, a); }
_Z11UnserializeI10DataStreamEvRT_Ra:
  272|  1.72k|template<typename Stream> inline void Unserialize(Stream& s, int8_t& a  ) { a = ser_readdata8(s); }
_Z9SerializeI10DataStreamEvRT_b:
  285|  1.72k|template <typename Stream> inline void Serialize(Stream& s, bool a) { uint8_t f = a; ser_writedata8(s, f); }
_Z11UnserializeI10DataStreamEvRT_Rb:
  286|  1.72k|template <typename Stream> inline void Unserialize(Stream& s, bool& a) { uint8_t f = ser_readdata8(s); a = f; }
_Z17ser_writedata32beI10DataStreamEvRT_j:
   74|  1.72k|{
   75|  1.72k|    obj = htobe32_internal(obj);
   76|  1.72k|    s.write(AsBytes(Span{&obj, 1}));
   77|  1.72k|}
_Z16ser_readdata32beI10DataStreamEjRT_:
  108|  1.72k|{
  109|  1.72k|    uint32_t obj;
  110|  1.72k|    s.read(AsWritableBytes(Span{&obj, 1}));
  111|  1.72k|    return be32toh_internal(obj);
  112|  1.72k|}
_Z17ser_writedata16beI10DataStreamEvRT_t:
   64|  1.72k|{
   65|  1.72k|    obj = htobe16_internal(obj);
   66|  1.72k|    s.write(AsBytes(Span{&obj, 1}));
   67|  1.72k|}
_Z16ser_readdata16beI10DataStreamEtRT_:
   96|  1.72k|{
   97|  1.72k|    uint16_t obj;
   98|  1.72k|    s.read(AsWritableBytes(Span{&obj, 1}));
   99|  1.72k|    return be16toh_internal(obj);
  100|  1.72k|}

_ZNK4SpanIKhE4sizeEv:
  187|  8.61k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|  8.61k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|  8.61k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4dataEv:
  174|  20.6k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  3.44k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  97.7k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  32.5k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE5beginEv:
  175|  32.5k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE3endEv:
  176|  32.5k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIKhE10size_bytesEv:
  188|  3.44k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|  3.44k|{
  260|  3.44k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  3.44k|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|  3.44k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  32.5k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZNK4SpanIjE4dataEv:
  174|  14.0k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  14.0k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|  7.02k|{
  260|  7.02k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  7.02k|}
_ZNK4SpanIhE10size_bytesEv:
  188|  20.6k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  8.61k|{
  260|  8.61k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  8.61k|}
_ZNK4SpanItE4dataEv:
  174|  13.8k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|  13.8k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|  6.94k|{
  260|  6.94k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  6.94k|}
_ZNK4SpanImE4dataEv:
  174|  13.1k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|  13.1k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|  6.56k|{
  260|  6.56k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  6.56k|}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  32.5k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  12.0k|{
  265|  12.0k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  12.0k|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  17.2k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|  6.94k|{
  265|  6.94k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  6.94k|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|  13.8k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|  7.02k|{
  265|  7.02k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  7.02k|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  14.0k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|  6.56k|{
  265|  6.56k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  6.56k|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|  13.1k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.72k|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|  1.72k|{
  276|  1.72k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|  1.72k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|  1.72k|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm20EEEE4SpanISt4byteEOT_:
  275|  1.72k|{
  276|  1.72k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|  1.72k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm20EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|  1.72k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm20EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.72k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|  5.16k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}

_ZNK10DataStream5emptyEv:
  182|  29.5k|    bool empty() const                               { return vch.size() == m_read_pos; }
_ZN10DataStream4readE4SpanISt4byteE:
  219|  32.5k|    {
  220|  32.5k|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 32.5k]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  32.5k|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  32.5k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 32.5k]
  |  Branch (224:43): [True: 0, False: 32.5k]
  ------------------
  225|      0|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|      0|        }
  227|  32.5k|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  32.5k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 30.9k, False: 1.58k]
  ------------------
  229|  30.9k|            m_read_pos = 0;
  230|  30.9k|            vch.clear();
  231|  30.9k|            return;
  232|  30.9k|        }
  233|  1.58k|        m_read_pos = next_read_pos.value();
  234|  1.58k|    }
_ZN10DataStream5writeE4SpanIKSt4byteE:
  252|  32.5k|    {
  253|       |        // Write to the end of the buffer
  254|  32.5k|        vch.insert(vch.end(), src.begin(), src.end());
  255|  32.5k|    }
_ZN10DataStreamC2Ev:
  164|  5.16k|    explicit DataStream() = default;
_ZN10DataStreamrsIRhEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamrsIR7uint256EERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIhEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamlsI7uint256EERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamlsI4SpanIKhEEERS_RKT_:
  259|  3.44k|    {
  260|  3.44k|        ::Serialize(*this, obj);
  261|  3.44k|        return (*this);
  262|  3.44k|    }
_ZN10DataStreamrsIRjEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIjEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRtEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamrsIRmEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsItEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamlsImEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIR7uint160EERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsI7uint160EERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamlsIlEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRlEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIiEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRiEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIsEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRsEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIaEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRaEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }
_ZN10DataStreamlsIbEERS_RKT_:
  259|  1.72k|    {
  260|  1.72k|        ::Serialize(*this, obj);
  261|  1.72k|        return (*this);
  262|  1.72k|    }
_ZN10DataStreamrsIRbEERS_OT_:
  266|  1.72k|    {
  267|  1.72k|        ::Unserialize(*this, obj);
  268|  1.72k|        return (*this);
  269|  1.72k|    }

_ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m:
   30|  6.75k|    {
   31|  6.75k|        if (p != nullptr)
  ------------------
  |  Branch (31:13): [True: 6.75k, False: 0]
  ------------------
   32|  6.75k|            memory_cleanse(p, sizeof(T) * n);
   33|  6.75k|        std::allocator<T>{}.deallocate(p, n);
   34|  6.75k|    }
_ZN25zero_after_free_allocatorISt4byteE8allocateEm:
   25|  6.75k|    {
   26|  6.75k|        return std::allocator<T>{}.allocate(n);
   27|  6.75k|    }

_Z14memory_cleansePvm:
   15|  6.75k|{
   16|       |#if defined(WIN32)
   17|       |    /* SecureZeroMemory is guaranteed not to be optimized out. */
   18|       |    SecureZeroMemory(ptr, len);
   19|       |#else
   20|  6.75k|    std::memset(ptr, 0, len);
   21|       |
   22|       |    /* Memory barrier that scares the compiler away from optimizing out the memset.
   23|       |     *
   24|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
   25|       |     * in BoringSSL (ISC License):
   26|       |     *    As best as we can tell, this is sufficient to break any optimisations that
   27|       |     *    might try to eliminate "superfluous" memsets.
   28|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
   29|       |     * is pretty efficient because the compiler can still implement the memset() efficiently,
   30|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
   31|       |     * Yang et al. (USENIX Security 2017) for more background.
   32|       |     */
   33|  6.75k|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
   34|  6.75k|#endif
   35|  6.75k|}

_ZN18FuzzedDataProviderC2EPKhm:
   37|  1.72k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  10.4k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 9.38k, False: 1.04k]
  |  Branch (217:43): [True: 9.38k, False: 0]
  ------------------
  218|  10.4k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 8.71k, False: 676]
  ------------------
  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|  8.71k|    --remaining_bytes_;
  226|  8.71k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  8.71k|    offset += CHAR_BIT;
  228|  8.71k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 0, False: 1.72k]
  ------------------
  232|      0|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  13.5k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 12.2k, False: 1.26k]
  |  Branch (217:43): [True: 12.2k, False: 0]
  ------------------
  218|  13.5k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 11.7k, False: 456]
  ------------------
  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|  11.7k|    --remaining_bytes_;
  226|  11.7k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  11.7k|    offset += CHAR_BIT;
  228|  11.7k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 0, False: 1.72k]
  ------------------
  232|      0|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  2.69k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.46k, False: 231]
  |  Branch (217:43): [True: 2.46k, False: 0]
  ------------------
  218|  2.69k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 971, False: 1.49k]
  ------------------
  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|    971|    --remaining_bytes_;
  226|    971|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    971|    offset += CHAR_BIT;
  228|    971|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  4.01k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.53k, False: 488]
  |  Branch (217:43): [True: 3.53k, False: 0]
  ------------------
  218|  4.01k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 2.29k, False: 1.23k]
  ------------------
  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|  2.29k|    --remaining_bytes_;
  226|  2.29k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  2.29k|    offset += CHAR_BIT;
  228|  2.29k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIsEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIsEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  2.07k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.90k, False: 178]
  |  Branch (217:43): [True: 1.90k, False: 0]
  ------------------
  218|  2.07k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 357, False: 1.54k]
  ------------------
  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|    357|    --remaining_bytes_;
  226|    357|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    357|    offset += CHAR_BIT;
  228|    357|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralItEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  2.08k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.90k, False: 180]
  |  Branch (217:43): [True: 1.90k, False: 0]
  ------------------
  218|  2.08k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 361, False: 1.54k]
  ------------------
  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|    361|    --remaining_bytes_;
  226|    361|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    361|    offset += CHAR_BIT;
  228|    361|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIcEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIcEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  1.88k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.72k, False: 166]
  |  Branch (217:43): [True: 1.72k, False: 0]
  ------------------
  218|  1.88k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 166, False: 1.55k]
  ------------------
  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|    166|    --remaining_bytes_;
  226|    166|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    166|    offset += CHAR_BIT;
  228|    166|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  3.44k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  3.44k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  3.44k|                                std::numeric_limits<T>::max());
  198|  3.44k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  3.44k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  3.44k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  3.44k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  3.44k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 3.44k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  3.44k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  3.44k|  uint64_t result = 0;
  215|  3.44k|  size_t offset = 0;
  216|       |
  217|  3.78k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.44k, False: 342]
  |  Branch (217:43): [True: 3.44k, False: 0]
  ------------------
  218|  3.78k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 342, False: 3.10k]
  ------------------
  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|    342|    --remaining_bytes_;
  226|    342|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    342|    offset += CHAR_BIT;
  228|    342|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  3.44k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 3.44k, False: 0]
  ------------------
  232|  3.44k|    result = result % (range + 1);
  233|       |
  234|  3.44k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  3.44k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIaEET_v:
  195|  1.72k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.72k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.72k|                                std::numeric_limits<T>::max());
  198|  1.72k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIaEET_S1_S1_:
  205|  1.72k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.72k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.72k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.72k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.72k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.72k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.72k|  uint64_t result = 0;
  215|  1.72k|  size_t offset = 0;
  216|       |
  217|  1.88k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.72k, False: 167]
  |  Branch (217:43): [True: 1.72k, False: 0]
  ------------------
  218|  1.88k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 167, False: 1.55k]
  ------------------
  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|    167|    --remaining_bytes_;
  226|    167|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    167|    offset += CHAR_BIT;
  228|    167|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.72k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.72k, False: 0]
  ------------------
  232|  1.72k|    result = result % (range + 1);
  233|       |
  234|  1.72k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.72k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  1.72k|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  1.72k|  return 1 & ConsumeIntegral<uint8_t>();
  291|  1.72k|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  339|  3.44k|                                               size_t num_bytes) {
  340|  3.44k|  std::memcpy(destination, data_ptr_, num_bytes);
  341|  3.44k|  Advance(num_bytes);
  342|  3.44k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  3.44k|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  3.44k|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 3.44k]
  ------------------
  346|      0|    abort();
  347|       |
  348|  3.44k|  data_ptr_ += num_bytes;
  349|  3.44k|  remaining_bytes_ -= num_bytes;
  350|  3.44k|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|  3.44k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|  3.44k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|  3.44k|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|  3.44k|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  353|  3.44k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  354|  3.44k|  static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");
  355|       |
  356|       |  // The point of using the size-based constructor below is to increase the
  357|       |  // odds of having a vector object with capacity being equal to the length.
  358|       |  // That part is always implementation specific, but at least both libc++ and
  359|       |  // libstdc++ allocate the requested number of bytes in that constructor,
  360|       |  // which seems to be a natural choice for other implementations as well.
  361|       |  // To increase the odds even more, we also call |shrink_to_fit| below.
  362|  3.44k|  std::vector<T> result(size);
  363|  3.44k|  if (size == 0) {
  ------------------
  |  Branch (363:7): [True: 0, False: 3.44k]
  ------------------
  364|      0|    if (num_bytes != 0)
  ------------------
  |  Branch (364:9): [True: 0, False: 0]
  ------------------
  365|      0|      abort();
  366|      0|    return result;
  367|      0|  }
  368|       |
  369|  3.44k|  CopyAndAdvance(result.data(), num_bytes);
  370|       |
  371|       |  // Even though |shrink_to_fit| is also implementation specific, we expect it
  372|       |  // to provide an additional assurance in case vector's constructor allocated
  373|       |  // a buffer which is larger than the actual amount of data we put inside it.
  374|  3.44k|  result.shrink_to_fit();
  375|  3.44k|  return result;
  376|  3.44k|}

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

_Z19integer_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   51|  1.73k|{
   52|  1.73k|    if (buffer.size() < sizeof(uint256) + sizeof(uint160)) {
  ------------------
  |  Branch (52:9): [True: 11, False: 1.72k]
  ------------------
   53|     11|        return;
   54|     11|    }
   55|  1.72k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   56|  1.72k|    const uint256 u256(fuzzed_data_provider.ConsumeBytes<unsigned char>(sizeof(uint256)));
   57|  1.72k|    const uint160 u160(fuzzed_data_provider.ConsumeBytes<unsigned char>(sizeof(uint160)));
   58|  1.72k|    const uint64_t u64 = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
   59|  1.72k|    const int64_t i64 = fuzzed_data_provider.ConsumeIntegral<int64_t>();
   60|  1.72k|    const uint32_t u32 = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
   61|  1.72k|    const int32_t i32 = fuzzed_data_provider.ConsumeIntegral<int32_t>();
   62|  1.72k|    const uint16_t u16 = fuzzed_data_provider.ConsumeIntegral<uint16_t>();
   63|  1.72k|    const int16_t i16 = fuzzed_data_provider.ConsumeIntegral<int16_t>();
   64|  1.72k|    const uint8_t u8 = fuzzed_data_provider.ConsumeIntegral<uint8_t>();
   65|  1.72k|    const int8_t i8 = fuzzed_data_provider.ConsumeIntegral<int8_t>();
   66|       |    // We cannot assume a specific value of std::is_signed<char>::value:
   67|       |    // ConsumeIntegral<char>() instead of casting from {u,}int8_t.
   68|  1.72k|    const char ch = fuzzed_data_provider.ConsumeIntegral<char>();
   69|  1.72k|    const bool b = fuzzed_data_provider.ConsumeBool();
   70|       |
   71|  1.72k|    const Consensus::Params& consensus_params = Params().GetConsensus();
   72|  1.72k|    (void)CheckProofOfWorkImpl(u256, u32, consensus_params);
   73|  1.72k|    if (u64 <= MAX_MONEY) {
  ------------------
  |  Branch (73:9): [True: 526, False: 1.19k]
  ------------------
   74|    526|        const uint64_t compressed_money_amount = CompressAmount(u64);
   75|    526|        assert(u64 == DecompressAmount(compressed_money_amount));
   76|    526|        static const uint64_t compressed_money_amount_max = CompressAmount(MAX_MONEY - 1);
   77|    526|        assert(compressed_money_amount <= compressed_money_amount_max);
   78|  1.19k|    } else {
   79|  1.19k|        (void)CompressAmount(u64);
   80|  1.19k|    }
   81|  1.72k|    constexpr uint256 u256_min{"0000000000000000000000000000000000000000000000000000000000000000"};
   82|  1.72k|    constexpr uint256 u256_max{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"};
   83|  1.72k|    const std::vector<uint256> v256{u256, u256_min, u256_max};
   84|  1.72k|    (void)ComputeMerkleRoot(v256);
   85|  1.72k|    (void)DecompressAmount(u64);
   86|  1.72k|    {
   87|  1.72k|        if (std::optional<CAmount> parsed = ParseMoney(FormatMoney(i64))) {
  ------------------
  |  Branch (87:36): [True: 156, False: 1.56k]
  ------------------
   88|    156|            assert(parsed.value() == i64);
   89|    156|        }
   90|  1.72k|    }
   91|  1.72k|    (void)GetSizeOfCompactSize(u64);
   92|  1.72k|    (void)GetSpecialScriptSize(u32);
   93|  1.72k|    if (!MultiplicationOverflow(i64, static_cast<int64_t>(u32)) && !AdditionOverflow(i64, static_cast<int64_t>(4)) && !AdditionOverflow(i64 * u32, static_cast<int64_t>(4))) {
  ------------------
  |  Branch (93:9): [True: 1.20k, False: 517]
  |  Branch (93:68): [True: 1.19k, False: 10]
  |  Branch (93:119): [True: 1.19k, False: 2]
  ------------------
   94|  1.19k|        (void)GetVirtualTransactionSize(i64, i64, u32);
   95|  1.19k|    }
   96|  1.72k|    (void)HexDigit(ch);
   97|  1.72k|    (void)MoneyRange(i64);
   98|  1.72k|    (void)ToString(i64);
   99|  1.72k|    (void)IsDigit(ch);
  100|  1.72k|    (void)IsSpace(ch);
  101|  1.72k|    (void)IsSwitchChar(ch);
  102|  1.72k|    (void)memusage::DynamicUsage(ch);
  103|  1.72k|    (void)memusage::DynamicUsage(i16);
  104|  1.72k|    (void)memusage::DynamicUsage(i32);
  105|  1.72k|    (void)memusage::DynamicUsage(i64);
  106|  1.72k|    (void)memusage::DynamicUsage(i8);
  107|  1.72k|    (void)memusage::DynamicUsage(u16);
  108|  1.72k|    (void)memusage::DynamicUsage(u32);
  109|  1.72k|    (void)memusage::DynamicUsage(u64);
  110|  1.72k|    (void)memusage::DynamicUsage(u8);
  111|  1.72k|    const unsigned char uch = static_cast<unsigned char>(u8);
  112|  1.72k|    (void)memusage::DynamicUsage(uch);
  113|  1.72k|    {
  114|  1.72k|        const std::set<int64_t> i64s{i64, static_cast<int64_t>(u64)};
  115|  1.72k|        const size_t dynamic_usage = memusage::DynamicUsage(i64s);
  116|  1.72k|        const size_t incremental_dynamic_usage = memusage::IncrementalDynamicUsage(i64s);
  117|  1.72k|        assert(dynamic_usage == incremental_dynamic_usage * i64s.size());
  118|  1.72k|    }
  119|  1.72k|    (void)MillisToTimeval(i64);
  120|  1.72k|    (void)SighashToStr(uch);
  121|  1.72k|    (void)SipHashUint256(u64, u64, u256);
  122|  1.72k|    (void)SipHashUint256Extra(u64, u64, u256, u32);
  123|  1.72k|    (void)ToLower(ch);
  124|  1.72k|    (void)ToUpper(ch);
  125|  1.72k|    {
  126|  1.72k|        if (std::optional<CAmount> parsed = ParseMoney(ValueFromAmount(i64).getValStr())) {
  ------------------
  |  Branch (126:36): [True: 156, False: 1.56k]
  ------------------
  127|    156|            assert(parsed.value() == i64);
  128|    156|        }
  129|  1.72k|    }
  130|  1.72k|    if (i32 >= 0 && i32 <= 16) {
  ------------------
  |  Branch (130:9): [True: 100, False: 1.62k]
  |  Branch (130:21): [True: 8, False: 92]
  ------------------
  131|      8|        assert(i32 == CScript::DecodeOP_N(CScript::EncodeOP_N(i32)));
  132|      8|    }
  133|       |
  134|  1.72k|    const std::chrono::seconds seconds{i64};
  135|  1.72k|    assert(count_seconds(seconds) == i64);
  136|       |
  137|  1.72k|    const CScriptNum script_num{i64};
  138|  1.72k|    (void)script_num.getint();
  139|  1.72k|    (void)script_num.getvch();
  140|       |
  141|  1.72k|    const arith_uint256 au256 = UintToArith256(u256);
  142|  1.72k|    assert(ArithToUint256(au256) == u256);
  143|  1.72k|    assert(uint256::FromHex(au256.GetHex()).value() == u256);
  144|  1.72k|    (void)au256.bits();
  145|  1.72k|    (void)au256.GetCompact(/* fNegative= */ false);
  146|  1.72k|    (void)au256.GetCompact(/* fNegative= */ true);
  147|  1.72k|    (void)au256.getdouble();
  148|  1.72k|    (void)au256.GetHex();
  149|  1.72k|    (void)au256.GetLow64();
  150|  1.72k|    (void)au256.size();
  151|  1.72k|    (void)au256.ToString();
  152|       |
  153|  1.72k|    const CKeyID key_id{u160};
  154|  1.72k|    const CScriptID script_id{u160};
  155|       |
  156|  1.72k|    {
  157|  1.72k|        DataStream stream{};
  158|       |
  159|  1.72k|        uint256 deserialized_u256;
  160|  1.72k|        stream << u256;
  161|  1.72k|        stream >> deserialized_u256;
  162|  1.72k|        assert(u256 == deserialized_u256 && stream.empty());
  163|       |
  164|  1.72k|        uint160 deserialized_u160;
  165|  1.72k|        stream << u160;
  166|  1.72k|        stream >> deserialized_u160;
  167|  1.72k|        assert(u160 == deserialized_u160 && stream.empty());
  168|       |
  169|  1.72k|        uint64_t deserialized_u64;
  170|  1.72k|        stream << u64;
  171|  1.72k|        stream >> deserialized_u64;
  172|  1.72k|        assert(u64 == deserialized_u64 && stream.empty());
  173|       |
  174|  1.72k|        int64_t deserialized_i64;
  175|  1.72k|        stream << i64;
  176|  1.72k|        stream >> deserialized_i64;
  177|  1.72k|        assert(i64 == deserialized_i64 && stream.empty());
  178|       |
  179|  1.72k|        uint32_t deserialized_u32;
  180|  1.72k|        stream << u32;
  181|  1.72k|        stream >> deserialized_u32;
  182|  1.72k|        assert(u32 == deserialized_u32 && stream.empty());
  183|       |
  184|  1.72k|        int32_t deserialized_i32;
  185|  1.72k|        stream << i32;
  186|  1.72k|        stream >> deserialized_i32;
  187|  1.72k|        assert(i32 == deserialized_i32 && stream.empty());
  188|       |
  189|  1.72k|        uint16_t deserialized_u16;
  190|  1.72k|        stream << u16;
  191|  1.72k|        stream >> deserialized_u16;
  192|  1.72k|        assert(u16 == deserialized_u16 && stream.empty());
  193|       |
  194|  1.72k|        int16_t deserialized_i16;
  195|  1.72k|        stream << i16;
  196|  1.72k|        stream >> deserialized_i16;
  197|  1.72k|        assert(i16 == deserialized_i16 && stream.empty());
  198|       |
  199|  1.72k|        uint8_t deserialized_u8;
  200|  1.72k|        stream << u8;
  201|  1.72k|        stream >> deserialized_u8;
  202|  1.72k|        assert(u8 == deserialized_u8 && stream.empty());
  203|       |
  204|  1.72k|        int8_t deserialized_i8;
  205|  1.72k|        stream << i8;
  206|  1.72k|        stream >> deserialized_i8;
  207|  1.72k|        assert(i8 == deserialized_i8 && stream.empty());
  208|       |
  209|  1.72k|        bool deserialized_b;
  210|  1.72k|        stream << b;
  211|  1.72k|        stream >> deserialized_b;
  212|  1.72k|        assert(b == deserialized_b && stream.empty());
  213|  1.72k|    }
  214|       |
  215|  1.72k|    {
  216|  1.72k|        const ServiceFlags service_flags = (ServiceFlags)u64;
  217|  1.72k|        (void)MayHaveUsefulAddressDB(service_flags);
  218|  1.72k|    }
  219|       |
  220|  1.72k|    {
  221|  1.72k|        DataStream stream{};
  222|       |
  223|  1.72k|        ser_writedata64(stream, u64);
  224|  1.72k|        const uint64_t deserialized_u64 = ser_readdata64(stream);
  225|  1.72k|        assert(u64 == deserialized_u64 && stream.empty());
  226|       |
  227|  1.72k|        ser_writedata32(stream, u32);
  228|  1.72k|        const uint32_t deserialized_u32 = ser_readdata32(stream);
  229|  1.72k|        assert(u32 == deserialized_u32 && stream.empty());
  230|       |
  231|  1.72k|        ser_writedata32be(stream, u32);
  232|  1.72k|        const uint32_t deserialized_u32be = ser_readdata32be(stream);
  233|  1.72k|        assert(u32 == deserialized_u32be && stream.empty());
  234|       |
  235|  1.72k|        ser_writedata16(stream, u16);
  236|  1.72k|        const uint16_t deserialized_u16 = ser_readdata16(stream);
  237|  1.72k|        assert(u16 == deserialized_u16 && stream.empty());
  238|       |
  239|  1.72k|        ser_writedata16be(stream, u16);
  240|  1.72k|        const uint16_t deserialized_u16be = ser_readdata16be(stream);
  241|  1.72k|        assert(u16 == deserialized_u16be && stream.empty());
  242|       |
  243|  1.72k|        ser_writedata8(stream, u8);
  244|  1.72k|        const uint8_t deserialized_u8 = ser_readdata8(stream);
  245|  1.72k|        assert(u8 == deserialized_u8 && stream.empty());
  246|  1.72k|    }
  247|       |
  248|  1.72k|    {
  249|  1.72k|        DataStream stream{};
  250|       |
  251|  1.72k|        WriteCompactSize(stream, u64);
  252|  1.72k|        try {
  253|  1.72k|            const uint64_t deserialized_u64 = ReadCompactSize(stream);
  254|  1.72k|            assert(u64 == deserialized_u64 && stream.empty());
  255|  1.72k|        } catch (const std::ios_base::failure&) {
  256|  1.46k|        }
  257|  1.72k|    }
  258|       |
  259|  1.72k|    try {
  260|  1.72k|        CHECK_NONFATAL(b);
  ------------------
  |  |   82|  1.72k|    inline_check_non_fatal(condition, __FILE__, __LINE__, __func__, #condition)
  ------------------
  261|  1.72k|    } catch (const NonFatalCheckError&) {
  262|  1.64k|    }
  263|  1.72k|}

_Z22MultiplicationOverflowIlEbT_S0_:
  209|  1.72k|{
  210|  1.72k|    static_assert(std::is_integral<T>::value, "Integral required.");
  211|  1.72k|    if (std::numeric_limits<T>::is_signed) {
  ------------------
  |  Branch (211:9): [Folded - Ignored]
  ------------------
  212|  1.72k|        if (i > 0) {
  ------------------
  |  Branch (212:13): [True: 544, False: 1.17k]
  ------------------
  213|    544|            if (j > 0) {
  ------------------
  |  Branch (213:17): [True: 329, False: 215]
  ------------------
  214|    329|                return i > (std::numeric_limits<T>::max() / j);
  215|    329|            } else {
  216|    215|                return j < (std::numeric_limits<T>::min() / i);
  217|    215|            }
  218|  1.17k|        } else {
  219|  1.17k|            if (j > 0) {
  ------------------
  |  Branch (219:17): [True: 410, False: 768]
  ------------------
  220|    410|                return i < (std::numeric_limits<T>::min() / j);
  221|    768|            } else {
  222|    768|                return i != 0 && (j < (std::numeric_limits<T>::max() / i));
  ------------------
  |  Branch (222:24): [True: 767, False: 1]
  |  Branch (222:34): [True: 0, False: 767]
  ------------------
  223|    768|            }
  224|  1.17k|        }
  225|  1.72k|    } else {
  226|      0|        return j != 0 && i > std::numeric_limits<T>::max() / j;
  ------------------
  |  Branch (226:16): [True: 0, False: 0]
  |  Branch (226:26): [True: 0, False: 0]
  ------------------
  227|      0|    }
  228|  1.72k|}

_ZN12CheckGlobalsC2Ev:
   56|  1.73k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|  1.73k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  1.73k|    {
   18|  1.73k|        g_used_g_prng = false;
   19|  1.73k|        g_seeded_g_prng_zero = false;
   20|  1.73k|        g_used_system_time = false;
   21|  1.73k|        SetMockTime(0s);
   22|  1.73k|    }
_ZN16CheckGlobalsImplD2Ev:
   24|  1.73k|    {
   25|  1.73k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 0, False: 1.73k]
  |  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|  1.73k|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 1.73k]
  ------------------
   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|  1.73k|    }

_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|  20.1k|        {
  542|  20.1k|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|  20.1k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  543|  20.1k|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|  20.1k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  544|  20.1k|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|  20.1k|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|  5.09k|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|  3.44k|{
  579|  3.44k|    int i = 0;
  580|  10.3k|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 10.3k, False: 0]
  |  Branch (580:24): [True: 6.88k, False: 3.44k]
  ------------------
  581|  6.88k|        i = 10*i + (*c - '0');
  582|  3.44k|    return i;
  583|  3.44k|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|  16.6k|{
  594|  16.6k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 16.6k, False: 0]
  |  Branch (594:22): [True: 0, False: 16.6k]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|  16.6k|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 16.6k]
  ------------------
  598|      0|        ++c;
  599|      0|        n = 0;
  600|      0|        if (positionalMode) {
  ------------------
  |  Branch (600:13): [True: 0, False: 0]
  ------------------
  601|      0|            int pos = parseIntAndAdvance(c) - 1;
  602|      0|            if (*c != '$')
  ------------------
  |  Branch (602:17): [True: 0, False: 0]
  ------------------
  603|      0|                TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  604|      0|            if (pos >= 0 && pos < numArgs)
  ------------------
  |  Branch (604:17): [True: 0, False: 0]
  |  Branch (604:29): [True: 0, False: 0]
  ------------------
  605|      0|                n = args[pos].toInt();
  606|      0|            else
  607|      0|                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  608|      0|            ++c;
  609|      0|        }
  610|      0|        else {
  611|      0|            if (argIndex < numArgs)
  ------------------
  |  Branch (611:17): [True: 0, False: 0]
  ------------------
  612|      0|                n = args[argIndex++].toInt();
  613|      0|            else
  614|      0|                TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  615|      0|        }
  616|      0|    }
  617|  16.6k|    else {
  618|  16.6k|        return false;
  619|  16.6k|    }
  620|      0|    return true;
  621|  16.6k|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|  25.2k|{
  630|  25.2k|    const char* c = fmt;
  631|   132k|    for (;; ++c) {
  632|   132k|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 5.09k, False: 127k]
  ------------------
  633|  5.09k|            out.write(fmt, c - fmt);
  634|  5.09k|            return c;
  635|  5.09k|        }
  636|   127k|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 20.1k, False: 107k]
  ------------------
  637|  20.1k|            out.write(fmt, c - fmt);
  638|  20.1k|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 20.1k, False: 0]
  ------------------
  639|  20.1k|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|   132k|    }
  644|  25.2k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|  20.1k|{
  686|  20.1k|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|  20.1k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  687|       |    // Reset stream state to defaults.
  688|  20.1k|    out.width(0);
  689|  20.1k|    out.precision(6);
  690|  20.1k|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|  20.1k|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|  20.1k|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|  20.1k|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|  20.1k|    bool precisionSet = false;
  696|  20.1k|    bool widthSet = false;
  697|  20.1k|    int widthExtra = 0;
  698|  20.1k|    const char* c = fmtStart + 1;
  699|       |
  700|       |    // 1) Parse an argument index (if followed by '$') or a width possibly
  701|       |    // preceded with '0' flag.
  702|  20.1k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 20.1k, False: 0]
  |  Branch (702:22): [True: 3.44k, False: 16.6k]
  ------------------
  703|  3.44k|        const char tmpc = *c;
  704|  3.44k|        int value = parseIntAndAdvance(c);
  705|  3.44k|        if (*c == '$') {
  ------------------
  |  Branch (705:13): [True: 0, False: 3.44k]
  ------------------
  706|       |            // value is an argument index
  707|      0|            if (value > 0 && value <= numArgs)
  ------------------
  |  Branch (707:17): [True: 0, False: 0]
  |  Branch (707:30): [True: 0, False: 0]
  ------------------
  708|      0|                argIndex = value - 1;
  709|      0|            else
  710|      0|                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  711|      0|            ++c;
  712|      0|            positionalMode = true;
  713|      0|        }
  714|  3.44k|        else if (positionalMode) {
  ------------------
  |  Branch (714:18): [True: 0, False: 3.44k]
  ------------------
  715|      0|            TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  716|      0|        }
  717|  3.44k|        else {
  718|  3.44k|            if (tmpc == '0') {
  ------------------
  |  Branch (718:17): [True: 3.44k, False: 0]
  ------------------
  719|       |                // Use internal padding so that numeric values are
  720|       |                // formatted correctly, eg -00010 rather than 000-10
  721|  3.44k|                out.fill('0');
  722|  3.44k|                out.setf(std::ios::internal, std::ios::adjustfield);
  723|  3.44k|            }
  724|  3.44k|            if (value != 0) {
  ------------------
  |  Branch (724:17): [True: 3.44k, False: 0]
  ------------------
  725|       |                // Nonzero value means that we parsed width.
  726|  3.44k|                widthSet = true;
  727|  3.44k|                out.width(value);
  728|  3.44k|            }
  729|  3.44k|        }
  730|  3.44k|    }
  731|  16.6k|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 16.6k]
  ------------------
  732|      0|        TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  733|      0|    }
  734|       |    // 2) Parse flags and width if we did not do it in previous step.
  735|  20.1k|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 16.6k, False: 3.44k]
  ------------------
  736|       |        // Parse flags
  737|  16.6k|        for (;; ++c) {
  738|  16.6k|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 16.6k]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 16.6k]
  ------------------
  743|       |                    // overridden by left alignment ('-' flag)
  744|      0|                    if (!(out.flags() & std::ios::left)) {
  ------------------
  |  Branch (744:25): [True: 0, False: 0]
  ------------------
  745|       |                        // Use internal padding so that numeric values are
  746|       |                        // formatted correctly, eg -00010 rather than 000-10
  747|      0|                        out.fill('0');
  748|      0|                        out.setf(std::ios::internal, std::ios::adjustfield);
  749|      0|                    }
  750|      0|                    continue;
  751|      0|                case '-':
  ------------------
  |  Branch (751:17): [True: 0, False: 16.6k]
  ------------------
  752|      0|                    out.fill(' ');
  753|      0|                    out.setf(std::ios::left, std::ios::adjustfield);
  754|      0|                    continue;
  755|      0|                case ' ':
  ------------------
  |  Branch (755:17): [True: 0, False: 16.6k]
  ------------------
  756|       |                    // overridden by show positive sign, '+' flag.
  757|      0|                    if (!(out.flags() & std::ios::showpos))
  ------------------
  |  Branch (757:25): [True: 0, False: 0]
  ------------------
  758|      0|                        spacePadPositive = true;
  759|      0|                    continue;
  760|      0|                case '+':
  ------------------
  |  Branch (760:17): [True: 0, False: 16.6k]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|  16.6k|                default:
  ------------------
  |  Branch (765:17): [True: 16.6k, False: 0]
  ------------------
  766|  16.6k|                    break;
  767|  16.6k|            }
  768|  16.6k|            break;
  769|  16.6k|        }
  770|       |        // Parse width
  771|  16.6k|        int width = 0;
  772|  16.6k|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|  16.6k|                                         args, argIndex, numArgs);
  774|  16.6k|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 16.6k]
  ------------------
  775|      0|            if (width < 0) {
  ------------------
  |  Branch (775:17): [True: 0, False: 0]
  ------------------
  776|       |                // negative widths correspond to '-' flag set
  777|      0|                out.fill(' ');
  778|      0|                out.setf(std::ios::left, std::ios::adjustfield);
  779|      0|                width = -width;
  780|      0|            }
  781|      0|            out.width(width);
  782|      0|        }
  783|  16.6k|    }
  784|       |    // 3) Parse precision
  785|  20.1k|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 20.1k]
  ------------------
  786|      0|        ++c;
  787|      0|        int precision = 0;
  788|      0|        parseWidthOrPrecision(precision, c, positionalMode,
  789|      0|                              args, argIndex, numArgs);
  790|       |        // Presence of `.` indicates precision set, unless the inferred value
  791|       |        // was negative in which case the default is used.
  792|      0|        precisionSet = precision >= 0;
  793|      0|        if (precisionSet)
  ------------------
  |  Branch (793:13): [True: 0, False: 0]
  ------------------
  794|      0|            out.precision(precision);
  795|      0|    }
  796|       |    // 4) Ignore any C99 length modifier
  797|  20.1k|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 20.1k]
  |  Branch (797:25): [True: 0, False: 20.1k]
  |  Branch (797:38): [True: 0, False: 20.1k]
  ------------------
  798|  20.1k|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 20.1k]
  |  Branch (798:25): [True: 0, False: 20.1k]
  |  Branch (798:38): [True: 0, False: 20.1k]
  ------------------
  799|      0|        ++c;
  800|      0|    }
  801|       |    // 5) We're up to the conversion specifier character.
  802|       |    // Set stream flags based on conversion specifier (thanks to the
  803|       |    // boost::format class for forging the way here).
  804|  20.1k|    bool intConversion = false;
  805|  20.1k|    switch (*c) {
  806|  8.53k|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 0, False: 20.1k]
  |  Branch (806:19): [True: 8.53k, False: 11.6k]
  |  Branch (806:29): [True: 0, False: 20.1k]
  ------------------
  807|  8.53k|            out.setf(std::ios::dec, std::ios::basefield);
  808|  8.53k|            intConversion = true;
  809|  8.53k|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 20.1k]
  ------------------
  811|      0|            out.setf(std::ios::oct, std::ios::basefield);
  812|      0|            intConversion = true;
  813|      0|            break;
  814|      0|        case 'X':
  ------------------
  |  Branch (814:9): [True: 0, False: 20.1k]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|      0|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 0, False: 20.1k]
  |  Branch (817:19): [True: 0, False: 20.1k]
  ------------------
  818|      0|            out.setf(std::ios::hex, std::ios::basefield);
  819|      0|            intConversion = true;
  820|      0|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 20.1k]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 20.1k]
  ------------------
  825|      0|            out.setf(std::ios::scientific, std::ios::floatfield);
  826|      0|            out.setf(std::ios::dec, std::ios::basefield);
  827|      0|            break;
  828|      0|        case 'F':
  ------------------
  |  Branch (828:9): [True: 0, False: 20.1k]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 20.1k]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 20.1k]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 20.1k]
  ------------------
  838|       |#           ifdef _MSC_VER
  839|       |            // Workaround https://developercommunity.visualstudio.com/content/problem/520472/hexfloat-stream-output-does-not-ignore-precision-a.html
  840|       |            // by always setting maximum precision on MSVC to avoid precision
  841|       |            // loss for doubles.
  842|       |            out.precision(13);
  843|       |#           endif
  844|      0|            out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield);
  845|      0|            break;
  846|      0|        case 'G':
  ------------------
  |  Branch (846:9): [True: 0, False: 20.1k]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 20.1k]
  ------------------
  850|      0|            out.setf(std::ios::dec, std::ios::basefield);
  851|       |            // As in boost::format, let stream decide float format.
  852|      0|            out.flags(out.flags() & ~std::ios::floatfield);
  853|      0|            break;
  854|      0|        case 'c':
  ------------------
  |  Branch (854:9): [True: 0, False: 20.1k]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|  11.6k|        case 's':
  ------------------
  |  Branch (857:9): [True: 11.6k, False: 8.53k]
  ------------------
  858|  11.6k|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 11.6k]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|  11.6k|            out.setf(std::ios::boolalpha);
  862|  11.6k|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 20.1k]
  ------------------
  864|       |            // Not supported - will cause problems!
  865|      0|            TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  866|      0|            break;
  867|      0|        case '\0':
  ------------------
  |  Branch (867:9): [True: 0, False: 20.1k]
  ------------------
  868|      0|            TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  869|      0|                             "terminated by end of string");
  870|      0|            return c;
  871|      0|        default:
  ------------------
  |  Branch (871:9): [True: 0, False: 20.1k]
  ------------------
  872|      0|            break;
  873|  20.1k|    }
  874|  20.1k|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 8.53k, False: 11.6k]
  |  Branch (874:26): [True: 0, False: 8.53k]
  |  Branch (874:42): [True: 0, False: 0]
  ------------------
  875|       |        // "precision" for integers gives the minimum number of digits (to be
  876|       |        // padded with zeros on the left).  This isn't really supported by the
  877|       |        // iostreams, but we can approximately simulate it with the width if
  878|       |        // the width isn't otherwise used.
  879|      0|        out.width(out.precision() + widthExtra);
  880|      0|        out.setf(std::ios::internal, std::ios::adjustfield);
  881|      0|        out.fill('0');
  882|      0|    }
  883|  20.1k|    return c+1;
  884|  20.1k|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|  5.09k|{
  892|       |    // Saved stream state
  893|  5.09k|    std::streamsize origWidth = out.width();
  894|  5.09k|    std::streamsize origPrecision = out.precision();
  895|  5.09k|    std::ios::fmtflags origFlags = out.flags();
  896|  5.09k|    char origFill = out.fill();
  897|       |
  898|       |    // "Positional mode" means all format specs should be of the form "%n$..."
  899|       |    // with `n` an integer. We detect this in `streamStateFromFormat`.
  900|  5.09k|    bool positionalMode = false;
  901|  5.09k|    int argIndex = 0;
  902|  25.2k|    while (true) {
  ------------------
  |  Branch (902:12): [Folded - Ignored]
  ------------------
  903|  25.2k|        fmt = printFormatStringLiteral(out, fmt);
  904|  25.2k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 5.09k, False: 20.1k]
  ------------------
  905|  5.09k|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 5.09k, False: 0]
  |  Branch (905:36): [True: 0, False: 5.09k]
  ------------------
  906|      0|                TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  907|      0|            }
  908|  5.09k|            break;
  909|  5.09k|        }
  910|  20.1k|        bool spacePadPositive = false;
  911|  20.1k|        int ntrunc = -1;
  912|  20.1k|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|  20.1k|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|  20.1k|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 20.1k]
  ------------------
  917|      0|            TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  918|      0|            return;
  919|      0|        }
  920|  20.1k|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|  20.1k|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 20.1k, False: 0]
  ------------------
  923|  20.1k|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|  20.1k|        }
  925|      0|        else {
  926|       |            // The following is a special case with no direct correspondence
  927|       |            // between stream formatting and the printf() behaviour.  Simulate
  928|       |            // it crudely by formatting into a temporary string stream and
  929|       |            // munging the resulting string.
  930|      0|            std::ostringstream tmpStream;
  931|      0|            tmpStream.copyfmt(out);
  932|      0|            tmpStream.setf(std::ios::showpos);
  933|      0|            arg.format(tmpStream, fmt, fmtEnd, ntrunc);
  934|      0|            std::string result = tmpStream.str(); // allocates... yuck.
  935|      0|            for (size_t i = 0, iend = result.size(); i < iend; ++i) {
  ------------------
  |  Branch (935:54): [True: 0, False: 0]
  ------------------
  936|      0|                if (result[i] == '+')
  ------------------
  |  Branch (936:21): [True: 0, False: 0]
  ------------------
  937|      0|                    result[i] = ' ';
  938|      0|            }
  939|      0|            out << result;
  940|      0|        }
  941|  20.1k|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 20.1k, False: 0]
  ------------------
  942|  20.1k|            ++argIndex;
  943|  20.1k|        fmt = fmtEnd;
  944|  20.1k|    }
  945|       |
  946|       |    // Restore stream state
  947|  5.09k|    out.width(origWidth);
  948|  5.09k|    out.precision(origPrecision);
  949|  5.09k|    out.flags(origFlags);
  950|  5.09k|    out.fill(origFill);
  951|  5.09k|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|  5.09k|{
 1071|  5.09k|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|  5.09k|}
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|  1.64k|            : m_value(static_cast<const void*>(&value)),
  535|  1.64k|            m_formatImpl(&formatImpl<T>),
  536|  1.64k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.64k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  1.64k|        {
  559|  1.64k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.64k|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  1.64k|{
  352|  1.64k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.64k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.64k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.64k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.64k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.64k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.64k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 1.64k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.64k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.64k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.64k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.64k|    else
  378|  1.64k|        out << value;
  379|  1.64k|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|  1.72k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|  1.64k|            : m_value(static_cast<const void*>(&value)),
  535|  1.64k|            m_formatImpl(&formatImpl<T>),
  536|  1.64k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.64k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|  1.64k|        {
  559|  1.64k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.64k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|  1.64k|{
  352|  1.64k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.64k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.64k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.64k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.64k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.64k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.64k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.64k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.64k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.64k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.64k|    else
  378|  1.64k|        out << value;
  379|  1.64k|}
_ZN10tinyformat6detail9FormatArgC2IlEERKT_:
  534|  6.88k|            : m_value(static_cast<const void*>(&value)),
  535|  6.88k|            m_formatImpl(&formatImpl<T>),
  536|  6.88k|            m_toIntImpl(&toIntImpl<T>)
  537|  6.88k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  6.88k|        {
  559|  6.88k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  6.88k|        }
_ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  6.88k|{
  352|  6.88k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  6.88k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  6.88k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  6.88k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  6.88k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  6.88k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  6.88k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 6.88k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  6.88k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  6.88k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 6.88k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  6.88k|    else
  378|  6.88k|        out << value;
  379|  6.88k|}
_ZN10tinyformat6detail9FormatArgC2IPKcEERKT_:
  534|  1.72k|            : m_value(static_cast<const void*>(&value)),
  535|  1.72k|            m_formatImpl(&formatImpl<T>),
  536|  1.72k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.72k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv:
  558|  1.72k|        {
  559|  1.72k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.72k|        }
_ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_:
  351|  1.72k|{
  352|  1.72k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.72k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.72k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.72k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.72k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.72k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.72k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.72k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 1.72k]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.72k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.72k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.72k|    else
  378|  1.72k|        out << value;
  379|  1.72k|}
_ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv:
  197|  1.72k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2INSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEERKT_:
  534|  4.94k|            : m_value(static_cast<const void*>(&value)),
  535|  4.94k|            m_formatImpl(&formatImpl<T>),
  536|  4.94k|            m_toIntImpl(&toIntImpl<T>)
  537|  4.94k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSC_iPKv:
  558|  4.94k|        {
  559|  4.94k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  4.94k|        }
_ZN10tinyformat11formatValueINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSA_iRKT_:
  351|  4.94k|{
  352|  4.94k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  4.94k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  4.94k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  4.94k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  4.94k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  4.94k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  4.94k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  4.94k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  4.94k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 4.94k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  4.94k|    else
  378|  4.94k|        out << value;
  379|  4.94k|}
_ZN10tinyformat6detail9FormatArgC2IA13_cEERKT_:
  534|  1.64k|            : m_value(static_cast<const void*>(&value)),
  535|  1.64k|            m_formatImpl(&formatImpl<T>),
  536|  1.64k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.64k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIA13_cEEvRNSt3__113basic_ostreamIcNS4_11char_traitsIcEEEEPKcSB_iPKv:
  558|  1.64k|        {
  559|  1.64k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.64k|        }
_ZN10tinyformat11formatValueIA13_cEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_iRKT_:
  351|  1.64k|{
  352|  1.64k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.64k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.64k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.64k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.64k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.64k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.64k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.64k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 1.64k]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.64k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.64k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.64k|    else
  378|  1.64k|        out << value;
  379|  1.64k|}
_ZN10tinyformat6formatIJPKcllEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.72k|{
 1089|  1.72k|    std::ostringstream oss;
 1090|  1.72k|    format(oss, fmt, args...);
 1091|  1.72k|    return oss.str();
 1092|  1.72k|}
_ZN10tinyformat6formatIJPKcllEEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.72k|{
 1081|  1.72k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.72k|}
_ZN10tinyformat14makeFormatListIJPKcllEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.72k|{
 1045|  1.72k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.72k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJPKcllEEEDpRKT_:
  990|  1.72k|            : FormatList(&m_formatterStore[0], N),
  991|  1.72k|            m_formatterStore { FormatArg(args)... }
  992|  1.72k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IA42_cEERKT_:
  534|  1.64k|            : m_value(static_cast<const void*>(&value)),
  535|  1.64k|            m_formatImpl(&formatImpl<T>),
  536|  1.64k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.64k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIA42_cEEvRNSt3__113basic_ostreamIcNS4_11char_traitsIcEEEEPKcSB_iPKv:
  558|  1.64k|        {
  559|  1.64k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.64k|        }
_ZN10tinyformat11formatValueIA42_cEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_iRKT_:
  351|  1.64k|{
  352|  1.64k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  1.64k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.64k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.64k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  1.64k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.64k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.64k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.64k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 1.64k]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.64k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.64k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  1.64k|    else
  378|  1.64k|        out << value;
  379|  1.64k|}
_ZN10tinyformat6formatIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_iS5_A13_cNS1_12basic_stringIcS4_NS1_9allocatorIcEEEEA42_cEEESA_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.64k|{
 1089|  1.64k|    std::ostringstream oss;
 1090|  1.64k|    format(oss, fmt, args...);
 1091|  1.64k|    return oss.str();
 1092|  1.64k|}
_ZN10tinyformat6formatIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_iS5_A13_cNS1_12basic_stringIcS4_NS1_9allocatorIcEEEEA42_cEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.64k|{
 1081|  1.64k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.64k|}
_ZN10tinyformat17FormatStringCheckILj7EEcvPKcEv:
  197|  1.64k|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_iS5_A13_cNS1_12basic_stringIcS4_NS1_9allocatorIcEEEEA42_cEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.64k|{
 1045|  1.64k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.64k|}
_ZN10tinyformat6detail11FormatListNILi7EEC2IJNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEES8_iS8_A13_cNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEA42_cEEEDpRKT_:
  990|  1.64k|            : FormatList(&m_formatterStore[0], N),
  991|  1.64k|            m_formatterStore { FormatArg(args)... }
  992|  1.64k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJllEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.72k|{
 1089|  1.72k|    std::ostringstream oss;
 1090|  1.72k|    format(oss, fmt, args...);
 1091|  1.72k|    return oss.str();
 1092|  1.72k|}
_ZN10tinyformat6formatIJllEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.72k|{
 1081|  1.72k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.72k|}
_ZN10tinyformat14makeFormatListIJllEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.72k|{
 1045|  1.72k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.72k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJllEEEDpRKT_:
  990|  1.72k|            : FormatList(&m_formatterStore[0], N),
  991|  1.72k|            m_formatterStore { FormatArg(args)... }
  992|  1.72k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZNK9base_blobILj256EE6GetHexEv:
   12|  5.16k|{
   13|  5.16k|    uint8_t m_data_rev[WIDTH];
   14|   170k|    for (int i = 0; i < WIDTH; ++i) {
  ------------------
  |  Branch (14:21): [True: 165k, False: 5.16k]
  ------------------
   15|   165k|        m_data_rev[i] = m_data[WIDTH - 1 - i];
   16|   165k|    }
   17|  5.16k|    return HexStr(m_data_rev);
   18|  5.16k|}
_ZN9base_blobILj256EE16SetHexDeprecatedENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   22|  1.72k|{
   23|  1.72k|    std::fill(m_data.begin(), m_data.end(), 0);
   24|       |
   25|  1.72k|    const auto trimmed = util::RemovePrefixView(util::TrimStringView(str), "0x");
   26|       |
   27|       |    // Note: if we are passed a greater number of digits than would fit as bytes
   28|       |    // in m_data, we will be discarding the leftmost ones.
   29|       |    // str="12bc" in a WIDTH=1 m_data => m_data[] == "\0xbc", not "0x12".
   30|  1.72k|    size_t digits = 0;
   31|   110k|    for (const char c : trimmed) {
  ------------------
  |  Branch (31:23): [True: 110k, False: 1.72k]
  ------------------
   32|   110k|        if (::HexDigit(c) == -1) break;
  ------------------
  |  Branch (32:13): [True: 0, False: 110k]
  ------------------
   33|   110k|        ++digits;
   34|   110k|    }
   35|  1.72k|    unsigned char* p1 = m_data.data();
   36|  1.72k|    unsigned char* pend = p1 + WIDTH;
   37|  56.8k|    while (digits > 0 && p1 < pend) {
  ------------------
  |  Branch (37:12): [True: 55.1k, False: 1.72k]
  |  Branch (37:26): [True: 55.1k, False: 0]
  ------------------
   38|  55.1k|        *p1 = ::HexDigit(trimmed[--digits]);
   39|  55.1k|        if (digits > 0) {
  ------------------
  |  Branch (39:13): [True: 55.1k, False: 0]
  ------------------
   40|  55.1k|            *p1 |= ((unsigned char)::HexDigit(trimmed[--digits]) << 4);
   41|  55.1k|            p1++;
   42|  55.1k|        }
   43|  55.1k|    }
   44|  1.72k|}

_ZN7uint160C2E4SpanIKhE:
  193|  1.72k|    constexpr explicit uint160(Span<const unsigned char> vch) : base_blob<160>(vch) {}
_ZN7uint2567FromHexENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  203|  1.72k|    static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
_ZN7uint256C2E4SpanIKhE:
  208|  1.72k|    constexpr explicit uint256(Span<const unsigned char> vch) : base_blob<256>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|  61.9k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE5beginEv:
  118|  15.7k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  121|  1.72k|    static constexpr unsigned int size() { return WIDTH; }
_ZNK9base_blobILj256EE7CompareERKS0_:
   64|  5.16k|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZeqRK9base_blobILj256EES2_:
   66|  5.16k|    friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
_ZN6detail7FromHexI7uint256EENSt3__18optionalIT_EENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
  158|  1.72k|{
  159|  1.72k|    if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
  ------------------
  |  Branch (159:9): [True: 0, False: 1.72k]
  |  Branch (159:46): [True: 0, False: 1.72k]
  ------------------
  160|  1.72k|    uintN_t rv;
  161|  1.72k|    rv.SetHexDeprecated(str);
  162|  1.72k|    return rv;
  163|  1.72k|}
_ZN7uint256C2Ev:
  205|  5.16k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|  10.3k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EEC2E4SpanIKhE:
   41|  1.72k|    {
   42|  1.72k|        assert(vch.size() == WIDTH);
   43|  1.72k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|  1.72k|    }
_ZNK9base_blobILj160EE7CompareERKS0_:
   64|  1.72k|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|  1.72k|    {
  134|  1.72k|        s.read(MakeWritableByteSpan(m_data));
  135|  1.72k|    }
_ZNK9base_blobILj256EE9GetUint64Ei:
  123|  13.7k|    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
_ZN7uint160C2Ev:
  192|  1.72k|    constexpr uint160() = default;
_ZN9base_blobILj160EEC2Ev:
   35|  1.72k|    constexpr base_blob() : m_data() {}
_ZNK9base_blobILj256EE9SerializeI10DataStreamEEvRT_:
  127|  1.72k|    {
  128|  1.72k|        s << Span(m_data);
  129|  1.72k|    }
_ZN9base_blobILj160EEC2E4SpanIKhE:
   41|  1.72k|    {
   42|  1.72k|        assert(vch.size() == WIDTH);
   43|  1.72k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|  1.72k|    }
_ZN9base_blobILj160EE11UnserializeI10DataStreamEEvRT_:
  133|  1.72k|    {
  134|  1.72k|        s.read(MakeWritableByteSpan(m_data));
  135|  1.72k|    }
_ZNK9base_blobILj160EE9SerializeI10DataStreamEEvRT_:
  127|  1.72k|    {
  128|  1.72k|        s << Span(m_data);
  129|  1.72k|    }
_ZeqRK9base_blobILj160EES2_:
   66|  1.72k|    friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }

_ZN8UniValueC2ENS_5VTypeENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   32|  1.72k|    UniValue(UniValue::VType type, std::string str = {}) : typ{type}, val{std::move(str)} {}
_ZNK8UniValue9getValStrEv:
   68|  1.72k|    const std::string& getValStr() const { return val; }

_Z20StrFormatInternalBugNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_iS3_:
   18|  1.64k|{
   19|  1.64k|    return strprintf("Internal bug detected: %s\n%s:%d (%s)\n"
  ------------------
  |  | 1172|  1.64k|#define strprintf tfm::format
  ------------------
   20|  1.64k|                     "%s %s\n"
   21|  1.64k|                     "Please report this issue here: %s\n",
   22|  1.64k|                     msg, file, line, func, CLIENT_NAME, FormatFullVersion(), CLIENT_BUGREPORT);
  ------------------
  |  |  127|  1.64k|#define CLIENT_NAME "Bitcoin Core"
  ------------------
                                   msg, file, line, func, CLIENT_NAME, FormatFullVersion(), CLIENT_BUGREPORT);
  ------------------
  |  |  124|  1.64k|#define CLIENT_BUGREPORT "https://github.com/bitcoin/bitcoin/issues"
  ------------------
   23|  1.64k|}
_ZN18NonFatalCheckErrorC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_iS4_:
   26|  1.64k|    : std::runtime_error{StrFormatInternalBug(msg, file, line, func)}
   27|  1.64k|{
   28|  1.64k|}

_Z22inline_check_non_fatalIRKbEOT_S3_PKciS5_S5_:
   35|  1.72k|{
   36|  1.72k|    if (!val) {
  ------------------
  |  Branch (36:9): [True: 1.64k, False: 75]
  ------------------
   37|  1.64k|        throw NonFatalCheckError{assertion, file, line, func};
   38|  1.64k|    }
   39|     75|    return std::forward<T>(val);
   40|  1.72k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  1.73k|{
   53|  1.73k|    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.73k|    ) {
   58|  1.73k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.73k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.73k|    }
   62|  1.73k|    return std::forward<T>(val);
   63|  1.73k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  1.73k|{
   53|  1.73k|    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.73k|    ) {
   58|  1.73k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.73k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.73k|    }
   62|  1.73k|    return std::forward<T>(val);
   63|  1.73k|}

_ZN8BaseHashI7uint160EC2ERKS0_:
   16|  1.72k|    explicit BaseHash(const HashType& in) : m_hash(in) {}

_Z11FormatMoneyl:
   20|  1.72k|{
   21|       |    // Note: not using straight sprintf here because we do NOT want
   22|       |    // localized number formatting.
   23|  1.72k|    static_assert(COIN > 1);
   24|  1.72k|    int64_t quotient = n / COIN;
   25|  1.72k|    int64_t remainder = n % COIN;
   26|  1.72k|    if (n < 0) {
  ------------------
  |  Branch (26:9): [True: 1.17k, False: 546]
  ------------------
   27|  1.17k|        quotient = -quotient;
   28|  1.17k|        remainder = -remainder;
   29|  1.17k|    }
   30|  1.72k|    std::string str = strprintf("%d.%08d", quotient, remainder);
  ------------------
  |  | 1172|  1.72k|#define strprintf tfm::format
  ------------------
   31|       |
   32|       |    // Right-trim excess zeros before the decimal point:
   33|  1.72k|    int nTrim = 0;
   34|  1.96k|    for (int i = str.size()-1; (str[i] == '0' && IsDigit(str[i-2])); --i)
  ------------------
  |  Branch (34:33): [True: 244, False: 1.71k]
  |  Branch (34:50): [True: 240, False: 4]
  ------------------
   35|    240|        ++nTrim;
   36|  1.72k|    if (nTrim)
  ------------------
  |  Branch (36:9): [True: 161, False: 1.56k]
  ------------------
   37|    161|        str.erase(str.size()-nTrim, nTrim);
   38|       |
   39|  1.72k|    if (n < 0)
  ------------------
  |  Branch (39:9): [True: 1.17k, False: 546]
  ------------------
   40|  1.17k|        str.insert(uint32_t{0}, 1, '-');
   41|  1.72k|    return str;
   42|  1.72k|}
_Z10ParseMoneyRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
   46|  3.44k|{
   47|  3.44k|    if (!ContainsNoNUL(money_string)) {
  ------------------
  |  Branch (47:9): [True: 0, False: 3.44k]
  ------------------
   48|      0|        return std::nullopt;
   49|      0|    }
   50|  3.44k|    const std::string str = TrimString(money_string);
   51|  3.44k|    if (str.empty()) {
  ------------------
  |  Branch (51:9): [True: 0, False: 3.44k]
  ------------------
   52|      0|        return std::nullopt;
   53|      0|    }
   54|       |
   55|  3.44k|    std::string strWhole;
   56|  3.44k|    int64_t nUnits = 0;
   57|  3.44k|    const char* p = str.c_str();
   58|  13.2k|    for (; *p; p++)
  ------------------
  |  Branch (58:12): [True: 13.2k, False: 0]
  ------------------
   59|  13.2k|    {
   60|  13.2k|        if (*p == '.')
  ------------------
  |  Branch (60:13): [True: 1.09k, False: 12.1k]
  ------------------
   61|  1.09k|        {
   62|  1.09k|            p++;
   63|  1.09k|            int64_t nMult = COIN / 10;
   64|  9.70k|            while (IsDigit(*p) && (nMult > 0))
  ------------------
  |  Branch (64:20): [True: 8.61k, False: 1.09k]
  |  Branch (64:35): [True: 8.61k, False: 0]
  ------------------
   65|  8.61k|            {
   66|  8.61k|                nUnits += nMult * (*p++ - '0');
   67|  8.61k|                nMult /= 10;
   68|  8.61k|            }
   69|  1.09k|            break;
   70|  1.09k|        }
   71|  12.1k|        if (IsSpace(*p))
  ------------------
  |  Branch (71:13): [True: 0, False: 12.1k]
  ------------------
   72|      0|            return std::nullopt;
   73|  12.1k|        if (!IsDigit(*p))
  ------------------
  |  Branch (73:13): [True: 2.35k, False: 9.80k]
  ------------------
   74|  2.35k|            return std::nullopt;
   75|  9.80k|        strWhole.insert(strWhole.end(), *p);
   76|  9.80k|    }
   77|  1.09k|    if (*p) {
  ------------------
  |  Branch (77:9): [True: 0, False: 1.09k]
  ------------------
   78|      0|        return std::nullopt;
   79|      0|    }
   80|  1.09k|    if (strWhole.size() > 10) // guard against 63 bit overflow
  ------------------
  |  Branch (80:9): [True: 602, False: 490]
  ------------------
   81|    602|        return std::nullopt;
   82|    490|    if (nUnits < 0 || nUnits > COIN)
  ------------------
  |  Branch (82:9): [True: 0, False: 490]
  |  Branch (82:23): [True: 0, False: 490]
  ------------------
   83|      0|        return std::nullopt;
   84|    490|    int64_t nWhole = LocaleIndependentAtoi<int64_t>(strWhole);
   85|    490|    CAmount value = nWhole * COIN + nUnits;
   86|       |
   87|    490|    if (!MoneyRange(value)) {
  ------------------
  |  Branch (87:9): [True: 178, False: 312]
  ------------------
   88|    178|        return std::nullopt;
   89|    178|    }
   90|       |
   91|    312|    return value;
   92|    490|}

_Z16AdditionOverflowIlEbT_S0_:
   16|  2.40k|{
   17|  2.40k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|  2.40k|    if constexpr (std::numeric_limits<T>::is_signed) {
   19|  2.40k|        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
  ------------------
  |  Branch (19:17): [True: 460, False: 1.94k]
  |  Branch (19:26): [True: 12, False: 448]
  ------------------
   20|  2.40k|               (i < 0 && j < std::numeric_limits<T>::min() - i);
  ------------------
  |  Branch (20:17): [True: 963, False: 1.42k]
  |  Branch (20:26): [True: 0, False: 963]
  ------------------
   21|  2.40k|    }
   22|      0|    return std::numeric_limits<T>::max() - i < j;
   23|  2.40k|}
_Z16AdditionOverflowImEbT_S0_:
   16|  32.5k|{
   17|  32.5k|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  32.5k|    return std::numeric_limits<T>::max() - i < j;
   23|  32.5k|}
_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   27|  32.5k|{
   28|  32.5k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 0, False: 32.5k]
  ------------------
   29|      0|        return std::nullopt;
   30|      0|    }
   31|  32.5k|    return i + j;
   32|  32.5k|}

_Z5IsHexNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
   42|  1.72k|{
   43|   110k|    for (char c : str) {
  ------------------
  |  Branch (43:17): [True: 110k, False: 1.72k]
  ------------------
   44|   110k|        if (HexDigit(c) < 0) return false;
  ------------------
  |  Branch (44:13): [True: 0, False: 110k]
  ------------------
   45|   110k|    }
   46|  1.72k|    return (str.size() > 0) && (str.size()%2 == 0);
  ------------------
  |  Branch (46:12): [True: 1.72k, False: 0]
  |  Branch (46:32): [True: 1.72k, False: 0]
  ------------------
   47|  1.72k|}

_Z7IsDigitc:
  151|  23.8k|{
  152|  23.8k|    return c >= '0' && c <= '9';
  ------------------
  |  Branch (152:12): [True: 18.7k, False: 5.12k]
  |  Branch (152:24): [True: 18.6k, False: 36]
  ------------------
  153|  23.8k|}
_Z7IsSpacec:
  166|  13.8k|constexpr inline bool IsSpace(char c) noexcept {
  167|  13.8k|    return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v';
  ------------------
  |  Branch (167:12): [True: 1, False: 13.8k]
  |  Branch (167:24): [True: 0, False: 13.8k]
  |  Branch (167:37): [True: 0, False: 13.8k]
  |  Branch (167:50): [True: 0, False: 13.8k]
  |  Branch (167:63): [True: 0, False: 13.8k]
  |  Branch (167:76): [True: 0, False: 13.8k]
  ------------------
  168|  13.8k|}
_Z7ToLowerc:
  305|  1.72k|{
  306|  1.72k|    return (c >= 'A' && c <= 'Z' ? (c - 'A') + 'a' : c);
  ------------------
  |  Branch (306:13): [True: 35, False: 1.68k]
  |  Branch (306:25): [True: 4, False: 31]
  ------------------
  307|  1.72k|}
_Z7ToUpperc:
  331|  1.72k|{
  332|  1.72k|    return (c >= 'a' && c <= 'z' ? (c - 'a') + 'A' : c);
  ------------------
  |  Branch (332:13): [True: 29, False: 1.69k]
  |  Branch (332:25): [True: 5, False: 24]
  ------------------
  333|  1.72k|}
_Z21LocaleIndependentAtoiIlET_NSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  119|    490|{
  120|    490|    static_assert(std::is_integral<T>::value);
  121|    490|    T result;
  122|       |    // Emulate atoi(...) handling of white space and leading +/-.
  123|    490|    std::string_view s = util::TrimStringView(str);
  124|    490|    if (!s.empty() && s[0] == '+') {
  ------------------
  |  Branch (124:9): [True: 490, False: 0]
  |  Branch (124:23): [True: 0, False: 490]
  ------------------
  125|      0|        if (s.length() >= 2 && s[1] == '-') {
  ------------------
  |  Branch (125:13): [True: 0, False: 0]
  |  Branch (125:32): [True: 0, False: 0]
  ------------------
  126|      0|            return 0;
  127|      0|        }
  128|      0|        s = s.substr(1);
  129|      0|    }
  130|    490|    auto [_, error_condition] = std::from_chars(s.data(), s.data() + s.size(), result);
  131|    490|    if (error_condition == std::errc::result_out_of_range) {
  ------------------
  |  Branch (131:9): [True: 0, False: 490]
  ------------------
  132|      0|        if (s.length() >= 1 && s[0] == '-') {
  ------------------
  |  Branch (132:13): [True: 0, False: 0]
  |  Branch (132:32): [True: 0, False: 0]
  ------------------
  133|       |            // Saturate underflow, per strtoll's behavior.
  134|      0|            return std::numeric_limits<T>::min();
  135|      0|        } else {
  136|       |            // Saturate overflow, per strtoll's behavior.
  137|      0|            return std::numeric_limits<T>::max();
  138|      0|        }
  139|    490|    } else if (error_condition != std::errc{}) {
  ------------------
  |  Branch (139:16): [True: 0, False: 490]
  ------------------
  140|      0|        return 0;
  141|      0|    }
  142|    490|    return result;
  143|    490|}

_ZN4util14TrimStringViewENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
  147|  5.65k|{
  148|  5.65k|    std::string::size_type front = str.find_first_not_of(pattern);
  149|  5.65k|    if (front == std::string::npos) {
  ------------------
  |  Branch (149:9): [True: 0, False: 5.65k]
  ------------------
  150|      0|        return {};
  151|      0|    }
  152|  5.65k|    std::string::size_type end = str.find_last_not_of(pattern);
  153|  5.65k|    return str.substr(front, end - front + 1);
  154|  5.65k|}
_ZN4util10TrimStringENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
  157|  3.44k|{
  158|  3.44k|    return std::string(TrimStringView(str, pattern));
  159|  3.44k|}
_ZN4util16RemovePrefixViewENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
  170|  1.72k|{
  171|  1.72k|    if (str.substr(0, prefix.size()) == prefix) {
  ------------------
  |  Branch (171:9): [True: 0, False: 1.72k]
  ------------------
  172|      0|        return str.substr(prefix.size());
  173|      0|    }
  174|  1.72k|    return str;
  175|  1.72k|}
_ZN4util13ContainsNoNULENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  222|  3.44k|{
  223|  65.4k|    for (auto c : str) {
  ------------------
  |  Branch (223:17): [True: 65.4k, False: 3.44k]
  ------------------
  224|  65.4k|        if (c == 0) return false;
  ------------------
  |  Branch (224:13): [True: 0, False: 65.4k]
  ------------------
  225|  65.4k|    }
  226|  3.44k|    return true;
  227|  3.44k|}
_ZN4util8ToStringIlEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKT_:
  234|  1.72k|{
  235|  1.72k|    std::ostringstream oss;
  236|  1.72k|    oss.imbue(std::locale::classic());
  237|  1.72k|    oss << t;
  238|  1.72k|    return oss.str();
  239|  1.72k|}

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  1.73k|{
   43|  1.73k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  1.73k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  1.73k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  1.73k|}
_Z15MillisToTimevall:
  120|  1.72k|{
  121|  1.72k|    struct timeval timeout;
  122|  1.72k|    timeout.tv_sec  = nTimeout / 1000;
  123|  1.72k|    timeout.tv_usec = (nTimeout % 1000) * 1000;
  124|  1.72k|    return timeout;
  125|  1.72k|}

_Z13count_secondsNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   81|  1.72k|constexpr int64_t count_seconds(std::chrono::seconds t) { return t.count(); }