LLVMFuzzerTestOneInput:
   26|  1.00k|{
   27|  1.00k|    constexpr auto var_count = 4;
   28|       |
   29|  1.00k|    auto guard = immer::gc_disable_guard{};
   30|       |
   31|  1.00k|    using array_t     = immer::array<int, gc_memory>;
   32|  1.00k|    using transient_t = typename array_t::transient_type;
   33|  1.00k|    using size_t      = std::uint8_t;
   34|       |
   35|  1.00k|    auto vs = std::array<array_t, var_count>{};
   36|  1.00k|    auto ts = std::array<transient_t, var_count>{};
   37|       |
   38|  1.00k|    auto is_valid_var   = [&](auto idx) { return idx >= 0 && idx < var_count; };
   39|  1.00k|    auto is_valid_index = [](auto& v) {
   40|  1.00k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
   41|  1.00k|    };
   42|  1.00k|    auto is_valid_size = [](auto& v) {
   43|  1.00k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
   44|  1.00k|    };
   45|       |    // limit doing immutable pushes on vectors that are too big already to
   46|       |    // prevent timeouts
   47|  1.00k|    auto too_big = [](auto&& v) { return v.size() > (std::size_t{1} << 10); };
   48|  1.00k|    return fuzzer_input{data, size}.run([&](auto& in) {
   49|  1.00k|        enum ops
   50|  1.00k|        {
   51|  1.00k|            op_transient,
   52|  1.00k|            op_persistent,
   53|  1.00k|            op_push_back,
   54|  1.00k|            op_update,
   55|  1.00k|            op_take,
   56|  1.00k|            op_push_back_mut,
   57|  1.00k|            op_update_mut,
   58|  1.00k|            op_take_mut,
   59|  1.00k|        };
   60|  1.00k|        auto dst = read<char>(in, is_valid_var);
   61|  1.00k|        switch (read<char>(in)) {
   62|  1.00k|        case op_transient: {
   63|  1.00k|            auto src = read<char>(in, is_valid_var);
   64|  1.00k|            ts[dst]  = vs[src].transient();
   65|  1.00k|            break;
   66|  1.00k|        }
   67|  1.00k|        case op_persistent: {
   68|  1.00k|            auto src = read<char>(in, is_valid_var);
   69|  1.00k|            vs[dst]  = ts[src].persistent();
   70|  1.00k|            break;
   71|  1.00k|        }
   72|  1.00k|        case op_push_back: {
   73|  1.00k|            auto src = read<char>(in, is_valid_var);
   74|  1.00k|            if (!too_big(vs[src]))
   75|  1.00k|                vs[dst] = vs[src].push_back(42);
   76|  1.00k|            break;
   77|  1.00k|        }
   78|  1.00k|        case op_update: {
   79|  1.00k|            auto src = read<char>(in, is_valid_var);
   80|  1.00k|            auto idx = read<size_t>(in, is_valid_index(vs[src]));
   81|  1.00k|            vs[dst]  = vs[src].update(idx, [](auto x) { return x + 1; });
   82|  1.00k|            break;
   83|  1.00k|        }
   84|  1.00k|        case op_take: {
   85|  1.00k|            auto src = read<char>(in, is_valid_var);
   86|  1.00k|            auto idx = read<size_t>(in, is_valid_size(vs[src]));
   87|  1.00k|            vs[dst]  = vs[src].take(idx);
   88|  1.00k|            break;
   89|  1.00k|        }
   90|  1.00k|        case op_push_back_mut: {
   91|  1.00k|            if (!too_big(vs[dst]))
   92|  1.00k|                ts[dst].push_back(13);
   93|  1.00k|            break;
   94|  1.00k|        }
   95|  1.00k|        case op_update_mut: {
   96|  1.00k|            auto idx = read<size_t>(in, is_valid_index(ts[dst]));
   97|  1.00k|            ts[dst].update(idx, [](auto x) { return x + 1; });
   98|  1.00k|            break;
   99|  1.00k|        }
  100|  1.00k|        case op_take_mut: {
  101|  1.00k|            auto idx = read<size_t>(in, is_valid_size(ts[dst]));
  102|  1.00k|            ts[dst].take(idx);
  103|  1.00k|            break;
  104|  1.00k|        }
  105|  1.00k|        default:
  106|  1.00k|            break;
  107|  1.00k|        };
  108|  1.00k|        return true;
  109|  1.00k|    });
  110|  1.00k|}
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_:
   48|  1.59M|    return fuzzer_input{data, size}.run([&](auto& in) {
   49|  1.59M|        enum ops
   50|  1.59M|        {
   51|  1.59M|            op_transient,
   52|  1.59M|            op_persistent,
   53|  1.59M|            op_push_back,
   54|  1.59M|            op_update,
   55|  1.59M|            op_take,
   56|  1.59M|            op_push_back_mut,
   57|  1.59M|            op_update_mut,
   58|  1.59M|            op_take_mut,
   59|  1.59M|        };
   60|  1.59M|        auto dst = read<char>(in, is_valid_var);
   61|  1.59M|        switch (read<char>(in)) {
   62|  18.7k|        case op_transient: {
  ------------------
  |  Branch (62:9): [True: 18.7k, False: 1.57M]
  ------------------
   63|  18.7k|            auto src = read<char>(in, is_valid_var);
   64|  18.7k|            ts[dst]  = vs[src].transient();
   65|  18.7k|            break;
   66|      0|        }
   67|  4.16k|        case op_persistent: {
  ------------------
  |  Branch (67:9): [True: 4.16k, False: 1.58M]
  ------------------
   68|  4.16k|            auto src = read<char>(in, is_valid_var);
   69|  4.16k|            vs[dst]  = ts[src].persistent();
   70|  4.16k|            break;
   71|      0|        }
   72|  18.1k|        case op_push_back: {
  ------------------
  |  Branch (72:9): [True: 18.1k, False: 1.57M]
  ------------------
   73|  18.1k|            auto src = read<char>(in, is_valid_var);
   74|  18.1k|            if (!too_big(vs[src]))
  ------------------
  |  Branch (74:17): [True: 13.2k, False: 4.91k]
  ------------------
   75|  13.2k|                vs[dst] = vs[src].push_back(42);
   76|  18.1k|            break;
   77|      0|        }
   78|  3.05k|        case op_update: {
  ------------------
  |  Branch (78:9): [True: 3.05k, False: 1.59M]
  ------------------
   79|  3.05k|            auto src = read<char>(in, is_valid_var);
   80|  3.05k|            auto idx = read<size_t>(in, is_valid_index(vs[src]));
   81|  3.05k|            vs[dst]  = vs[src].update(idx, [](auto x) { return x + 1; });
   82|  3.05k|            break;
   83|      0|        }
   84|  2.90k|        case op_take: {
  ------------------
  |  Branch (84:9): [True: 2.90k, False: 1.59M]
  ------------------
   85|  2.90k|            auto src = read<char>(in, is_valid_var);
   86|  2.90k|            auto idx = read<size_t>(in, is_valid_size(vs[src]));
   87|  2.90k|            vs[dst]  = vs[src].take(idx);
   88|  2.90k|            break;
   89|      0|        }
   90|  1.53M|        case op_push_back_mut: {
  ------------------
  |  Branch (90:9): [True: 1.53M, False: 54.0k]
  ------------------
   91|  1.53M|            if (!too_big(vs[dst]))
  ------------------
  |  Branch (91:17): [True: 1.46M, False: 77.1k]
  ------------------
   92|  1.46M|                ts[dst].push_back(13);
   93|  1.53M|            break;
   94|      0|        }
   95|  1.09k|        case op_update_mut: {
  ------------------
  |  Branch (95:9): [True: 1.09k, False: 1.59M]
  ------------------
   96|  1.09k|            auto idx = read<size_t>(in, is_valid_index(ts[dst]));
   97|  1.09k|            ts[dst].update(idx, [](auto x) { return x + 1; });
   98|  1.09k|            break;
   99|      0|        }
  100|  2.75k|        case op_take_mut: {
  ------------------
  |  Branch (100:9): [True: 2.75k, False: 1.59M]
  ------------------
  101|  2.75k|            auto idx = read<size_t>(in, is_valid_size(ts[dst]));
  102|  2.75k|            ts[dst].take(idx);
  103|  2.75k|            break;
  104|      0|        }
  105|  2.53k|        default:
  ------------------
  |  Branch (105:9): [True: 2.53k, False: 1.59M]
  ------------------
  106|  2.53k|            break;
  107|  1.59M|        };
  108|  1.59M|        return true;
  109|  1.59M|    });
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIcEEDaT_:
   38|  1.69M|    auto is_valid_var   = [&](auto idx) { return idx >= 0 && idx < var_count; };
  ------------------
  |  Branch (38:50): [True: 1.67M, False: 18.9k]
  |  Branch (38:62): [True: 1.63M, False: 31.8k]
  ------------------
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIRN5immer5arrayIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaOT_:
   47|  1.55M|    auto too_big = [](auto&& v) { return v.size() > (std::size_t{1} << 10); };
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   40|   124k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
  ------------------
  |  Branch (40:39): [True: 124k, False: 0]
  |  Branch (40:51): [True: 2.98k, False: 121k]
  ------------------
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_:
   39|  3.01k|    auto is_valid_index = [](auto& v) {
   40|  3.01k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
   41|  3.01k|    };
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_ENKUlS2_E_clIiEEDaS2_:
   81|  2.98k|            vs[dst]  = vs[src].update(idx, [](auto x) { return x + 1; });
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   43|  6.09k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
  ------------------
  |  Branch (43:39): [True: 6.09k, False: 0]
  |  Branch (43:51): [True: 2.83k, False: 3.26k]
  ------------------
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_:
   42|  2.86k|    auto is_valid_size = [](auto& v) {
   43|  2.86k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
   44|  2.86k|    };
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer15array_transientIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   40|  1.86k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
  ------------------
  |  Branch (40:39): [True: 1.86k, False: 0]
  |  Branch (40:51): [True: 1.06k, False: 798]
  ------------------
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer15array_transientIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_:
   39|  1.09k|    auto is_valid_index = [](auto& v) {
   40|  1.09k|        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
   41|  1.09k|    };
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_ENKUlS2_E0_clIiEEDaS2_:
   97|  1.06k|            ts[dst].update(idx, [](auto x) { return x + 1; });
