LLVMFuzzerTestOneInput:
   17|    649|{
   18|    649|    constexpr auto var_count = 4;
   19|       |
   20|    649|    using array_t = immer::array<int, immer::default_memory_policy>;
   21|    649|    using size_t  = std::uint8_t;
   22|       |
   23|    649|    auto vars = std::array<array_t, var_count>{};
   24|       |
   25|    649|    auto is_valid_var   = [&](auto idx) { return idx >= 0 && idx < var_count; };
   26|    649|    auto is_valid_index = [](auto& v) {
   27|    649|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
   28|    649|    };
   29|    649|    auto is_valid_size = [](auto& v) {
   30|    649|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
   31|    649|    };
   32|       |    // limit doing immutable pushes on vectors that are too big already to
   33|       |    // prevent timeouts
   34|    649|    auto too_big = [](auto&& v) { return v.size() > (std::size_t{1} << 10); };
   35|    649|    return fuzzer_input{data, size}.run([&](auto& in) {
   36|    649|        enum ops
   37|    649|        {
   38|    649|            op_push_back,
   39|    649|            op_update,
   40|    649|            op_take,
   41|    649|            op_push_back_move,
   42|    649|            op_update_move,
   43|    649|            op_take_move,
   44|    649|        };
   45|    649|        auto src = read<char>(in, is_valid_var);
   46|    649|        auto dst = read<char>(in, is_valid_var);
   47|    649|        switch (read<char>(in)) {
   48|    649|        case op_push_back: {
   49|    649|            if (!too_big(vars[src]))
   50|    649|                vars[dst] = vars[src].push_back(42);
   51|    649|            break;
   52|    649|        }
   53|    649|        case op_update: {
   54|    649|            auto idx  = read<size_t>(in, is_valid_index(vars[src]));
   55|    649|            vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; });
   56|    649|            break;
   57|    649|        }
   58|    649|        case op_take: {
   59|    649|            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
   60|    649|            vars[dst] = vars[src].take(idx);
   61|    649|            break;
   62|    649|        }
   63|    649|        case op_push_back_move: {
   64|    649|            if (!too_big(vars[src]))
   65|    649|                vars[dst] = std::move(vars[src]).push_back(12);
   66|    649|            break;
   67|    649|        }
   68|    649|        case op_update_move: {
   69|    649|            auto idx = read<size_t>(in, is_valid_index(vars[src]));
   70|    649|            vars[dst] =
   71|    649|                std::move(vars[src]).update(idx, [](auto x) { return x + 1; });
   72|    649|            break;
   73|    649|        }
   74|    649|        case op_take_move: {
   75|    649|            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
   76|    649|            vars[dst] = std::move(vars[src]).take(idx);
   77|    649|            break;
   78|    649|        }
   79|    649|        default:
   80|    649|            break;
   81|    649|        };
   82|    649|        return true;
   83|    649|    });
   84|    649|}
