julia> A = Tensor(Dense(SparseList(Element(0.0))), [0 0 3.3; 1.1 0 0; 2.2 0 4.4; 0 0 5.5])
4×3 Tensor{DenseLevel{Int64, SparseListLevel{Int64, Vector{Int64}, Vector{Int64}, ElementLevel{0.0, Float64, Int64, Vector{Float64}}}}}:
 0.0  0.0  3.3
 1.1  0.0  0.0
 2.2  0.0  4.4
 0.0  0.0  5.5
julia> B = Tensor(SparseDict(SparseDict(Element(0.0))))
0×0 Tensor{SparseDictLevel{Int64, Vector{Int64}, Vector{Int64}, Vector{Int64}, Dict{Tuple{Int64, Int64}, Int64}, Vector{Int64}, SparseDictLevel{Int64, Vector{Int64}, Vector{Int64}, Vector{Int64}, Dict{Tuple{Int64, Int64}, Int64}, Vector{Int64}, ElementLevel{0.0, Float64, Int64, Vector{Float64}}}}}
julia> @finch_code mode = :fast begin
        B .= 0
        for j = _
            for i = _
                B[j, i] = A[i, j]
            end
        end
    end
quote
    B_lvl = ((ex.bodies[1]).bodies[1]).tns.bind.lvl
    B_lvl_ptr = B_lvl.ptr
    B_lvl_idx = B_lvl.idx
    B_lvl_val = B_lvl.val
    B_lvl_tbl = B_lvl.tbl
    B_lvl_pool = B_lvl.pool
    B_lvl_2 = B_lvl.lvl
    B_lvl_ptr_2 = B_lvl_2.ptr
    B_lvl_idx_2 = B_lvl_2.idx
    B_lvl_val_2 = B_lvl_2.val
    B_lvl_tbl_2 = B_lvl_2.tbl
    B_lvl_pool_2 = B_lvl_2.pool
    B_lvl_3 = B_lvl_2.lvl
    B_lvl_2_val = B_lvl_2.lvl.val
    A_lvl = ((ex.bodies[1]).bodies[2]).body.body.rhs.tns.bind.lvl
    A_lvl_2 = A_lvl.lvl
    A_lvl_ptr = A_lvl_2.ptr
    A_lvl_idx = A_lvl_2.idx
    A_lvl_2_val = A_lvl_2.lvl.val
    empty!(B_lvl_tbl)
    empty!(B_lvl_pool)
    B_lvl_qos_stop = 0
    empty!(B_lvl_tbl_2)
    empty!(B_lvl_pool_2)
    B_lvl_qos_stop_2 = 0
    for j_4 = 1:A_lvl.shape
        A_lvl_q = (1 - 1) * A_lvl.shape + j_4
        A_lvl_2_q = A_lvl_ptr[A_lvl_q]
        A_lvl_2_q_stop = A_lvl_ptr[A_lvl_q + 1]
        if A_lvl_2_q < A_lvl_2_q_stop
            A_lvl_2_i1 = A_lvl_idx[A_lvl_2_q_stop - 1]
        else
            A_lvl_2_i1 = 0
        end
        phase_stop = min(A_lvl_2_i1, A_lvl_2.shape)
        if phase_stop >= 1
            if A_lvl_idx[A_lvl_2_q] < 1
                A_lvl_2_q = Finch.scansearch(A_lvl_idx, 1, A_lvl_2_q, A_lvl_2_q_stop - 1)
            end
            while true
                A_lvl_2_i = A_lvl_idx[A_lvl_2_q]
                if A_lvl_2_i < phase_stop
                    A_lvl_3_val = A_lvl_2_val[A_lvl_2_q]
                    B_lvl_qos = get(B_lvl_tbl, (1, A_lvl_2_i), 0)
                    if B_lvl_qos == 0
                        if !(isempty(B_lvl_pool))
                            B_lvl_qos = pop!(B_lvl_pool)
                        else
                            B_lvl_qos = length(B_lvl_tbl) + 1
                            if B_lvl_qos > B_lvl_qos_stop
                                B_lvl_qos_stop = max(B_lvl_qos_stop << 1, 1)
                                Finch.resize_if_smaller!(B_lvl_val, B_lvl_qos_stop)
                                Finch.fill_range!(B_lvl_val, 0, B_lvl_qos, B_lvl_qos_stop)
                            end
                        end
                        B_lvl_tbl[(1, A_lvl_2_i)] = B_lvl_qos
                    end
                    B_lvl_dirty = false
                    B_lvl_2_qos = get(B_lvl_tbl_2, (B_lvl_qos, j_4), 0)
                    if B_lvl_2_qos == 0
                        if !(isempty(B_lvl_pool_2))
                            B_lvl_2_qos = pop!(B_lvl_pool_2)
                        else
                            B_lvl_2_qos = length(B_lvl_tbl_2) + 1
                            if B_lvl_2_qos > B_lvl_qos_stop_2
                                B_lvl_qos_stop_2 = max(B_lvl_qos_stop_2 << 1, 1)
                                Finch.resize_if_smaller!(B_lvl_2_val, B_lvl_qos_stop_2)
                                Finch.fill_range!(B_lvl_2_val, 0.0, B_lvl_2_qos, B_lvl_qos_stop_2)
                                Finch.resize_if_smaller!(B_lvl_val_2, B_lvl_qos_stop_2)
                                Finch.fill_range!(B_lvl_val_2, 0, B_lvl_2_qos, B_lvl_qos_stop_2)
                            end
                        end
                        B_lvl_tbl_2[(B_lvl_qos, j_4)] = B_lvl_2_qos
                    end
                    B_lvl_2_val[B_lvl_2_qos] = A_lvl_3_val
                    B_lvl_val_2[B_lvl_2_qos] = B_lvl_2_qos
                    B_lvl_dirty = true
                    if B_lvl_dirty
                        B_lvl_val[B_lvl_qos] = B_lvl_qos
                    elseif B_lvl_val[B_lvl_qos] == 0
                        push!(B_lvl_pool, B_lvl_qos)
                        delete!(B_lvl_tbl, (1, A_lvl_2_i))
                    end
                    A_lvl_2_q += 1
                else
                    phase_stop_3 = min(phase_stop, A_lvl_2_i)
                    if A_lvl_2_i == phase_stop_3
                        A_lvl_3_val = A_lvl_2_val[A_lvl_2_q]
                        B_lvl_qos = get(B_lvl_tbl, (1, phase_stop_3), 0)
                        if B_lvl_qos == 0
                            if !(isempty(B_lvl_pool))
                                B_lvl_qos = pop!(B_lvl_pool)
                            else
                                B_lvl_qos = length(B_lvl_tbl) + 1
                                if B_lvl_qos > B_lvl_qos_stop
                                    B_lvl_qos_stop = max(B_lvl_qos_stop << 1, 1)
                                    Finch.resize_if_smaller!(B_lvl_val, B_lvl_qos_stop)
                                    Finch.fill_range!(B_lvl_val, 0, B_lvl_qos, B_lvl_qos_stop)
                                end
                            end
                            B_lvl_tbl[(1, phase_stop_3)] = B_lvl_qos
                        end
                        B_lvl_dirty = false
                        B_lvl_2_qos_2 = get(B_lvl_tbl_2, (B_lvl_qos, j_4), 0)
                        if B_lvl_2_qos_2 == 0
                            if !(isempty(B_lvl_pool_2))
                                B_lvl_2_qos_2 = pop!(B_lvl_pool_2)
                            else
                                B_lvl_2_qos_2 = length(B_lvl_tbl_2) + 1
                                if B_lvl_2_qos_2 > B_lvl_qos_stop_2
                                    B_lvl_qos_stop_2 = max(B_lvl_qos_stop_2 << 1, 1)
                                    Finch.resize_if_smaller!(B_lvl_2_val, B_lvl_qos_stop_2)
                                    Finch.fill_range!(B_lvl_2_val, 0.0, B_lvl_2_qos_2, B_lvl_qos_stop_2)
                                    Finch.resize_if_smaller!(B_lvl_val_2, B_lvl_qos_stop_2)
                                    Finch.fill_range!(B_lvl_val_2, 0, B_lvl_2_qos_2, B_lvl_qos_stop_2)
                                end
                            end
                            B_lvl_tbl_2[(B_lvl_qos, j_4)] = B_lvl_2_qos_2
                        end
                        B_lvl_2_val[B_lvl_2_qos_2] = A_lvl_3_val
                        B_lvl_val_2[B_lvl_2_qos_2] = B_lvl_2_qos_2
                        B_lvl_dirty = true
                        if B_lvl_dirty
                            B_lvl_val[B_lvl_qos] = B_lvl_qos
                        elseif B_lvl_val[B_lvl_qos] == 0
                            push!(B_lvl_pool, B_lvl_qos)
                            delete!(B_lvl_tbl, (1, phase_stop_3))
                        end
                        A_lvl_2_q += 1
                    end
                    break
                end
            end
        end
    end
    resize!(B_lvl_ptr, 1 + 1)
    B_lvl_ptr[1] = 1
    Finch.fill_range!(B_lvl_ptr, 0, 2, 1 + 1)
    pdx_tmp = Vector{Int64}(undef, length(B_lvl_tbl))
    resize!(B_lvl_idx, length(B_lvl_tbl))
    resize!(B_lvl_val, length(B_lvl_tbl))
    idx_tmp = Vector{Int64}(undef, length(B_lvl_tbl))
    val_tmp = Vector{Int64}(undef, length(B_lvl_tbl))
    q = 0
    for entry = pairs(B_lvl_tbl)
        sugar_2 = entry[1]
        p_2 = sugar_2[1]
        i_13 = sugar_2[2]
        v_8 = entry[2]
        q += 1
        idx_tmp[q] = i_13
        val_tmp[q] = v_8
        pdx_tmp[q] = p_2
        B_lvl_ptr[p_2 + 1] += 1
    end
    for p_2 = 2:1 + 1
        B_lvl_ptr[p_2] += B_lvl_ptr[p_2 - 1]
    end
    perm = sortperm(idx_tmp)
    ptr_2 = copy(B_lvl_ptr)
    for q = perm
        p_2 = pdx_tmp[q]
        r = ptr_2[p_2]
        B_lvl_idx[r] = idx_tmp[q]
        B_lvl_val[r] = val_tmp[q]
        ptr_2[p_2] += 1
    end
    qos_stop = B_lvl_ptr[1 + 1] - 1
    resize!(B_lvl_ptr_2, qos_stop + 1)
    B_lvl_ptr_2[1] = 1
    Finch.fill_range!(B_lvl_ptr_2, 0, 2, qos_stop + 1)
    pdx_tmp_2 = Vector{Int64}(undef, length(B_lvl_tbl_2))
    resize!(B_lvl_idx_2, length(B_lvl_tbl_2))
    resize!(B_lvl_val_2, length(B_lvl_tbl_2))
    idx_tmp_2 = Vector{Int64}(undef, length(B_lvl_tbl_2))
    val_tmp_2 = Vector{Int64}(undef, length(B_lvl_tbl_2))
    q_2 = 0
    for entry_2 = pairs(B_lvl_tbl_2)
        sugar_4 = entry_2[1]
        p_4 = sugar_4[1]
        i_14 = sugar_4[2]
        v_9 = entry_2[2]
        q_2 += 1
        idx_tmp_2[q_2] = i_14
        val_tmp_2[q_2] = v_9
        pdx_tmp_2[q_2] = p_4
        B_lvl_ptr_2[p_4 + 1] += 1
    end
    for p_4 = 2:qos_stop + 1
        B_lvl_ptr_2[p_4] += B_lvl_ptr_2[p_4 - 1]
    end
    perm_2 = sortperm(idx_tmp_2)
    ptr_3 = copy(B_lvl_ptr_2)
    for q_2 = perm_2
        p_4 = pdx_tmp_2[q_2]
        r_2 = ptr_3[p_4]
        B_lvl_idx_2[r_2] = idx_tmp_2[q_2]
        B_lvl_val_2[r_2] = val_tmp_2[q_2]
        ptr_3[p_4] += 1
    end
    qos_stop_2 = B_lvl_ptr_2[qos_stop + 1] - 1
    resize!(B_lvl_2_val, qos_stop_2)
    (B = Tensor((SparseDictLevel){Int64}((SparseDictLevel){Int64}(B_lvl_3, A_lvl.shape, B_lvl_ptr_2, B_lvl_idx_2, B_lvl_val_2, B_lvl_tbl_2, B_lvl_pool_2), A_lvl_2.shape, B_lvl_ptr, B_lvl_idx, B_lvl_val, B_lvl_tbl, B_lvl_pool)),)
end
julia> @finch mode = :fast begin
        B .= 0
        for j = _
            for i = _
                B[j, i] = A[i, j]
            end
        end
    end
(B = Tensor(SparseDict{Int64}(SparseDict{Int64}(Element{0.0, Float64, Int64}([1.1, 2.2, 3.3, 4.4, 5.5]), 3, [1, 2, 4, 5, 6], [1, 1, 3, 3, 3], [1, 2, 4, 3, 5], Dict((1, 1) => 1, (3, 3) => 3, (2, 1) => 2, (4, 3) => 5, (2, 3) => 4), Int64[]), 4, [1, 5], [1, 2, 3, 4], [3, 1, 2, 4], Dict((1, 2) => 1, (1, 1) => 3, (1, 3) => 2, (1, 4) => 4), Int64[])),)