array-gc.cpp:_ZZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer15array_transientIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_ENKUlSC_E_clIhEEDaSC_:
   43|  4.00k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
  ------------------
  |  Branch (43:39): [True: 4.00k, False: 0]
  |  Branch (43:51): [True: 2.72k, False: 1.28k]
  ------------------
array-gc.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer15array_transientIiNS1_13memory_policyINS1_11heap_policyINS1_7gc_heapEEENS1_18no_refcount_policyENS1_15spinlock_policyENS1_20gc_transience_policyELb0ELb0EEEEEEEDaRT_:
   42|  2.75k|    auto is_valid_size = [](auto& v) {
   43|  2.75k|        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
   44|  2.75k|    };

array-gc.cpp:_ZN12fuzzer_input3runIZ22LLVMFuzzerTestOneInputE3$_4EEiT_:
   50|  1.00k|    {
   51|  1.00k|        if (size_ > fuzzer_input_max_size)
  ------------------
  |  Branch (51:13): [True: 8, False: 994]
  ------------------
   52|      8|            return 0;
   53|    994|        try {
   54|  1.59M|            while (step(*this))
  ------------------
  |  Branch (54:20): [True: 1.59M, False: 994]
  ------------------
   55|  1.59M|                continue;
   56|    994|        } catch (const no_more_input&) {
   57|    994|        };
   58|    994|        return 0;
   59|    994|    }