array.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_:
   35|   376k|    return fuzzer_input{data, size}.run([&](auto& in) {
   36|   376k|        enum ops
   37|   376k|        {
   38|   376k|            op_push_back,
   39|   376k|            op_update,
   40|   376k|            op_take,
   41|   376k|            op_push_back_move,
   42|   376k|            op_update_move,
   43|   376k|            op_take_move,
   44|   376k|        };
   45|   376k|        auto src = read<char>(in, is_valid_var);
   46|   376k|        auto dst = read<char>(in, is_valid_var);
   47|   376k|        switch (read<char>(in)) {
   48|   207k|        case op_push_back: {
  ------------------
  |  Branch (48:9): [True: 207k, False: 168k]
  ------------------
   49|   207k|            if (!too_big(vars[src]))
  ------------------
  |  Branch (49:17): [True: 183k, False: 24.0k]
  ------------------
   50|   183k|                vars[dst] = vars[src].push_back(42);
   51|   207k|            break;
   52|      0|        }
   53|  3.07k|        case op_update: {
  ------------------
  |  Branch (53:9): [True: 3.07k, False: 373k]
  ------------------
   54|  3.07k|            auto idx  = read<size_t>(in, is_valid_index(vars[src]));
   55|  3.07k|            vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; });
   56|  3.07k|            break;
   57|      0|        }
   58|  4.75k|        case op_take: {
  ------------------
  |  Branch (58:9): [True: 4.75k, False: 371k]
  ------------------
   59|  4.75k|            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
   60|  4.75k|            vars[dst] = vars[src].take(idx);
   61|  4.75k|            break;
   62|      0|        }
   63|   140k|        case op_push_back_move: {
  ------------------
  |  Branch (63:9): [True: 140k, False: 236k]
  ------------------
   64|   140k|            if (!too_big(vars[src]))
  ------------------
  |  Branch (64:17): [True: 137k, False: 3.13k]
  ------------------
   65|   137k|                vars[dst] = std::move(vars[src]).push_back(12);
   66|   140k|            break;
   67|      0|        }
   68|  8.16k|        case op_update_move: {
  ------------------
  |  Branch (68:9): [True: 8.16k, False: 368k]
  ------------------
   69|  8.16k|            auto idx = read<size_t>(in, is_valid_index(vars[src]));
   70|  8.16k|            vars[dst] =
   71|  8.16k|                std::move(vars[src]).update(idx, [](auto x) { return x + 1; });
   72|  8.16k|            break;
   73|      0|        }
   74|  2.79k|        case op_take_move: {
  ------------------
  |  Branch (74:9): [True: 2.79k, False: 373k]
  ------------------
   75|  2.79k|            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
   76|  2.79k|            vars[dst] = std::move(vars[src]).take(idx);
   77|  2.79k|            break;
   78|      0|        }
   79|  9.13k|        default:
  ------------------
  |  Branch (79:9): [True: 9.13k, False: 367k]
  ------------------
   80|  9.13k|            break;
   81|   376k|        };
   82|   376k|        return true;
   83|   376k|    });
array.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIcEEDaT_:
   25|  1.01M|    auto is_valid_var   = [&](auto idx) { return idx >= 0 && idx < var_count; };
  ------------------
  |  Branch (25:50): [True: 925k, False: 94.6k]
  |  Branch (25:62): [True: 752k, False: 172k]
  ------------------
array.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIRN5immer5arrayIiNS1_13memory_policyINS1_21free_list_heap_policyINS1_8cpp_heapELm1024EEENS1_15refcount_policyENS1_15spinlock_policyENS1_20no_transience_policyELb0ELb1EEEEEEEDaOT_:
   34|   348k|    auto too_big = [](auto&& v) { return v.size() > (std::size_t{1} << 10); };
array.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS1_13memory_policyINS1_21free_list_heap_policyINS1_8cpp_heapELm1024EEENS1_15refcount_policyENS1_15spinlock_policyENS1_20no_transience_policyELb0ELb1EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   27|  31.9k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
  ------------------
  |  Branch (27:39): [True: 31.9k, False: 0]
  |  Branch (27:51): [True: 11.1k, False: 20.7k]
  ------------------
array.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS1_13memory_policyINS1_21free_list_heap_policyINS1_8cpp_heapELm1024EEENS1_15refcount_policyENS1_15spinlock_policyENS1_20no_transience_policyELb0ELb1EEEEEEEDaRT_:
   26|  11.2k|    auto is_valid_index = [](auto& v) {
   27|  11.2k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
   28|  11.2k|    };
array.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_ENKUlS2_E_clIiEEDaS2_:
   55|  3.05k|            vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; });
array.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS1_13memory_policyINS1_21free_list_heap_policyINS1_8cpp_heapELm1024EEENS1_15refcount_policyENS1_15spinlock_policyENS1_20no_transience_policyELb0ELb1EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   30|  14.8k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
  ------------------
  |  Branch (30:39): [True: 14.8k, False: 0]
  |  Branch (30:51): [True: 7.50k, False: 7.39k]
  ------------------
