begin
    Ct_lvl = ((ex.bodies[1]).bodies[1]).tns.bind.lvl
    Ct_lvl_2 = Ct_lvl.lvl
    Ct_lvl_3 = Ct_lvl_2.lvl
    Ct_lvl_3_val = Ct_lvl_3.val
    A_lvl = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[1]).tns.bind.lvl
    A_lvl_ptr = A_lvl.ptr
    A_lvl_tbl1 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[1]).tns.bind.lvl.tbl[1]
    A_lvl_stop1 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[1]).tns.bind.lvl.shape[1]
    A_lvl_tbl2 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[1]).tns.bind.lvl.tbl[2]
    A_lvl_stop2 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[1]).tns.bind.lvl.shape[2]
    A_lvl_2 = A_lvl.lvl
    A_lvl_2_val = A_lvl_2.val
    B_lvl = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[2]).tns.bind.lvl
    B_lvl_ptr = B_lvl.ptr
    B_lvl_tbl1 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[2]).tns.bind.lvl.tbl[1]
    B_lvl_stop1 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[2]).tns.bind.lvl.shape[1]
    B_lvl_tbl2 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[2]).tns.bind.lvl.tbl[2]
    B_lvl_stop2 = (((ex.bodies[1]).bodies[2]).body.body.body.rhs.args[2]).tns.bind.lvl.shape[2]
    B_lvl_2 = B_lvl.lvl
    B_lvl_2_val = B_lvl_2.val
    n = (Base.Threads).nthreads()
    n_2 = (Base.Threads).nthreads()
    B_lvl_stop1 == A_lvl_stop2 || throw(DimensionMismatch("mismatched dimension limits ($(B_lvl_stop1) != $(A_lvl_stop2))"))
    @warn "Performance Warning: non-concordant traversal of A[i, k] (hint: most arrays prefer column major or first index fast, run in fast mode to ignore this warning)"
    pos_stop = A_lvl_stop1 * B_lvl_stop2
    Finch.resize_if_smaller!(Ct_lvl_3_val, pos_stop)
    Finch.fill_range!(Ct_lvl_3_val, 0x00000000, 1, pos_stop)
    Ct_lvl_3_val_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), Ct_lvl_3_val)
    B_lvl_2_val_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), B_lvl_2_val)
    B_lvl_ptr_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), B_lvl_ptr)
    B_lvl_tbl1_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), B_lvl_tbl1)
    B_lvl_tbl2_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), B_lvl_tbl2)
    A_lvl_2_val_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), A_lvl_2_val)
    A_lvl_ptr_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), A_lvl_ptr)
    A_lvl_tbl1_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), A_lvl_tbl1)
    A_lvl_tbl2_2 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id}(n)), A_lvl_tbl2)
    Threads.@threads :dynamic for tid = 1:n
            Finch.@barrier begin
                    @inbounds @fastmath(begin
                                Ct_lvl_3_val_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), Ct_lvl_3_val_2)
                                B_lvl_2_val_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), B_lvl_2_val_2)
                                B_lvl_ptr_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), B_lvl_ptr_2)
                                B_lvl_tbl1_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), B_lvl_tbl1_2)
                                B_lvl_tbl2_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), B_lvl_tbl2_2)
                                A_lvl_2_val_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), A_lvl_2_val_2)
                                A_lvl_ptr_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), A_lvl_ptr_2)
                                A_lvl_tbl1_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), A_lvl_tbl1_2)
                                A_lvl_tbl2_3 = (Finch).transfer((Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()), A_lvl_tbl2_2)
                                B_lvl_q = B_lvl_ptr_3[1]
                                B_lvl_q_stop = B_lvl_ptr_3[1 + 1]
                                if B_lvl_q < B_lvl_q_stop
                                    B_lvl_i_stop = B_lvl_tbl2_3[B_lvl_q_stop - 1]
                                else
                                    B_lvl_i_stop = 0
                                end
                                phase_start_2 = max(1, 1 + fld(B_lvl_stop2 * (tid + -1), n))
                                phase_stop_2 = min(B_lvl_stop2, B_lvl_i_stop, fld(B_lvl_stop2 * tid, n))
                                if phase_stop_2 >= phase_start_2
                                    j = phase_start_2
                                    if B_lvl_tbl2_3[B_lvl_q] < phase_start_2
                                        B_lvl_q = Finch.scansearch(B_lvl_tbl2_3, phase_start_2, B_lvl_q, B_lvl_q_stop - 1)
                                    end
                                    while true
                                        B_lvl_i = B_lvl_tbl2_3[B_lvl_q]
                                        B_lvl_q_step = B_lvl_q
                                        if B_lvl_tbl2_3[B_lvl_q] == B_lvl_i
                                            B_lvl_q_step = Finch.scansearch(B_lvl_tbl2_3, B_lvl_i + 1, B_lvl_q, B_lvl_q_stop - 1)
                                        end
                                        if B_lvl_i < phase_stop_2
                                            for j_7 = j:-1 + B_lvl_i
                                                Threads.@threads :dynamic for tid_2 = 1:n_2
                                                        Finch.@barrier begin
                                                                @inbounds @fastmath(begin
                                                                            phase_start_5 = max(1, 1 + fld(A_lvl_stop1 * tid_2, n_2))
                                                                            if A_lvl_stop1 >= phase_start_5
                                                                                A_lvl_stop1 + 1
                                                                            end
                                                                        end)
                                                                nothing
                                                            end
                                                    end
                                            end
                                            Ct_lvl_q = (1 - 1) * B_lvl_stop2 + B_lvl_i
                                            Ct_lvl_3_val_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), Ct_lvl_3_val_3)
                                            A_lvl_2_val_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_2_val_3)
                                            A_lvl_ptr_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_ptr_3)
                                            A_lvl_tbl1_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_tbl1_3)
                                            A_lvl_tbl2_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_tbl2_3)
                                            B_lvl_2_val_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), B_lvl_2_val_3)
                                            (Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2))
                                            B_lvl_tbl1_4 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), B_lvl_tbl1_3)
                                            (Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2))
                                            Threads.@threads :dynamic for tid_3 = 1:n_2
                                                    Finch.@barrier begin
                                                            @inbounds @fastmath(begin
                                                                        Ct_lvl_3_val_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), Ct_lvl_3_val_4)
                                                                        A_lvl_2_val_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_2_val_4)
                                                                        A_lvl_ptr_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_ptr_4)
                                                                        A_lvl_tbl1_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_tbl1_4)
                                                                        A_lvl_tbl2_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_tbl2_4)
                                                                        B_lvl_2_val_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), B_lvl_2_val_4)
                                                                        (Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()))
                                                                        B_lvl_tbl1_5 = (Finch).transfer((Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), B_lvl_tbl1_4)
                                                                        (Finch.CPUThread)(tid_3, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()))
                                                                        phase_start_7 = max(1, 1 + fld(A_lvl_stop1 * (-1 + tid_3), n_2))
                                                                        phase_stop_8 = min(A_lvl_stop1, fld(A_lvl_stop1 * tid_3, n_2))
                                                                        if phase_stop_8 >= phase_start_7
                                                                            for i_10 = phase_start_7:phase_stop_8
                                                                                Ct_lvl_2_q = (Ct_lvl_q - 1) * A_lvl_stop1 + i_10
                                                                                B_lvl_q_2 = B_lvl_q
                                                                                if B_lvl_q < B_lvl_q_step
                                                                                    B_lvl_i_stop_2 = B_lvl_tbl1_5[B_lvl_q_step - 1]
                                                                                else
                                                                                    B_lvl_i_stop_2 = 0
                                                                                end
                                                                                A_lvl_q = A_lvl_ptr_5[1]
                                                                                A_lvl_q_stop = A_lvl_ptr_5[1 + 1]
                                                                                if A_lvl_q < A_lvl_q_stop
                                                                                    A_lvl_i_stop = A_lvl_tbl2_5[A_lvl_q_stop - 1]
                                                                                else
                                                                                    A_lvl_i_stop = 0
                                                                                end
                                                                                phase_stop_9 = min(B_lvl_stop1, B_lvl_i_stop_2, A_lvl_i_stop)
                                                                                if phase_stop_9 >= 1
                                                                                    k = 1
                                                                                    if B_lvl_tbl1_5[B_lvl_q] < 1
                                                                                        B_lvl_q_2 = Finch.scansearch(B_lvl_tbl1_5, 1, B_lvl_q, B_lvl_q_step - 1)
                                                                                    end
                                                                                    if A_lvl_tbl2_5[A_lvl_q] < 1
                                                                                        A_lvl_q = Finch.scansearch(A_lvl_tbl2_5, 1, A_lvl_q, A_lvl_q_stop - 1)
                                                                                    end
                                                                                    while k <= phase_stop_9
                                                                                        B_lvl_i_2 = B_lvl_tbl1_5[B_lvl_q_2]
                                                                                        A_lvl_i = A_lvl_tbl2_5[A_lvl_q]
                                                                                        A_lvl_q_step = A_lvl_q
                                                                                        if A_lvl_tbl2_5[A_lvl_q] == A_lvl_i
                                                                                            A_lvl_q_step = Finch.scansearch(A_lvl_tbl2_5, A_lvl_i + 1, A_lvl_q, A_lvl_q_stop - 1)
                                                                                        end
                                                                                        phase_stop_10 = min(A_lvl_i, phase_stop_9, B_lvl_i_2)
                                                                                        if B_lvl_i_2 == phase_stop_10 && A_lvl_i == phase_stop_10
                                                                                            B_lvl_2_val_6 = B_lvl_2_val_5[B_lvl_q_2]
                                                                                            A_lvl_q_2 = A_lvl_q
                                                                                            if A_lvl_q < A_lvl_q_step
                                                                                                A_lvl_i_stop_2 = A_lvl_tbl1_5[A_lvl_q_step - 1]
                                                                                            else
                                                                                                A_lvl_i_stop_2 = 0
                                                                                            end
                                                                                            phase_stop_11 = min(i_10, A_lvl_i_stop_2)
                                                                                            if phase_stop_11 >= i_10
                                                                                                if A_lvl_tbl1_5[A_lvl_q] < i_10
                                                                                                    A_lvl_q_2 = Finch.scansearch(A_lvl_tbl1_5, i_10, A_lvl_q, A_lvl_q_step - 1)
                                                                                                end
                                                                                                while true
                                                                                                    A_lvl_i_2 = A_lvl_tbl1_5[A_lvl_q_2]
                                                                                                    if A_lvl_i_2 < phase_stop_11
                                                                                                        A_lvl_2_val_6 = A_lvl_2_val_5[A_lvl_q_2]
                                                                                                        Ct_lvl_3_val_5[Ct_lvl_2_q] = B_lvl_2_val_6 * A_lvl_2_val_6 + Ct_lvl_3_val_5[Ct_lvl_2_q]
                                                                                                        A_lvl_q_2 += 1
                                                                                                    else
                                                                                                        phase_stop_13 = min(phase_stop_11, A_lvl_i_2)
                                                                                                        if A_lvl_i_2 == phase_stop_13
                                                                                                            A_lvl_2_val_6 = A_lvl_2_val_5[A_lvl_q_2]
                                                                                                            Ct_lvl_3_val_5[Ct_lvl_2_q] += B_lvl_2_val_6 * A_lvl_2_val_6
                                                                                                            A_lvl_q_2 += 1
                                                                                                        end
                                                                                                        break
                                                                                                    end
                                                                                                end
                                                                                            end
                                                                                            B_lvl_q_2 += 1
                                                                                            A_lvl_q = A_lvl_q_step
                                                                                        elseif A_lvl_i == phase_stop_10
                                                                                            A_lvl_q = A_lvl_q_step
                                                                                        elseif B_lvl_i_2 == phase_stop_10
                                                                                            B_lvl_q_2 += 1
                                                                                        end
                                                                                        k = phase_stop_10 + 1
                                                                                    end
                                                                                end
                                                                            end
                                                                        end
                                                                        phase_start_16 = max(1, 1 + fld(A_lvl_stop1 * tid_3, n_2))
                                                                        if A_lvl_stop1 >= phase_start_16
                                                                            A_lvl_stop1 + 1
                                                                        end
                                                                    end)
                                                            nothing
                                                        end
                                                end
                                            Ct_lvl_3_val_3 = (Finch).transfer(Ct_lvl_3_val_3, Ct_lvl_3_val_4)
                                            B_lvl_q = B_lvl_q_step
                                            j = B_lvl_i + 1
                                        else
                                            phase_stop_19 = min(phase_stop_2, B_lvl_i)
                                            if B_lvl_i == phase_stop_19
                                                for j_9 = j:-1 + phase_stop_19
                                                    Threads.@threads :dynamic for tid_4 = 1:n_2
                                                            Finch.@barrier begin
                                                                    @inbounds @fastmath(begin
                                                                                phase_start_20 = max(1, 1 + fld(A_lvl_stop1 * tid_4, n_2))
                                                                                if A_lvl_stop1 >= phase_start_20
                                                                                    A_lvl_stop1 + 1
                                                                                end
                                                                            end)
                                                                    nothing
                                                                end
                                                        end
                                                end
                                                Ct_lvl_q = (1 - 1) * B_lvl_stop2 + phase_stop_19
                                                Ct_lvl_3_val_6 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), Ct_lvl_3_val_3)
                                                A_lvl_2_val_7 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_2_val_3)
                                                A_lvl_ptr_6 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_ptr_3)
                                                A_lvl_tbl1_6 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_tbl1_3)
                                                A_lvl_tbl2_6 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), A_lvl_tbl2_3)
                                                B_lvl_2_val_8 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), B_lvl_2_val_3)
                                                (Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2))
                                                B_lvl_tbl1_6 = (Finch).transfer((Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2)), B_lvl_tbl1_3)
                                                (Finch.CPUSharedMemory)(Finch.CPU{:id_2}(n_2))
                                                Threads.@threads :dynamic for tid_5 = 1:n_2
                                                        Finch.@barrier begin
                                                                @inbounds @fastmath(begin
                                                                            Ct_lvl_3_val_7 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), Ct_lvl_3_val_6)
                                                                            A_lvl_2_val_8 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_2_val_7)
                                                                            A_lvl_ptr_7 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_ptr_6)
                                                                            A_lvl_tbl1_7 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_tbl1_6)
                                                                            A_lvl_tbl2_7 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), A_lvl_tbl2_6)
                                                                            B_lvl_2_val_9 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), B_lvl_2_val_8)
                                                                            (Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()))
                                                                            B_lvl_tbl1_7 = (Finch).transfer((Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)())), B_lvl_tbl1_6)
                                                                            (Finch.CPUThread)(tid_5, Finch.CPU{:id_2}(n_2), (Finch.CPUThread)(tid, Finch.CPU{:id}(n), (Finch.SerialTask)()))
                                                                            phase_start_22 = max(1, 1 + fld(A_lvl_stop1 * (-1 + tid_5), n_2))
                                                                            phase_stop_24 = min(A_lvl_stop1, fld(A_lvl_stop1 * tid_5, n_2))
                                                                            if phase_stop_24 >= phase_start_22
                                                                                for i_18 = phase_start_22:phase_stop_24
                                                                                    Ct_lvl_2_q_2 = (Ct_lvl_q - 1) * A_lvl_stop1 + i_18
                                                                                    B_lvl_q_3 = B_lvl_q
                                                                                    if B_lvl_q < B_lvl_q_step
                                                                                        B_lvl_i_stop_3 = B_lvl_tbl1_7[B_lvl_q_step - 1]
                                                                                    else
                                                                                        B_lvl_i_stop_3 = 0
                                                                                    end
                                                                                    A_lvl_q_3 = A_lvl_ptr_7[1]
                                                                                    A_lvl_q_stop_3 = A_lvl_ptr_7[1 + 1]
                                                                                    if A_lvl_q_3 < A_lvl_q_stop_3
                                                                                        A_lvl_i_stop_3 = A_lvl_tbl2_7[A_lvl_q_stop_3 - 1]
                                                                                    else
                                                                                        A_lvl_i_stop_3 = 0
                                                                                    end
                                                                                    phase_stop_25 = min(B_lvl_stop1, B_lvl_i_stop_3, A_lvl_i_stop_3)
                                                                                    if phase_stop_25 >= 1
                                                                                        k = 1
                                                                                        if B_lvl_tbl1_7[B_lvl_q] < 1
                                                                                            B_lvl_q_3 = Finch.scansearch(B_lvl_tbl1_7, 1, B_lvl_q, B_lvl_q_step - 1)
                                                                                        end
                                                                                        if A_lvl_tbl2_7[A_lvl_q_3] < 1
                                                                                            A_lvl_q_3 = Finch.scansearch(A_lvl_tbl2_7, 1, A_lvl_q_3, A_lvl_q_stop_3 - 1)
                                                                                        end
                                                                                        while k <= phase_stop_25
                                                                                            B_lvl_i_3 = B_lvl_tbl1_7[B_lvl_q_3]
                                                                                            A_lvl_i_3 = A_lvl_tbl2_7[A_lvl_q_3]
                                                                                            A_lvl_q_step_3 = A_lvl_q_3
                                                                                            if A_lvl_tbl2_7[A_lvl_q_3] == A_lvl_i_3
                                                                                                A_lvl_q_step_3 = Finch.scansearch(A_lvl_tbl2_7, A_lvl_i_3 + 1, A_lvl_q_3, A_lvl_q_stop_3 - 1)
                                                                                            end
                                                                                            phase_stop_26 = min(A_lvl_i_3, phase_stop_25, B_lvl_i_3)
                                                                                            if B_lvl_i_3 == phase_stop_26 && A_lvl_i_3 == phase_stop_26
                                                                                                B_lvl_2_val_10 = B_lvl_2_val_9[B_lvl_q_3]
                                                                                                A_lvl_q_4 = A_lvl_q_3
                                                                                                if A_lvl_q_3 < A_lvl_q_step_3
                                                                                                    A_lvl_i_stop_4 = A_lvl_tbl1_7[A_lvl_q_step_3 - 1]
                                                                                                else
                                                                                                    A_lvl_i_stop_4 = 0
                                                                                                end
                                                                                                phase_stop_27 = min(i_18, A_lvl_i_stop_4)
                                                                                                if phase_stop_27 >= i_18
                                                                                                    if A_lvl_tbl1_7[A_lvl_q_3] < i_18
                                                                                                        A_lvl_q_4 = Finch.scansearch(A_lvl_tbl1_7, i_18, A_lvl_q_3, A_lvl_q_step_3 - 1)
                                                                                                    end
                                                                                                    while true
                                                                                                        A_lvl_i_4 = A_lvl_tbl1_7[A_lvl_q_4]
                                                                                                        if A_lvl_i_4 < phase_stop_27
                                                                                                            A_lvl_2_val_9 = A_lvl_2_val_8[A_lvl_q_4]
                                                                                                            Ct_lvl_3_val_7[Ct_lvl_2_q_2] = B_lvl_2_val_10 * A_lvl_2_val_9 + Ct_lvl_3_val_7[Ct_lvl_2_q_2]
                                                                                                            A_lvl_q_4 += 1
                                                                                                        else
                                                                                                            phase_stop_29 = min(phase_stop_27, A_lvl_i_4)
                                                                                                            if A_lvl_i_4 == phase_stop_29
                                                                                                                A_lvl_2_val_9 = A_lvl_2_val_8[A_lvl_q_4]
                                                                                                                Ct_lvl_3_val_7[Ct_lvl_2_q_2] += B_lvl_2_val_10 * A_lvl_2_val_9
                                                                                                                A_lvl_q_4 += 1
                                                                                                            end
                                                                                                            break
                                                                                                        end
                                                                                                    end
                                                                                                end
                                                                                                B_lvl_q_3 += 1
                                                                                                A_lvl_q_3 = A_lvl_q_step_3
                                                                                            elseif A_lvl_i_3 == phase_stop_26
                                                                                                A_lvl_q_3 = A_lvl_q_step_3
                                                                                            elseif B_lvl_i_3 == phase_stop_26
                                                                                                B_lvl_q_3 += 1
                                                                                            end
                                                                                            k = phase_stop_26 + 1
                                                                                        end
                                                                                    end
                                                                                end
                                                                            end
                                                                            phase_start_31 = max(1, 1 + fld(A_lvl_stop1 * tid_5, n_2))
                                                                            if A_lvl_stop1 >= phase_start_31
                                                                                A_lvl_stop1 + 1
                                                                            end
                                                                        end)
                                                                nothing
                                                            end
                                                    end
                                                Ct_lvl_3_val_3 = (Finch).transfer(Ct_lvl_3_val_3, Ct_lvl_3_val_6)
                                                B_lvl_q = B_lvl_q_step
                                            else
                                                for j_11 = j:phase_stop_19
                                                    Threads.@threads :dynamic for tid_6 = 1:n_2
                                                            Finch.@barrier begin
                                                                    @inbounds @fastmath(begin
                                                                                phase_start_34 = max(1, 1 + fld(A_lvl_stop1 * tid_6, n_2))
                                                                                if A_lvl_stop1 >= phase_start_34
                                                                                    A_lvl_stop1 + 1
                                                                                end
                                                                            end)
                                                                    nothing
                                                                end
                                                        end
                                                end
                                            end
                                            j = phase_stop_19 + 1
                                            break
                                        end
                                    end
                                end
                                phase_start_37 = max(1, 1 + fld(B_lvl_stop2 * (tid + -1), n), 1 + B_lvl_i_stop)
                                phase_stop_40 = min(B_lvl_stop2, fld(B_lvl_stop2 * tid, n))
                                if phase_stop_40 >= phase_start_37
                                    for j_15 = phase_start_37:phase_stop_40
                                        Threads.@threads :dynamic for tid_7 = 1:n_2
                                                Finch.@barrier begin
                                                        @inbounds @fastmath(begin
                                                                    phase_start_40 = max(1, 1 + fld(A_lvl_stop1 * tid_7, n_2))
                                                                    if A_lvl_stop1 >= phase_start_40
                                                                        A_lvl_stop1 + 1
                                                                    end
                                                                end)
                                                        nothing
                                                    end
                                            end
                                    end
                                end
                                phase_start_41 = max(1, 1 + fld(B_lvl_stop2 * tid, n), 1 + B_lvl_i_stop)
                                if B_lvl_stop2 >= phase_start_41
                                    B_lvl_stop2 + 1
                                end
                            end)
                    nothing
                end
        end
    resize!(Ct_lvl_3_val_2, A_lvl_stop1 * B_lvl_stop2)
    (Ct = Tensor((DenseLevel){Int32}((DenseLevel){Int32}(ElementLevel{0x00000000, UInt32, Int32}(Ct_lvl_3_val_2), A_lvl_stop1), B_lvl_stop2)),)
end