array-gc.cpp:_Z4readIcZ22LLVMFuzzerTestOneInputE3$_0ET_R12fuzzer_inputT0_:
   70|  1.64M|{
   71|  1.64M|    auto x = read<T>(fz);
   72|  1.69M|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 50.8k, False: 1.64M]
  ------------------
   73|  50.8k|        x = read<T>(fz);
   74|  1.64M|    return x;
   75|  1.64M|}
_Z4readIcERKT_R12fuzzer_input:
   64|  3.28M|{
   65|  3.28M|    return *reinterpret_cast<const T*>(fz.next(sizeof(T), alignof(T)));
   66|  3.28M|}
_ZN12fuzzer_input4nextEmm:
   40|  3.42M|    {
   41|  3.42M|        auto& p = const_cast<void*&>(reinterpret_cast<const void*&>(data_));
   42|  3.42M|        auto r  = std::align(align, size, p, size_);
   43|  3.42M|        if (r == nullptr)
  ------------------
  |  Branch (43:13): [True: 994, False: 3.41M]
  ------------------
   44|    994|            throw no_more_input{};
   45|  3.41M|        return next(size);
   46|  3.42M|    }
_ZN12fuzzer_input4nextEm:
   30|  3.41M|    {
   31|  3.41M|        if (size_ < size)
  ------------------
  |  Branch (31:13): [True: 0, False: 3.41M]
  ------------------
   32|      0|            throw no_more_input{};
   33|  3.41M|        auto r = data_;
   34|  3.41M|        data_ += size;
   35|  3.41M|        size_ -= size;
   36|  3.41M|        return r;
   37|  3.41M|    }
array-gc.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer5arrayIiNS2_13memory_policyINS2_11heap_policyINS2_7gc_heapEEENS2_18no_refcount_policyENS2_15spinlock_policyENS2_20gc_transience_policyELb0ELb0EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  3.01k|{
   71|  3.01k|    auto x = read<T>(fz);
   72|   124k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 121k, False: 3.01k]
  ------------------
   73|   121k|        x = read<T>(fz);
   74|  3.01k|    return x;
   75|  3.01k|}
_Z4readIhERKT_R12fuzzer_input:
   64|   136k|{
   65|   136k|    return *reinterpret_cast<const T*>(fz.next(sizeof(T), alignof(T)));
   66|   136k|}
array-gc.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer5arrayIiNS2_13memory_policyINS2_11heap_policyINS2_7gc_heapEEENS2_18no_refcount_policyENS2_15spinlock_policyENS2_20gc_transience_policyELb0ELb0EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  2.86k|{
   71|  2.86k|    auto x = read<T>(fz);
   72|  6.12k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 3.26k, False: 2.86k]
  ------------------
   73|  3.26k|        x = read<T>(fz);
   74|  2.86k|    return x;
   75|  2.86k|}
array-gc.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_1clIN5immer15array_transientIiNS2_13memory_policyINS2_11heap_policyINS2_7gc_heapEEENS2_18no_refcount_policyENS2_15spinlock_policyENS2_20gc_transience_policyELb0ELb0EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  1.09k|{
   71|  1.09k|    auto x = read<T>(fz);
   72|  1.89k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 798, False: 1.09k]
  ------------------
   73|    798|        x = read<T>(fz);
   74|  1.09k|    return x;
   75|  1.09k|}