array.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS1_13memory_policyINS1_21free_list_heap_policyINS1_8cpp_heapELm1024EEENS1_15refcount_policyENS1_15spinlock_policyENS1_20no_transience_policyELb0ELb1EEEEEEEDaRT_:
   29|  7.55k|    auto is_valid_size = [](auto& v) {
   30|  7.55k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
   31|  7.55k|    };
array.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_ENKUlS2_E0_clIiEEDaS2_:
   71|  8.13k|                std::move(vars[src]).update(idx, [](auto x) { return x + 1; });

array.cpp:_ZN12fuzzer_input3runIZ22LLVMFuzzerTestOneInputE3$_4EEiT_:
   50|    649|    {
   51|    649|        if (size_ > fuzzer_input_max_size)
  ------------------
  |  Branch (51:13): [True: 6, False: 643]
  ------------------
   52|      6|            return 0;
   53|    643|        try {
   54|   376k|            while (step(*this))
  ------------------
  |  Branch (54:20): [True: 376k, False: 643]
  ------------------
   55|   376k|                continue;
   56|    643|        } catch (const no_more_input&) {
   57|    643|        };
   58|    643|        return 0;
   59|    643|    }
array.cpp:_Z4readIcZ22LLVMFuzzerTestOneInputE3$_0ET_R12fuzzer_inputT0_:
   70|   752k|{
   71|   752k|    auto x = read<T>(fz);
   72|  1.02M|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 267k, False: 752k]
  ------------------
   73|   267k|        x = read<T>(fz);
   74|   752k|    return x;
   75|   752k|}
_Z4readIcERKT_R12fuzzer_input:
   64|  1.39M|{
   65|  1.39M|    return *reinterpret_cast<const T*>(fz.next(sizeof(T), alignof(T)));
   66|  1.39M|}
_ZN12fuzzer_input4nextEmm:
   40|  1.44M|    {
   41|  1.44M|        auto& p = const_cast<void*&>(reinterpret_cast<const void*&>(data_));
   42|  1.44M|        auto r  = std::align(align, size, p, size_);
   43|  1.44M|        if (r == nullptr)
  ------------------
  |  Branch (43:13): [True: 643, False: 1.44M]
  ------------------
   44|    643|            throw no_more_input{};
   45|  1.44M|        return next(size);
   46|  1.44M|    }
_ZN12fuzzer_input4nextEm:
   30|  1.44M|    {
   31|  1.44M|        if (size_ < size)
  ------------------
  |  Branch (31:13): [True: 0, False: 1.44M]
  ------------------
   32|      0|            throw no_more_input{};
   33|  1.44M|        auto r = data_;
   34|  1.44M|        data_ += size;
   35|  1.44M|        size_ -= size;
   36|  1.44M|        return r;
   37|  1.44M|    }
array.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS2_13memory_policyINS2_21free_list_heap_policyINS2_8cpp_heapELm1024EEENS2_15refcount_policyENS2_15spinlock_policyENS2_20no_transience_policyELb0ELb1EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  11.2k|{
   71|  11.2k|    auto x = read<T>(fz);
   72|  31.9k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 20.7k, False: 11.2k]
  ------------------
   73|  20.7k|        x = read<T>(fz);
   74|  11.2k|    return x;
   75|  11.2k|}
_Z4readIhERKT_R12fuzzer_input:
   64|  46.8k|{
   65|  46.8k|    return *reinterpret_cast<const T*>(fz.next(sizeof(T), alignof(T)));
   66|  46.8k|}
