_ZNK4SpanIKhE4sizeEv:
  187|     35|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|     35|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|     35|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|      9|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__14spanIS0_Lm18446744073709551615EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|     26|        : m_data(other.data()), m_size(other.size()){}

_Z32base64_encode_decode_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   76|     26|{
   77|     26|    const std::string random_string{buffer.begin(), buffer.end()};
   78|       |
   79|       |    // Decode/Encode roundtrip
   80|     26|    if (auto result{DecodeBase64(random_string)}) {
  ------------------
  |  Branch (80:14): [True: 9, False: 17]
  ------------------
   81|      9|        const auto encoded_string{EncodeBase64(*result)};
   82|      9|        assert(encoded_string == TrimStringView(random_string));
   83|      9|    }
   84|       |    // Encode/Decode roundtrip
   85|     26|    const auto encoded{EncodeBase64(buffer)};
   86|     26|    const auto decoded{DecodeBase64(encoded)};
   87|     26|    assert(decoded && std::ranges::equal(*decoded, buffer));
   88|     26|}

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

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

_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|     26|{
   53|     26|    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|     26|    ) {
   58|     26|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 26]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|     26|    }
   62|     26|    return std::forward<T>(val);
   63|     26|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|     26|{
   53|     26|    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|     26|    ) {
   58|     26|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 26]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|     26|    }
   62|     26|    return std::forward<T>(val);
   63|     26|}

_Z12EncodeBase644SpanIKhE:
  100|     35|{
  101|     35|    static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  102|       |
  103|     35|    std::string str;
  104|     35|    str.reserve(((input.size() + 2) / 3) * 4);
  105|     35|    ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, input.begin(), input.end());
  106|     68|    while (str.size() % 4) str += '=';
  ------------------
  |  Branch (106:12): [True: 33, False: 35]
  ------------------
  107|     35|    return str;
  108|     35|}
_Z12DecodeBase64NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
  111|     52|{
  112|     52|    static const int8_t decode64_table[256]{
  113|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  114|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  115|     52|        -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
  116|     52|        -1, -1, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  117|     52|        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
  118|     52|        29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
  119|     52|        49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  120|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  121|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  122|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  123|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  124|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  125|     52|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
  126|     52|    };
  127|       |
  128|     52|    if (str.size() % 4 != 0) return {};
  ------------------
  |  Branch (128:9): [True: 11, False: 41]
  ------------------
  129|       |    /* One or two = characters at the end are permitted. */
  130|     41|    if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
  ------------------
  |  Branch (130:9): [True: 41, False: 0]
  |  Branch (130:28): [True: 23, False: 18]
  ------------------
  131|     41|    if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
  ------------------
  |  Branch (131:9): [True: 41, False: 0]
  |  Branch (131:28): [True: 13, False: 28]
  ------------------
  132|       |
  133|     41|    std::vector<unsigned char> ret;
  134|     41|    ret.reserve((str.size() * 3) / 4);
  135|     41|    bool valid = ConvertBits<6, 8, false>(
  136|     41|        [&](unsigned char c) { ret.push_back(c); },
  137|     41|        str.begin(), str.end(),
  138|     41|        [](char c) { return decode64_table[uint8_t(c)]; }
  139|     41|    );
  140|     41|    if (!valid) return {};
  ------------------
  |  Branch (140:9): [True: 6, False: 35]
  ------------------
  141|       |
  142|     35|    return ret;
  143|     41|}
strencodings.cpp:_ZZ12EncodeBase644SpanIKhEENK3$_0clEi:
  105|  1.57k|    ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, input.begin(), input.end());
strencodings.cpp:_ZZ12DecodeBase64NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEENK3$_1clEc:
  138|  1.70k|        [](char c) { return decode64_table[uint8_t(c)]; }
strencodings.cpp:_ZZ12DecodeBase64NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEENK3$_0clEh:
  136|  1.26k|        [&](unsigned char c) { ret.push_back(c); },

strencodings.cpp:_Z11ConvertBitsILi8ELi6ELb1EZ12EncodeBase644SpanIKhEE3$_0PS1_N12_GLOBAL__N_111IntIdentityEEbT2_T3_S8_T4_:
  270|     35|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|     35|    size_t acc = 0;
  272|     35|    size_t bits = 0;
  273|     35|    constexpr size_t maxv = (1 << tobits) - 1;
  274|     35|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|  1.20k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 1.17k, False: 35]
  ------------------
  276|  1.17k|        int v = infn(*it);
  277|  1.17k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 1.17k]
  ------------------
  278|  1.17k|        acc = ((acc << frombits) | v) & max_acc;
  279|  1.17k|        bits += frombits;
  280|  2.72k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 1.55k, False: 1.17k]
  ------------------
  281|  1.55k|            bits -= tobits;
  282|  1.55k|            outfn((acc >> bits) & maxv);
  283|  1.55k|        }
  284|  1.17k|        ++it;
  285|  1.17k|    }
  286|     35|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|     35|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 21, False: 14]
  ------------------
  288|     35|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|     35|    return true;
  292|     35|}
strencodings.cpp:_ZNK12_GLOBAL__N_111IntIdentityclEi:
  263|  1.17k|    [[maybe_unused]] int operator()(int x) const { return x; }
strencodings.cpp:_Z11ConvertBitsILi6ELi8ELb0EZ12DecodeBase64NSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEE3$_0PKcZ12DecodeBase64S4_E3$_1EbT2_T3_SA_T4_:
  270|     41|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|     41|    size_t acc = 0;
  272|     41|    size_t bits = 0;
  273|     41|    constexpr size_t maxv = (1 << tobits) - 1;
  274|     41|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|  1.74k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 1.70k, False: 36]
  ------------------
  276|  1.70k|        int v = infn(*it);
  277|  1.70k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 5, False: 1.69k]
  ------------------
  278|  1.69k|        acc = ((acc << frombits) | v) & max_acc;
  279|  1.69k|        bits += frombits;
  280|  2.96k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 1.26k, False: 1.69k]
  ------------------
  281|  1.26k|            bits -= tobits;
  282|  1.26k|            outfn((acc >> bits) & maxv);
  283|  1.26k|        }
  284|  1.69k|        ++it;
  285|  1.69k|    }
  286|     36|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|      0|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 0, False: 0]
  ------------------
  288|     36|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 36]
  |  Branch (288:36): [True: 1, False: 35]
  ------------------
  289|      1|        return false;
  290|      1|    }
  291|     35|    return true;
  292|     36|}

_ZN4util14TrimStringViewENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
  147|      9|{
  148|      9|    std::string::size_type front = str.find_first_not_of(pattern);
  149|      9|    if (front == std::string::npos) {
  ------------------
  |  Branch (149:9): [True: 0, False: 9]
  ------------------
  150|      0|        return {};
  151|      0|    }
  152|      9|    std::string::size_type end = str.find_last_not_of(pattern);
  153|      9|    return str.substr(front, end - front + 1);
  154|      9|}

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