array-gc.cpp:_Z4readIhZZ22LLVMFuzzerTestOneInputENK3$_2clIN5immer15array_transientIiNS2_13memory_policyINS2_11heap_policyINS2_7gc_heapEEENS2_18no_refcount_policyENS2_15spinlock_policyENS2_20gc_transience_policyELb0ELb0EEEEEEEDaRT_EUlSD_E_ESD_R12fuzzer_inputT0_:
   70|  2.75k|{
   71|  2.75k|    auto x = read<T>(fz);
   72|  4.03k|    while (!cond(x))
  ------------------
  |  Branch (72:12): [True: 1.28k, False: 2.75k]
  ------------------
   73|  1.28k|        x = read<T>(fz);
   74|  2.75k|    return x;
   75|  2.75k|}

_ZN5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2Ev:
   71|  4.00k|    array() = default;
_ZNKR5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE9transientEv:
  307|  18.6k|    {
  308|  18.6k|        return transient_type{impl_};
  309|  18.6k|    }
_ZN5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2ENS_6detail6arrays11no_capacityIiS8_EE:
  330|  23.1k|        : impl_(std::move(impl))
  331|  23.1k|    {
  332|  23.1k|    }
_ZNK5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4sizeEv:
  142|  1.68M|    IMMER_NODISCARD std::size_t size() const { return impl_.size; }
_ZNKR5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE9push_backEi:
  212|  13.2k|    {
  213|  13.2k|        return impl_.push_back(std::move(value));
  214|  13.2k|    }
array-gc.cpp:_ZNKR5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSE_E_EES9_mOSE_:
  266|  2.98k|    {
  267|  2.98k|        return impl_.update(index, std::forward<FnT>(fn));
  268|  2.98k|    }
_ZNKR5immer5arrayIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4takeEm:
  293|  2.83k|    {
  294|  2.83k|        return impl_.take(elems);
  295|  2.83k|    }

_ZN5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2Ev:
   57|  4.00k|    array_transient() = default;
_ZN5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2ENS_6detail6arrays13with_capacityIiS8_EE:
  198|  18.6k|        : impl_(std::move(impl))
  199|  18.6k|    {
  200|  18.6k|    }
_ZNR5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE10persistentEv:
  185|  4.12k|    {
  186|  4.12k|        this->owner_t::operator=(owner_t{});
  187|  4.12k|        return persistent_type(impl_);
  188|  4.12k|    }
_ZN5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE9push_backEi:
  145|  1.46M|    {
  146|  1.46M|        impl_.push_back_mut(*this, std::move(value));
  147|  1.46M|    }
_ZNK5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4sizeEv:
   96|  5.86k|    IMMER_NODISCARD std::size_t size() const { return impl_.size; }
array-gc.cpp:_ZN5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSE_E0_EEvmOSE_:
  169|  1.06k|    {
  170|  1.06k|        impl_.update_mut(*this, index, std::forward<FnT>(fn));
  171|  1.06k|    }
_ZN5immer15array_transientIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4takeEm:
  178|  2.72k|    void take(size_type elems) { impl_.take_mut(*this, elems); }