array.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS2_13memory_policyINS2_21free_list_heap_policyINS2_8cpp_heapELm1024EEENS2_15refcount_policyENS2_15spinlock_policyENS2_20no_transience_policyELb0ELb1EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  7.55k|{
   71|  7.55k|    auto x = read<T>(fz);
   72|  14.9k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 7.39k, False: 7.55k]
  ------------------
   73|  7.39k|        x = read<T>(fz);
   74|  7.55k|    return x;
   75|  7.55k|}

_ZN5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2Ev:
   71|  2.59k|    array() = default;
_ZNK5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4sizeEv:
  142|   395k|    IMMER_NODISCARD std::size_t size() const { return impl_.size; }
_ZNKR5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE9push_backEi:
  212|   183k|    {
  213|   183k|        return impl_.push_back(std::move(value));
  214|   183k|    }
_ZN5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2ENS_6detail6arrays13with_capacityIiS8_EE:
  330|   191k|        : impl_(std::move(impl))
  331|   191k|    {
  332|   191k|    }
array.cpp:_ZNKR5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSE_E_EES9_mOSE_:
  266|  3.05k|    {
  267|  3.05k|        return impl_.update(index, std::forward<FnT>(fn));
  268|  3.05k|    }
_ZNKR5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4takeEm:
  293|  4.73k|    {
  294|  4.73k|        return impl_.take(elems);
  295|  4.73k|    }
_ZNO5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE9push_backEi:
  217|   137k|    {
  218|   137k|        return push_back_move(move_t{}, std::move(value));
  219|   137k|    }
_ZN5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE14push_back_moveENSt3__117integral_constantIbLb1EEEi:
  335|   137k|    {
  336|   137k|        impl_.push_back_mut({}, std::move(value));
  337|   137k|        return std::move(*this);
  338|   137k|    }
array.cpp:_ZNO5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSE_E0_EEDcmOSE_:
  272|  8.13k|    {
  273|  8.13k|        return update_move(move_t{}, index, std::forward<FnT>(fn));
  274|  8.13k|    }
array.cpp:_ZN5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE11update_moveIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSE_E0_EEOS9_NSt3__117integral_constantIbLb1EEEmOSE_:
  356|  8.13k|    {
  357|  8.13k|        impl_.update_mut({}, index, std::forward<Fn>(fn));
  358|  8.13k|        return std::move(*this);
  359|  8.13k|    }
_ZNO5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4takeEm:
  298|  2.77k|    {
  299|  2.77k|        return take_move(move_t{}, elems);
  300|  2.77k|    }
_ZN5immer5arrayIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE9take_moveENSt3__117integral_constantIbLb1EEEm:
  367|  2.77k|    {
  368|  2.77k|        impl_.take_mut({}, elems);
  369|  2.77k|        return std::move(*this);
  370|  2.77k|    }

_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6make_nEm:
   69|   195k|    {
   70|   195k|        return new (heap::allocate(sizeof_n(n))) node_t{};
   71|   195k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE8sizeof_nEm:
   42|   390k|    {
   43|       |        return std::max(immer_offsetof(impl_t, d) +
  ------------------
  |  |   19|   390k|#define immer_offsetof offsetof
  ------------------
   44|   390k|                            decltype(impl_t::d)::get_storage_offset() +
   45|   390k|                            sizeof(T) * count,
   46|   390k|                        sizeof(node));
   47|   390k|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4refsEv:
   49|   731k|    refs_t& refs() const { return auto_const_cast(get<refs_t>(impl)); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE8delete_nEPSB_mm:
   63|   195k|    {
   64|   195k|        detail::destroy_n(p->data(), sz);
   65|   195k|        heap::deallocate(sizeof_n(cap), p);
   66|   195k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4dataEv:
   55|  1.11M|    T* data() { return impl.d.get_storage_ptr(); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6copy_nEmPSB_m:
  111|   191k|    {
  112|   191k|        return copy_n(n, p->data(), p->data() + count);
  113|   191k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6copy_nIPiSD_TnNSt3__19enable_ifIXsr6detailE21compatible_sentinel_vIT_T0_EEbE4typeELb1EEEPSB_mSG_SH_:
   98|   195k|    {
   99|   195k|        auto p = make_n(n);
  100|   195k|        IMMER_TRY {
  ------------------
  |  |   49|   195k|#define IMMER_TRY try
  ------------------
  101|   195k|            detail::uninitialized_copy(first, last, p->data());
  102|   195k|            return p;
  103|   195k|        }
  104|   195k|        IMMER_CATCH (...) {
  105|      0|            heap::deallocate(sizeof_n(n), p);
  106|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  107|      0|        }
  108|   195k|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE10can_mutateENS9_5applyIS6_E4type4editE:
   58|   148k|    {
   59|   148k|        return refs().unique() || ownee().can_mutate(e);
  ------------------
  |  Branch (59:16): [True: 147k, False: 260]
  |  Branch (59:35): [True: 0, False: 260]
  ------------------
   60|   148k|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE5owneeEv:
   51|    260|    const ownee_t& ownee() const { return get<ownee_t>(impl); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6copy_eENS9_5applyIS6_E4type4editEmPSB_m:
  124|  3.54k|    {
  125|  3.54k|        return copy_e(e, n, p->data(), p->data() + count);
  126|  3.54k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6copy_eIPiEEPSB_NS9_5applyIS6_E4type4editEmT_SJ_:
  117|  3.54k|    {
  118|  3.54k|        auto p     = copy_n(n, first, last);
  119|  3.54k|        p->ownee() = e;
  120|  3.54k|        return p;
  121|  3.54k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE5owneeEv:
   52|  3.54k|    ownee_t& ownee() { return get<ownee_t>(impl); }

_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE5emptyEv:
   36|   194k|    {
   37|   194k|        static const with_capacity empty_{node_t::make_n(1), 0, 1};
   38|   194k|        return empty_;
   39|   194k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2EPNS1_4nodeIiSA_EEmm:
   42|   389k|        : ptr{p}
   43|   389k|        , size{s}
   44|   389k|        , capacity{c}
   45|   389k|    {
   46|   389k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEED2Ev:
   87|   389k|    ~with_capacity() { dec(); }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE3decEv:
   96|   389k|    {
   97|   389k|        using immer::detail::get;
   98|   389k|        if (ptr->refs().dec())
  ------------------
  |  Branch (98:13): [True: 195k, False: 194k]
  ------------------
   99|   195k|            node_t::delete_n(ptr, size, capacity);
  100|   389k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2ERKSB_:
   49|   194k|        : with_capacity{other.ptr, other.size, other.capacity}
   50|   194k|    {
   51|   194k|        inc();
   52|   194k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE3incEv:
   90|   194k|    {
   91|   194k|        using immer::detail::get;
   92|   194k|        ptr->refs().inc();
   93|   194k|    }
_ZNK5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE9push_backEi:
  197|   183k|    {
  198|   183k|        auto cap = recommend_up(size + 1, capacity);
  199|   183k|        auto p   = node_t::copy_n(cap, ptr, size);
  200|   183k|        IMMER_TRY {
  ------------------
  |  |   49|   183k|#define IMMER_TRY try
  ------------------
  201|   183k|            new (p->data() + size) T(std::move(value));
  202|   183k|            return {p, size + 1, cap};
  203|   183k|        }
  204|   183k|        IMMER_CATCH (...) {
  205|      0|            node_t::delete_n(p, size, cap);
  206|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  207|      0|        }
  208|   183k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE12recommend_upEmm:
  180|   187k|    {
  181|   187k|        auto max = std::numeric_limits<size_t>::max();
  182|   187k|        return sz <= cap        ? cap
  ------------------
  |  Branch (182:16): [True: 177k, False: 9.39k]
  ------------------
  183|   187k|               : cap >= max / 2 ? max
  ------------------
  |  Branch (183:18): [True: 0, False: 9.39k]
  ------------------
  184|       |                                /* otherwise */
  185|  9.39k|                                : std::max(2 * cap, sz);
  186|   187k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEC2EOSB_:
   61|   191k|        : with_capacity{empty()}
   62|   191k|    {
   63|   191k|        swap(*this, other);
   64|   191k|    }
_ZN5immer6detail6arrays4swapERNS1_13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEESC_:
   80|   534k|    {
   81|   534k|        using std::swap;
   82|   534k|        swap(x.ptr, y.ptr);
   83|   534k|        swap(x.size, y.size);
   84|   534k|        swap(x.capacity, y.capacity);
   85|   534k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEEaSEOSB_:
   74|   343k|    {
   75|   343k|        swap(*this, other);
   76|   343k|        return *this;
   77|   343k|    }
array.cpp:_ZNK5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSG_E_EESB_mOSG_:
  261|  3.05k|    {
  262|  3.05k|        auto p = node_t::copy_n(capacity, ptr, size);
  263|  3.05k|        IMMER_TRY {
  ------------------
  |  |   49|  3.05k|#define IMMER_TRY try
  ------------------
  264|  3.05k|            auto& elem = p->data()[idx];
  265|  3.05k|            elem       = std::forward<Fn>(op)(std::move(elem));
  266|  3.05k|            return {p, size, capacity};
  267|  3.05k|        }
  268|  3.05k|        IMMER_CATCH (...) {
  269|      0|            node_t::delete_n(p, size, capacity);
  270|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  271|      0|        }
  272|  3.05k|    }
_ZNK5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4takeEm:
  295|  4.73k|    {
  296|  4.73k|        assert(sz <= size);
  ------------------
  |  Branch (296:9): [True: 4.73k, False: 0]
  ------------------
  297|  4.73k|        auto cap = recommend_down(sz, capacity);
  298|  4.73k|        auto p   = node_t::copy_n(cap, ptr, sz);
  299|  4.73k|        return {p, sz, cap};
  300|  4.73k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE14recommend_downEmm:
  189|  4.79k|    {
  190|  4.79k|        return sz == 0        ? 1
  ------------------
  |  Branch (190:16): [True: 2.12k, False: 2.67k]
  ------------------
  191|  4.79k|               : sz < cap / 2 ? sz * 2
  ------------------
  |  Branch (191:18): [True: 1.63k, False: 1.03k]
  ------------------
  192|  2.67k|                              :
  193|  2.67k|                              /* otherwise */ cap;
  194|  4.79k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE13push_back_mutENS9_5applyIS6_E4type4editEi:
  211|   137k|    {
  212|   137k|        if (ptr->can_mutate(e) && capacity > size) {
  ------------------
  |  Branch (212:13): [True: 137k, False: 192]
  |  Branch (212:35): [True: 133k, False: 3.28k]
  ------------------
  213|   133k|            new (data() + size) T(std::move(value));
  214|   133k|            ++size;
  215|   133k|        } else {
  216|  3.47k|            auto cap = recommend_up(size + 1, capacity);
  217|  3.47k|            auto p   = node_t::copy_e(e, cap, ptr, size);
  218|  3.47k|            IMMER_TRY {
  ------------------
  |  |   49|  3.47k|#define IMMER_TRY try
  ------------------
  219|  3.47k|                new (p->data() + size) T(std::move(value));
  220|  3.47k|                *this = {p, size + 1, cap};
  221|  3.47k|            }
  222|  3.47k|            IMMER_CATCH (...) {
  223|      0|                node_t::delete_n(p, size, cap);
  224|      0|                IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  225|      0|            }
  226|  3.47k|        }
  227|   137k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE4dataEv:
  103|   144k|    T* data() { return ptr->data(); }
array.cpp:_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE10update_mutIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSG_E0_EEvNS9_5applyIS6_E4type4editEmOSG_:
  276|  8.13k|    {
  277|  8.13k|        if (ptr->can_mutate(e)) {
  ------------------
  |  Branch (277:13): [True: 8.13k, False: 0]
  ------------------
  278|  8.13k|            auto& elem = data()[idx];
  279|  8.13k|            elem       = std::forward<Fn>(op)(std::move(elem));
  280|  8.13k|        } else {
  281|      0|            auto p = node_t::copy_e(e, capacity, ptr, size);
  282|      0|            IMMER_TRY {
  ------------------
  |  |   49|      0|#define IMMER_TRY try
  ------------------
  283|      0|                auto& elem = p->data()[idx];
  284|      0|                elem       = std::forward<Fn>(op)(std::move(elem));
  285|      0|                *this      = {p, size, capacity};
  286|      0|            }
  287|      0|            IMMER_CATCH (...) {
  288|      0|                node_t::delete_n(p, size, capacity);
  289|      0|                IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  290|      0|            }
  291|      0|        }
  292|  8.13k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE8take_mutENS9_5applyIS6_E4type4editEm:
  303|  2.77k|    {
  304|  2.77k|        assert(sz <= size);
  ------------------
  |  Branch (304:9): [True: 2.77k, False: 0]
  ------------------
  305|  2.77k|        if (ptr->can_mutate(e)) {
  ------------------
  |  Branch (305:13): [True: 2.70k, False: 68]
  ------------------
  306|  2.70k|            detail::destroy_n(data() + size, size - sz);
  307|  2.70k|            size = sz;
  308|  2.70k|        } else {
  309|     68|            auto cap = recommend_down(sz, capacity);
  310|     68|            auto p   = node_t::copy_e(e, cap, ptr, sz);
  311|     68|            *this    = {p, sz, cap};
  312|     68|        }
  313|  2.77k|    }

_ZN5immer6detail3csl3getINS_15refcount_policyEEEDcRKNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEES3_NS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tENS1_6memberIS3_NS1_7inheritINSC_5applyISA_E4type5owneeEvE4typeEE4typeEE4typeE:
  170|   731k|        {
  171|   731k|            return x.get_(type_t<U>{});
  172|   731k|        }
_ZNK5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_IS9_EEDcNS1_6type_tIT_EE:
  184|   731k|        {
  185|   731k|            return n.get_(t);
  186|   731k|        }
_ZNK5immer6detail3csl6memberINS_15refcount_policyENS1_7inheritINS_20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeEvE4typeEE4type4get_ENS1_6type_tIS3_EE:
  128|   731k|        const T& get_(type_t<T>) const { return d; }
_ZN5immer6detail3csl3getINS_20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeEEEDcRKNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyIS7_NS_15refcount_policyENS_15spinlock_policyES3_Lb0ELb1EEEE6data_tENS1_6memberISF_NS1_7inheritISA_vE4typeEE4typeEE4typeE:
  170|    260|        {
  171|    260|            return x.get_(type_t<U>{});
  172|    260|        }
_ZNK5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE:
  184|    260|        {
  185|    260|            return n.get_(t);
  186|    260|        }
_ZNK5immer6detail3csl7inheritINS_20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE:
  103|    260|        const T& get_(type_t<T>) const { return *this; }
_ZN5immer6detail3csl3getINS_20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeEEEDcRNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyIS7_NS_15refcount_policyENS_15spinlock_policyES3_Lb0ELb1EEEE6data_tENS1_6memberISF_NS1_7inheritISA_vE4typeEE4typeEE4typeE:
  165|  3.54k|        {
  166|  3.54k|            return x.get_(type_t<U>{});
  167|  3.54k|        }
_ZN5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tENS1_6memberIS9_NS1_7inheritINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE:
  179|  3.54k|        {
  180|  3.54k|            return n.get_(t);
  181|  3.54k|        }
_ZN5immer6detail3csl7inheritINS_20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE:
  102|  3.54k|        T& get_(type_t<T>) { return *this; }

_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tEiLb1EE18get_storage_offsetEv:
   87|   390k|    {
   88|   390k|        check_base();
   89|   390k|        return 0;
   90|   390k|    }
_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tEiLb1EE10check_baseEv:
   94|  1.50M|    {
   95|       |        // is_standard_layout requires that only one class in the hierarchy
   96|       |        // contains non-static data members. Since this class contains one
   97|       |        // member, the static_assert will only hold when the derived class is
   98|       |        // empty.
   99|  1.50M|        static_assert(std::is_standard_layout<Derived>::value,
  100|  1.50M|                      "Please remove 'true' if the derived class is non emtpy");
  101|  1.50M|    }
_ZN5immer6detail15auto_const_castINS_15refcount_policyEEERT_RKS3_:
  143|   731k|{
  144|   731k|    return const_cast<T&>(x);
  145|   731k|}
_ZN5immer6detail9destroy_nIPimEENSt3__19enable_ifIX20can_trivially_detroyIT_EES5_E4typeES5_T0_:
  188|   197k|{
  189|   197k|    return first + n;
  190|   197k|}
_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEENS_15refcount_policyENS_15spinlock_policyENS_20no_transience_policyELb0ELb1EEEE6data_tEiLb1EE15get_storage_ptrEv:
   75|  1.11M|    {
   76|  1.11M|        check_base();
   77|  1.11M|        return reinterpret_cast<T*>(this);
   78|  1.11M|    }
_ZN5immer6detail18uninitialized_copyIPiS2_S2_EENSt3__19enable_ifIX18can_trivially_copyIT_T1_EES6_E4typeES5_T0_S6_:
  236|   195k|{
  237|   195k|    return std::copy(first, last, out);
  238|   195k|}

_ZN5immer8cpp_heap8allocateIJEEEPvmDpT_:
   27|   195k|    {
   28|   195k|        return ::operator new(size);
   29|   195k|    }
_ZN5immer8cpp_heap10deallocateEmPv:
   36|   195k|    static void deallocate(std::size_t, void* data) { ::operator delete(data); }

_ZN5immer15debug_size_heapINS_8cpp_heapEE8allocateIJEEEPvmDpT_:
   49|   195k|    {
   50|   195k|        auto p = (std::size_t*) Base::allocate(size + extra_size, tags...);
   51|   195k|        new (p) std::size_t{size};
   52|   195k|        return ((char*) p) + extra_size;
   53|   195k|    }
_ZN5immer15debug_size_heapINS_8cpp_heapEE10deallocateIJEEEvmPvDpT_:
   57|   195k|    {
   58|   195k|        auto p = (std::size_t*) (((char*) data) - extra_size);
   59|   195k|        assert(*p == size);
  ------------------
  |  Branch (59:9): [True: 195k, False: 0]
  ------------------
   60|   195k|        Base::deallocate(size + extra_size, p, tags...);
   61|   195k|    }

_ZN5immer15refcount_policyC2Ev:
   28|   195k|        : refcount{1} {};
_ZN5immer15refcount_policy3decEv:
   36|   389k|    bool dec() { return 1 == refcount.fetch_sub(1, std::memory_order_acq_rel); }
_ZN5immer15refcount_policy3incEv:
   34|   194k|    void inc() { refcount.fetch_add(1, std::memory_order_relaxed); }
_ZN5immer15refcount_policy6uniqueEv:
   38|   148k|    bool unique() { return refcount == 1; }

_ZNK5immer20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5ownee10can_mutateENS6_4editE:
   35|    260|                bool can_mutate(edit) const { return false; }
_ZN5immer20no_transience_policy5applyINS_21free_list_heap_policyINS_8cpp_heapELm1024EEEE4type5owneeaSENS6_4editE:
   34|  3.54k|                ownee& operator=(edit) { return *this; };