_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE5emptyEv:
   34|  27.1k|    {
   35|  27.1k|        static const no_capacity empty_{
   36|  27.1k|            node_t::make_n(0),
   37|  27.1k|            0,
   38|  27.1k|        };
   39|  27.1k|        return empty_;
   40|  27.1k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2EPNS1_4nodeIiSA_EEm:
   43|  50.3k|        : ptr{p}
   44|  50.3k|        , size{s}
   45|  50.3k|    {
   46|  50.3k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEED2Ev:
   80|  50.3k|    ~no_capacity() { dec(); }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE3decEv:
   89|  50.3k|    {
   90|  50.3k|        using immer::detail::get;
   91|  50.3k|        if (ptr->refs().dec())
  ------------------
  |  Branch (91:13): [True: 0, False: 50.3k]
  ------------------
   92|      0|            node_t::delete_n(ptr, size, size);
   93|  50.3k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2ERKSB_:
   49|  27.1k|        : no_capacity{other.ptr, other.size}
   50|  27.1k|    {
   51|  27.1k|        inc();
   52|  27.1k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE3incEv:
   83|  27.1k|    {
   84|  27.1k|        using immer::detail::get;
   85|  27.1k|        ptr->refs().inc();
   86|  27.1k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2EOSB_:
   55|  23.1k|        : no_capacity{empty()}
   56|  23.1k|    {
   57|  23.1k|        swap(*this, other);
   58|  23.1k|    }
_ZN5immer6detail6arrays4swapERNS1_11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEESC_:
   74|  46.3k|    {
   75|  46.3k|        using std::swap;
   76|  46.3k|        swap(x.ptr, y.ptr);
   77|  46.3k|        swap(x.size, y.size);
   78|  46.3k|    }
_ZN5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEaSEOSB_:
   68|  23.1k|    {
   69|  23.1k|        swap(*this, other);
   70|  23.1k|        return *this;
   71|  23.1k|    }
_ZNK5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE9push_backEi:
  163|  13.2k|    {
  164|  13.2k|        auto p = node_t::copy_n(size + 1, ptr, size);
  165|  13.2k|        IMMER_TRY {
  ------------------
  |  |   49|  13.2k|#define IMMER_TRY try
  ------------------
  166|  13.2k|            new (p->data() + size) T(std::move(value));
  167|  13.2k|            return {p, size + 1};
  168|  13.2k|        }
  169|  13.2k|        IMMER_CATCH (...) {
  170|      0|            node_t::delete_n(p, size, size + 1);
  171|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  172|      0|        }
  173|  13.2k|    }
array-gc.cpp:_ZNK5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6updateIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSG_E_EESB_mOSG_:
  190|  2.98k|    {
  191|  2.98k|        auto p = node_t::copy_n(size, ptr, size);
  192|  2.98k|        IMMER_TRY {
  ------------------
  |  |   49|  2.98k|#define IMMER_TRY try
  ------------------
  193|  2.98k|            auto& elem = p->data()[idx];
  194|  2.98k|            elem       = std::forward<Fn>(op)(std::move(elem));
  195|  2.98k|            return {p, size};
  196|  2.98k|        }
  197|  2.98k|        IMMER_CATCH (...) {
  198|      0|            node_t::delete_n(p, size, size);
  199|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  200|      0|        }
  201|  2.98k|    }
_ZNK5immer6detail6arrays11no_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4takeEm:
  204|  2.83k|    {
  205|  2.83k|        auto p = node_t::copy_n(sz, ptr, sz);
  206|  2.83k|        return {p, sz};
  207|  2.83k|    }

_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6make_nEm:
   69|  32.9k|    {
   70|  32.9k|        return new (heap::allocate(sizeof_n(n))) node_t{};
   71|  32.9k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE8sizeof_nEm:
   42|  32.9k|    {
   43|       |        return std::max(immer_offsetof(impl_t, d) +
  ------------------
  |  |   19|  32.9k|#define immer_offsetof offsetof
  ------------------
   44|  32.9k|                            decltype(impl_t::d)::get_storage_offset() +
   45|  32.9k|                            sizeof(T) * count,
   46|  32.9k|                        sizeof(node));
   47|  32.9k|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4refsEv:
   49|  1.64M|    refs_t& refs() const { return auto_const_cast(get<refs_t>(impl)); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4dataEv:
   55|  1.57M|    T* data() { return impl.d.get_storage_ptr(); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6copy_nEmPSB_m:
  111|  20.9k|    {
  112|  20.9k|        return copy_n(n, p->data(), p->data() + count);
  113|  20.9k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6copy_nIPiSD_TnNSt3__19enable_ifIXsr6detailE21compatible_sentinel_vIT_T0_EEbE4typeELb1EEEPSB_mSG_SH_:
   98|  32.9k|    {
   99|  32.9k|        auto p = make_n(n);
  100|  32.9k|        IMMER_TRY {
  ------------------
  |  |   49|  32.9k|#define IMMER_TRY try
  ------------------
  101|  32.9k|            detail::uninitialized_copy(first, last, p->data());
  102|  32.9k|            return p;
  103|  32.9k|        }
  104|  32.9k|        IMMER_CATCH (...) {
  105|      0|            heap::deallocate(sizeof_n(n), p);
  106|      0|            IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  107|      0|        }
  108|  32.9k|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE10can_mutateENS9_5applyIS6_E4type4editE:
   58|  1.46M|    {
   59|  1.46M|        return refs().unique() || ownee().can_mutate(e);
  ------------------
  |  Branch (59:16): [True: 0, False: 1.46M]
  |  Branch (59:35): [True: 1.45M, False: 6.09k]
  ------------------
   60|  1.46M|    }
_ZNK5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE5owneeEv:
   51|  1.46M|    const ownee_t& ownee() const { return get<ownee_t>(impl); }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6copy_eENS9_5applyIS6_E4type4editEmPSB_m:
  124|  11.9k|    {
  125|  11.9k|        return copy_e(e, n, p->data(), p->data() + count);
  126|  11.9k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6copy_eIPiEEPSB_NS9_5applyIS6_E4type4editEmT_SJ_:
  117|  11.9k|    {
  118|  11.9k|        auto p     = copy_n(n, first, last);
  119|  11.9k|        p->ownee() = e;
  120|  11.9k|        return p;
  121|  11.9k|    }
_ZN5immer6detail6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE5owneeEv:
   52|  11.9k|    ownee_t& ownee() { return get<ownee_t>(impl); }

_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE5emptyEv:
   36|  22.6k|    {
   37|  22.6k|        static const with_capacity empty_{node_t::make_n(1), 0, 1};
   38|  22.6k|        return empty_;
   39|  22.6k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2EPNS1_4nodeIiSA_EEmm:
   42|  53.3k|        : ptr{p}
   43|  53.3k|        , size{s}
   44|  53.3k|        , capacity{c}
   45|  53.3k|    {
   46|  53.3k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEED2Ev:
   87|  53.3k|    ~with_capacity() { dec(); }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE3decEv:
   96|  53.3k|    {
   97|  53.3k|        using immer::detail::get;
   98|  53.3k|        if (ptr->refs().dec())
  ------------------
  |  Branch (98:13): [True: 0, False: 53.3k]
  ------------------
   99|      0|            node_t::delete_n(ptr, size, capacity);
  100|  53.3k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2ERKSB_:
   49|  22.6k|        : with_capacity{other.ptr, other.size, other.capacity}
   50|  22.6k|    {
   51|  22.6k|        inc();
   52|  22.6k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE3incEv:
   90|  41.3k|    {
   91|  41.3k|        using immer::detail::get;
   92|  41.3k|        ptr->refs().inc();
   93|  41.3k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2ERKNS1_11no_capacityIiSA_EE:
   55|  18.6k|        : with_capacity{other.ptr, other.size, other.size}
   56|  18.6k|    {
   57|  18.6k|        inc();
   58|  18.6k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEC2EOSB_:
   61|  18.6k|        : with_capacity{empty()}
   62|  18.6k|    {
   63|  18.6k|        swap(*this, other);
   64|  18.6k|    }
_ZN5immer6detail6arrays4swapERNS1_13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEESC_:
   80|  49.3k|    {
   81|  49.3k|        using std::swap;
   82|  49.3k|        swap(x.ptr, y.ptr);
   83|  49.3k|        swap(x.size, y.size);
   84|  49.3k|        swap(x.capacity, y.capacity);
   85|  49.3k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEaSEOSB_:
   74|  30.6k|    {
   75|  30.6k|        swap(*this, other);
   76|  30.6k|        return *this;
   77|  30.6k|    }
_ZNK5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEEcvNS1_11no_capacityIiSA_EEEv:
  116|  4.12k|    {
  117|  4.12k|        if (size == capacity) {
  ------------------
  |  Branch (117:13): [True: 2.21k, False: 1.91k]
  ------------------
  118|  2.21k|            ptr->refs().inc();
  119|  2.21k|            return {ptr, size};
  120|  2.21k|        } else {
  121|  1.91k|            return {node_t::copy_n(size, ptr, size), size};
  122|  1.91k|        }
  123|  4.12k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE13push_back_mutENS9_5applyIS6_E4type4editEi:
  211|  1.46M|    {
  212|  1.46M|        if (ptr->can_mutate(e) && capacity > size) {
  ------------------
  |  Branch (212:13): [True: 1.45M, False: 4.49k]
  |  Branch (212:35): [True: 1.45M, False: 5.86k]
  ------------------
  213|  1.45M|            new (data() + size) T(std::move(value));
  214|  1.45M|            ++size;
  215|  1.45M|        } else {
  216|  10.3k|            auto cap = recommend_up(size + 1, capacity);
  217|  10.3k|            auto p   = node_t::copy_e(e, cap, ptr, size);
  218|  10.3k|            IMMER_TRY {
  ------------------
  |  |   49|  10.3k|#define IMMER_TRY try
  ------------------
  219|  10.3k|                new (p->data() + size) T(std::move(value));
  220|  10.3k|                *this = {p, size + 1, cap};
  221|  10.3k|            }
  222|  10.3k|            IMMER_CATCH (...) {
  223|      0|                node_t::delete_n(p, size, cap);
  224|      0|                IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  225|      0|            }
  226|  10.3k|        }
  227|  1.46M|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE4dataEv:
  103|  1.45M|    T* data() { return ptr->data(); }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE12recommend_upEmm:
  180|  10.3k|    {
  181|  10.3k|        auto max = std::numeric_limits<size_t>::max();
  182|  10.3k|        return sz <= cap        ? cap
  ------------------
  |  Branch (182:16): [True: 1.22k, False: 9.13k]
  ------------------
  183|  10.3k|               : cap >= max / 2 ? max
  ------------------
  |  Branch (183:18): [True: 0, False: 9.13k]
  ------------------
  184|       |                                /* otherwise */
  185|  9.13k|                                : std::max(2 * cap, sz);
  186|  10.3k|    }
array-gc.cpp:_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE10update_mutIZZ22LLVMFuzzerTestOneInputENK3$_4clI12fuzzer_inputEEDaRT_EUlSG_E0_EEvNS9_5applyIS6_E4type4editEmOSG_:
  276|  1.06k|    {
  277|  1.06k|        if (ptr->can_mutate(e)) {
  ------------------
  |  Branch (277:13): [True: 685, False: 384]
  ------------------
  278|    685|            auto& elem = data()[idx];
  279|    685|            elem       = std::forward<Fn>(op)(std::move(elem));
  280|    685|        } else {
  281|    384|            auto p = node_t::copy_e(e, capacity, ptr, size);
  282|    384|            IMMER_TRY {
  ------------------
  |  |   49|    384|#define IMMER_TRY try
  ------------------
  283|    384|                auto& elem = p->data()[idx];
  284|    384|                elem       = std::forward<Fn>(op)(std::move(elem));
  285|    384|                *this      = {p, size, capacity};
  286|    384|            }
  287|    384|            IMMER_CATCH (...) {
  288|      0|                node_t::delete_n(p, size, capacity);
  289|      0|                IMMER_RETHROW;
  ------------------
  |  |   52|      0|#define IMMER_RETHROW throw
  ------------------
  290|      0|            }
  291|    384|        }
  292|  1.06k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE8take_mutENS9_5applyIS6_E4type4editEm:
  303|  2.72k|    {
  304|  2.72k|        assert(sz <= size);
  ------------------
  |  Branch (304:9): [True: 2.72k, False: 0]
  ------------------
  305|  2.72k|        if (ptr->can_mutate(e)) {
  ------------------
  |  Branch (305:13): [True: 1.50k, False: 1.21k]
  ------------------
  306|  1.50k|            detail::destroy_n(data() + size, size - sz);
  307|  1.50k|            size = sz;
  308|  1.50k|        } else {
  309|  1.21k|            auto cap = recommend_down(sz, capacity);
  310|  1.21k|            auto p   = node_t::copy_e(e, cap, ptr, sz);
  311|  1.21k|            *this    = {p, sz, cap};
  312|  1.21k|        }
  313|  2.72k|    }
_ZN5immer6detail6arrays13with_capacityIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE14recommend_downEmm:
  189|  1.21k|    {
  190|  1.21k|        return sz == 0        ? 1
  ------------------
  |  Branch (190:16): [True: 643, False: 572]
  ------------------
  191|  1.21k|               : sz < cap / 2 ? sz * 2
  ------------------
  |  Branch (191:18): [True: 307, False: 265]
  ------------------
  192|    572|                              :
  193|    572|                              /* otherwise */ cap;
  194|  1.21k|    }

_ZN5immer6detail3csl3getINS_18no_refcount_policyEEEDcRKNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEES3_NS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tENS1_7inheritIS3_NS1_6memberINSC_5applyISA_E4type5owneeEvE4typeEE4typeEE4typeE:
  170|  1.64M|        {
  171|  1.64M|            return x.get_(type_t<U>{});
  172|  1.64M|        }
_ZNK5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tENS1_7inheritIS9_NS1_6memberINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_IS9_EEDcNS1_6type_tIT_EE:
  184|  1.64M|        {
  185|  1.64M|            return n.get_(t);
  186|  1.64M|        }
_ZNK5immer6detail3csl7inheritINS_18no_refcount_policyENS1_6memberINS_20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeEvE4typeEE4type4get_ENS1_6type_tIS3_EE:
   82|  1.64M|        const T& get_(type_t<T>) const { return *this; }
_ZN5immer6detail3csl3getINS_20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeEEEDcRKNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyIS7_NS_18no_refcount_policyENS_15spinlock_policyES3_Lb0ELb0EEEE6data_tENS1_7inheritISF_NS1_6memberISA_vE4typeEE4typeEE4typeE:
  170|  1.46M|        {
  171|  1.46M|            return x.get_(type_t<U>{});
  172|  1.46M|        }
_ZNK5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tENS1_7inheritIS9_NS1_6memberINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE:
  184|  1.46M|        {
  185|  1.46M|            return n.get_(t);
  186|  1.46M|        }
_ZNK5immer6detail3csl6memberINS_20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE:
  151|  1.46M|        const T& get_(type_t<T>) const { return d; }
_ZN5immer6detail3csl3getINS_20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeEEEDcRNS1_10member_twoINS0_6arrays4nodeIiNS_13memory_policyIS7_NS_18no_refcount_policyENS_15spinlock_policyES3_Lb0ELb0EEEE6data_tENS1_7inheritISF_NS1_6memberISA_vE4typeEE4typeEE4typeE:
  165|  11.9k|        {
  166|  11.9k|            return x.get_(type_t<U>{});
  167|  11.9k|        }
_ZN5immer6detail3csl10member_twoINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tENS1_7inheritIS9_NS1_6memberINSB_5applyIS8_E4type5owneeEvE4typeEE4typeEE4type4get_ISK_EEDcNS1_6type_tIT_EE:
  179|  11.9k|        {
  180|  11.9k|            return n.get_(t);
  181|  11.9k|        }
_ZN5immer6detail3csl6memberINS_20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeEvE4type4get_ENS1_6type_tISA_EE:
  150|  11.9k|        T& get_(type_t<T>) { return d; }

_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tEiLb1EE18get_storage_offsetEv:
   87|  32.9k|    {
   88|  32.9k|        check_base();
   89|  32.9k|        return 0;
   90|  32.9k|    }
_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tEiLb1EE10check_baseEv:
   94|  1.61M|    {
   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.61M|        static_assert(std::is_standard_layout<Derived>::value,
  100|  1.61M|                      "Please remove 'true' if the derived class is non emtpy");
  101|  1.61M|    }
_ZN5immer6detail15auto_const_castINS_18no_refcount_policyEEERT_RKS3_:
  143|  1.64M|{
  144|  1.64M|    return const_cast<T&>(x);
  145|  1.64M|}
_ZN5immer6detail9destroy_nIPimEENSt3__19enable_ifIX20can_trivially_detroyIT_EES5_E4typeES5_T0_:
  188|  1.50k|{
  189|  1.50k|    return first + n;
  190|  1.50k|}
_ZN5immer6detail21with_trailing_storageINS0_6arrays4nodeIiNS_13memory_policyINS_11heap_policyINS_7gc_heapEEENS_18no_refcount_policyENS_15spinlock_policyENS_20gc_transience_policyELb0ELb0EEEE6data_tEiLb1EE15get_storage_ptrEv:
   75|  1.57M|    {
   76|  1.57M|        check_base();
   77|  1.57M|        return reinterpret_cast<T*>(this);
   78|  1.57M|    }
_ZN5immer6detail18uninitialized_copyIPiS2_S2_EENSt3__19enable_ifIX18can_trivially_copyIT_T1_EES6_E4typeES5_T0_S6_:
  236|  32.9k|{
  237|  32.9k|    return std::copy(first, last, out);
  238|  32.9k|}

_ZN5immer16gc_disable_guardC2Ev:
  137|  1.00k|    gc_disable_guard() { GC_disable(); }
_ZN5immer7gc_heap8allocateEm:
  106|  32.9k|    {
  107|  32.9k|        IMMER_GC_INIT_GUARD_;
  108|  32.9k|        auto p = GC_malloc(n);
  109|  32.9k|        if (IMMER_UNLIKELY(!p))
  ------------------
  |  |  116|  32.9k|#define IMMER_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
  |  |  ------------------
  |  |  |  Branch (116:30): [True: 0, False: 32.9k]
  |  |  ------------------
  ------------------
  110|      0|            IMMER_THROW(std::bad_alloc{});
  ------------------
  |  |   51|      0|#define IMMER_THROW(expr) throw expr
  ------------------
  111|  32.9k|        return p;
  112|  32.9k|    }
_ZN5immer7gc_heap8allocateEmNS_10norefs_tagE:
  115|  26.8k|    {
  116|  26.8k|        IMMER_GC_INIT_GUARD_;
  117|  26.8k|        auto p = GC_malloc_atomic(n);
  118|  26.8k|        if (IMMER_UNLIKELY(!p))
  ------------------
  |  |  116|  26.8k|#define IMMER_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
  |  |  ------------------
  |  |  |  Branch (116:30): [True: 0, False: 26.8k]
  |  |  ------------------
  ------------------
  119|      0|            IMMER_THROW(std::bad_alloc{});
  ------------------
  |  |   51|      0|#define IMMER_THROW(expr) throw expr
  ------------------
  120|  26.8k|        return p;
  121|  26.8k|    }
_ZN5immer16gc_disable_guardD2Ev:
  140|  1.00k|    {
  141|  1.00k|        GC_enable();
  142|  1.00k|        GC_gcollect();
  143|  1.00k|    }

_ZN5immer18no_refcount_policyC2Ev:
   22|  32.9k|    no_refcount_policy(){};
_ZN5immer18no_refcount_policy3decEv:
   26|   103k|    bool dec() { return false; }
_ZN5immer18no_refcount_policy3incEv:
   25|  70.7k|    void inc() {}
_ZN5immer18no_refcount_policy6uniqueEv:
   27|  1.46M|    bool unique() { return false; }

_ZN5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5ownerC2Ev:
   60|  26.8k|                    : token_{make_token_()}
   61|  26.8k|                {
   62|  26.8k|                }
_ZN5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owner11make_token_Ev:
   51|  26.8k|                {
   52|  26.8k|                    return heap_::allocate(1, norefs_tag{});
   53|  26.8k|                };
_ZN5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneraSEOS7_:
   79|  22.8k|                {
   80|  22.8k|                    token_ = o.token_.load();
   81|  22.8k|                    return *this;
   82|  22.8k|                }
_ZNK5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5ownee10can_mutateENS6_4editE:
   99|  1.46M|                bool can_mutate(edit t) const { return token_ == t; }
_ZNK5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type4editeqES7_:
   44|  1.46M|                bool operator==(edit x) const { return v == x.v; }
_ZN5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5owneeaSENS6_4editE:
   90|  11.9k|                {
   91|  11.9k|                    assert(e != noone);
  ------------------
  |  Branch (91:21): [True: 11.9k, False: 0]
  ------------------
   92|       |                    // This would be a nice safety plug but it sadly
   93|       |                    // does not hold during transient concatenation.
   94|       |                    // assert(token_ == e || token_ == edit{nullptr});
   95|  11.9k|                    token_ = e;
   96|  11.9k|                    return *this;
   97|  11.9k|                }
_ZNK5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type4editneES7_:
   45|  11.9k|                bool operator!=(edit x) const { return v != x.v; }
_ZN5immer20gc_transience_policy5applyINS_11heap_policyINS_7gc_heapEEEE4type5ownercvNS6_4editEEv:
   57|  1.47M|                operator edit() { return {token_}; }