src/cpu-kernels/getitem.cpp

awkward_regularize_rangeslice
----------------------------------------------------

def awkward_regularize_rangeslice(
    start: List[int],
    stop: List[int],
    posstep: bool,
    hasstart: bool,
    hasstop: bool,
    length: int,
):
    if posstep:
        if not hasstart:
            start = 0
        else:
            if start < 0:
                start = length
        if start < 0:
            start = 0
        if start > length:
            start = length
        if not hasstop:
            stop = length
        else:
            if stop < 0:
                stop = length
        if stop < 0:
            stop = 0
        if stop > length:
            stop = length
        if stop < start:
            stop = start
    else:
        if not hasstart:
            start = length - 1
        else:
            if start < 0:
                start = length
        if start < -1:
            start = -1
        if start > (length - 1):
            start = length - 1
        if not hasstop:
            stop = -1
        else:
            if stop < 0:
                stop = length
        if stop < -1:
            stop = -1
        if stop > (length - 1):
            stop = length - 1
        if stop > start:
            stop = start


awkward_regularize_arrayslice
----------------------------------------------------

for T in int:

    def awkward_regularize_arrayslice(
        flatheadptr: List[T], lenflathead: int, length: int
    ):
        for i in range(lenflathead):
            original = flatheadptr[i]
            if flatheadptr[i] < 0:
                flatheadptr[i] = length
            if (flatheadptr[i] < 0) or (flatheadptr[i] >= length):
                raise ValueError("index out of range")
        return


awkward_regularize_arrayslice_64
----------------------------------------------------

def awkward_regularize_arrayslice_64(
    flatheadptr: List[int], lenflathead: int, length: int
):
    return awkward_regularize_arrayslice(flatheadptr, lenflathead, length)


awkward_index8_to_index64
----------------------------------------------------

def awkward_index8_to_index64(toptr: List[int], fromptr: List[int], length: int):
    for i in range(length):
        toptr[i] = int(fromptr[i])
    return


awkward_indexU8_to_index64
----------------------------------------------------

def awkward_indexU8_to_index64(toptr: List[int], fromptr: List[int], length: int):
    for i in range(length):
        toptr[i] = int(fromptr[i])
    return


awkward_index32_to_index64
----------------------------------------------------

def awkward_index32_to_index64(toptr: List[int], fromptr: List[int], length: int):
    for i in range(length):
        toptr[i] = int(fromptr[i])
    return


awkward_indexU32_to_index64
----------------------------------------------------

def awkward_indexU32_to_index64(toptr: List[int], fromptr: List[int], length: int):
    for i in range(length):
        toptr[i] = int(fromptr[i])
    return


awkward_index_carry
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_index_carry(
            toindex: List[C],
            fromindex: List[C],
            carry: List[T],
            fromindexoffset: int,
            lenfromindex: int,
            length: int,
        ):
            for i in range(length):
                j = carry[i]
                if j > lenfromindex:
                    raise ValueError("index out of range")
                toindex[i] = fromindex[fromindexoffset + j]
            return


awkward_index8_carry_64
----------------------------------------------------

def awkward_index8_carry_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    lenfromindex: int,
    length: int,
):
    return awkward_index_carry(
        toindex, fromindex, carry, fromindexoffset, lenfromindex, length
    )


awkward_indexU8_carry_64
----------------------------------------------------

def awkward_indexU8_carry_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    lenfromindex: int,
    length: int,
):
    return awkward_index_carry(
        toindex, fromindex, carry, fromindexoffset, lenfromindex, length
    )


awkward_index32_carry_64
----------------------------------------------------

def awkward_index32_carry_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    lenfromindex: int,
    length: int,
):
    return awkward_index_carry(
        toindex, fromindex, carry, fromindexoffset, lenfromindex, length
    )


awkward_indexU32_carry_64
----------------------------------------------------

def awkward_indexU32_carry_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    lenfromindex: int,
    length: int,
):
    return awkward_index_carry(
        toindex, fromindex, carry, fromindexoffset, lenfromindex, length
    )


awkward_index64_carry_64
----------------------------------------------------

def awkward_index64_carry_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    lenfromindex: int,
    length: int,
):
    return awkward_index_carry(
        toindex, fromindex, carry, fromindexoffset, lenfromindex, length
    )


awkward_index_carry_nocheck
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_index_carry_nocheck(
            toindex: List[C],
            fromindex: List[C],
            carry: List[T],
            fromindexoffset: int,
            length: int,
        ):
            for i in range(length):
                toindex[i] = fromindex[fromindexoffset + carry[i]]
            return


awkward_index8_carry_nocheck_64
----------------------------------------------------

def awkward_index8_carry_nocheck_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_index_carry_nocheck(
        toindex, fromindex, carry, fromindexoffset, length
    )


awkward_indexU8_carry_nocheck_64
----------------------------------------------------

def awkward_indexU8_carry_nocheck_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_index_carry_nocheck(
        toindex, fromindex, carry, fromindexoffset, length
    )


awkward_index32_carry_nocheck_64
----------------------------------------------------

def awkward_index32_carry_nocheck_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_index_carry_nocheck(
        toindex, fromindex, carry, fromindexoffset, length
    )


awkward_indexU32_carry_nocheck_64
----------------------------------------------------

def awkward_indexU32_carry_nocheck_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_index_carry_nocheck(
        toindex, fromindex, carry, fromindexoffset, length
    )


awkward_index64_carry_nocheck_64
----------------------------------------------------

def awkward_index64_carry_nocheck_64(
    toindex: List[int],
    fromindex: List[int],
    carry: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_index_carry_nocheck(
        toindex, fromindex, carry, fromindexoffset, length
    )


awkward_slicearray_ravel
----------------------------------------------------

for T in int:

    def awkward_slicearray_ravel(
        toptr: List[T],
        fromptr: List[T],
        ndim: int,
        shape: List[int],
        strides: List[int],
    ):
        if ndim == 1:
            for i in range(shape[0]):
                toptr[i] = fromptr[i * strides[0]]
        else:
            for i in range(shape[0]):
                err = awkward_slicearray_ravel(
                    toptr[i * shape[1]],
                    fromptr[i * strides[0]],
                    ndim - 1,
                    shape[1],
                    strides[1],
                )
                if err.str != nullptr:
                    return err
        return


awkward_slicearray_ravel_64
----------------------------------------------------

def awkward_slicearray_ravel_64(
    toptr: List[int],
    fromptr: List[int],
    ndim: int,
    shape: List[int],
    strides: List[int],
):
    return awkward_slicearray_ravel(toptr, fromptr, ndim, shape, strides)


awkward_slicemissing_check_same
----------------------------------------------------

def awkward_slicemissing_check_same(
    same: List[bool],
    bytemask: List[int],
    bytemaskoffset: int,
    missingindex: List[int],
    missingindexoffset: int,
    length: int,
):
    same = true
    for i in range(length):
        left = bytemask[bytemaskoffset + i] != 0
        right = missingindex[missingindexoffset + i] < 0
        if left != right:
            same = false
            return
    return


awkward_carry_arange
----------------------------------------------------

for T in int:

    def awkward_carry_arange(toptr: List[T], length: int):
        for i in range(length):
            toptr[i] = i
        return


awkward_carry_arange_32
----------------------------------------------------

def awkward_carry_arange_32(toptr: List[int], length: int):
    return awkward_carry_arange(toptr, length)


awkward_carry_arange_U32
----------------------------------------------------

def awkward_carry_arange_U32(toptr: List[int], length: int):
    return awkward_carry_arange(toptr, length)


awkward_carry_arange_64
----------------------------------------------------

def awkward_carry_arange_64(toptr: List[int], length: int):
    return awkward_carry_arange(toptr, length)


awkward_identities_getitem_carry
----------------------------------------------------

for ID in int:
    for T in int:

        def awkward_identities_getitem_carry(
            newidentitiesptr: List[ID],
            identitiesptr: List[ID],
            carryptr: List[T],
            lencarry: int,
            offset: int,
            width: int,
            length: int,
        ):
            for i in range(lencarry):
                if carryptr[i] >= length:
                    raise ValueError("index out of range")
                for j in range(width):
                    newidentitiesptr[(width * i) + j] = identitiesptr[
                        (offset + (width * carryptr[i])) + j
                    ]
            return


awkward_identities32_getitem_carry_64
----------------------------------------------------

def awkward_identities32_getitem_carry_64(
    newidentitiesptr: List[int],
    identitiesptr: List[int],
    carryptr: List[int],
    lencarry: int,
    offset: int,
    width: int,
    length: int,
):
    return awkward_identities_getitem_carry(
        newidentitiesptr, identitiesptr, carryptr, lencarry, offset, width, length
    )


awkward_identities64_getitem_carry_64
----------------------------------------------------

def awkward_identities64_getitem_carry_64(
    newidentitiesptr: List[int],
    identitiesptr: List[int],
    carryptr: List[int],
    lencarry: int,
    offset: int,
    width: int,
    length: int,
):
    return awkward_identities_getitem_carry(
        newidentitiesptr, identitiesptr, carryptr, lencarry, offset, width, length
    )


awkward_numpyarray_contiguous_init
----------------------------------------------------

for T in int:

    def awkward_numpyarray_contiguous_init(toptr: List[T], skip: int, stride: int):
        for i in range(skip):
            toptr[i] = i * stride
        return


awkward_numpyarray_contiguous_init_64
----------------------------------------------------

def awkward_numpyarray_contiguous_init_64(toptr: List[int], skip: int, stride: int):
    return awkward_numpyarray_contiguous_init(toptr, skip, stride)


awkward_numpyarray_contiguous_copy
----------------------------------------------------

for T in int:

    def awkward_numpyarray_contiguous_copy(
        toptr: List[int],
        fromptr: List[int],
        len: int,
        stride: int,
        offset: int,
        pos: List[int],
    ):
        for i in range(len):
            toptr[i * stride : i * stride + stride] = fromptr[
                offset + int(pos[i]) : offset + int(pos[i]) + stride
            ]
        return


awkward_numpyarray_contiguous_copy_64
----------------------------------------------------

def awkward_numpyarray_contiguous_copy_64(
    toptr: List[int],
    fromptr: List[int],
    len: int,
    stride: int,
    offset: int,
    pos: List[int],
):
    return awkward_numpyarray_contiguous_copy(toptr, fromptr, len, stride, offset, pos)


awkward_numpyarray_contiguous_next
----------------------------------------------------

for T in int:

    def awkward_numpyarray_contiguous_next(
        topos: List[T], frompos: List[T], len: int, skip: int, stride: int
    ):
        for i in range(len):
            for j in range(skip):
                topos[(i * skip) + j] = frompos[i] + (j * stride)
        return


awkward_numpyarray_contiguous_next_64
----------------------------------------------------

def awkward_numpyarray_contiguous_next_64(
    topos: List[int], frompos: List[int], len: int, skip: int, stride: int
):
    return awkward_numpyarray_contiguous_next(topos, frompos, len, skip, stride)


awkward_numpyarray_getitem_next_null
----------------------------------------------------

def awkward_numpyarray_getitem_next_null(
    toptr: List[int],
    fromptr: List[int],
    len: int,
    stride: int,
    offset: int,
    pos: List[int],
):
    for i in range(len):
        toptr[i * stride : i * stride + stride] = fromptr[
            offset + (pos[i] * stride) : offset + (pos[i] * stride) + stride
        ]
    return


awkward_numpyarray_getitem_next_null_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_null_64(
    toptr: List[int],
    fromptr: List[int],
    len: int,
    stride: int,
    offset: int,
    pos: List[int],
):
    return awkward_numpyarray_getitem_next_null(
        toptr, fromptr, len, stride, offset, pos
    )


awkward_numpyarray_getitem_next_at
----------------------------------------------------

def awkward_numpyarray_getitem_next_at(
    nextcarryptr: List[T], carryptr: List[T], lencarry: int, skip: int, at: int
):
    for i in range(lencarry):
        nextcarryptr[i] = (skip * carryptr[i]) + at
    return


awkward_numpyarray_getitem_next_at_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_at_64(
    nextcarryptr: List[int], carryptr: List[int], lencarry: int, skip: int, at: int
):
    return awkward_numpyarray_getitem_next_at(
        nextcarryptr, carryptr, lencarry, skip, at
    )


awkward_numpyarray_getitem_next_range
----------------------------------------------------

def awkward_numpyarray_getitem_next_range(
    nextcarryptr: List[T],
    carryptr: List[T],
    lencarry: int,
    lenhead: int,
    skip: int,
    start: int,
    step: int,
):
    for i in range(lencarry):
        for j in range(lenhead):
            nextcarryptr[(i * lenhead) + j] = ((skip * carryptr[i]) + start) + (
                j * step
            )
    return


awkward_numpyarray_getitem_next_range_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_range_64(
    nextcarryptr: List[int],
    carryptr: List[int],
    lencarry: int,
    lenhead: int,
    skip: int,
    start: int,
    step: int,
):
    return awkward_numpyarray_getitem_next_range(
        nextcarryptr, carryptr, lencarry, lenhead, skip, start, step
    )


awkward_numpyarray_getitem_next_range_advanced
----------------------------------------------------

def awkward_numpyarray_getitem_next_range_advanced(
    nextcarryptr: List[T],
    nextadvancedptr: List[T],
    carryptr: List[T],
    advancedptr: List[T],
    lencarry: int,
    lenhead: int,
    skip: int,
    start: int,
    step: int,
):
    for i in range(lencarry):
        for j in range(lenhead):
            nextcarryptr[(i * lenhead) + j] = ((skip * carryptr[i]) + start) + (
                j * step
            )
            nextadvancedptr[(i * lenhead) + j] = advancedptr[i]
    return


awkward_numpyarray_getitem_next_range_advanced_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_range_advanced_64(
    nextcarryptr: List[int],
    nextadvancedptr: List[int],
    carryptr: List[int],
    advancedptr: List[int],
    lencarry: int,
    lenhead: int,
    skip: int,
    start: int,
    step: int,
):
    return awkward_numpyarray_getitem_next_range_advanced(
        nextcarryptr,
        nextadvancedptr,
        carryptr,
        advancedptr,
        lencarry,
        lenhead,
        skip,
        start,
        step,
    )


awkward_numpyarray_getitem_next_array
----------------------------------------------------

def awkward_numpyarray_getitem_next_array(
    nextcarryptr: List[T],
    nextadvancedptr: List[T],
    carryptr: List[T],
    flatheadptr: List[T],
    lencarry: int,
    lenflathead: int,
    skip: int,
):
    for i in range(lencarry):
        for j in range(lenflathead):
            nextcarryptr[(i * lenflathead) + j] = (skip * carryptr[i]) + flatheadptr[j]
            nextadvancedptr[(i * lenflathead) + j] = j
    return


awkward_numpyarray_getitem_next_array_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_array_64(
    nextcarryptr: List[int],
    nextadvancedptr: List[int],
    carryptr: List[int],
    flatheadptr: List[int],
    lencarry: int,
    lenflathead: int,
    skip: int,
):
    return awkward_numpyarray_getitem_next_array(
        nextcarryptr,
        nextadvancedptr,
        carryptr,
        flatheadptr,
        lencarry,
        lenflathead,
        skip,
    )


awkward_numpyarray_getitem_next_array_advanced
----------------------------------------------------

def awkward_numpyarray_getitem_next_array_advanced(
    nextcarryptr: List[T],
    carryptr: List[T],
    advancedptr: List[T],
    flatheadptr: List[T],
    lencarry: int,
    skip: int,
):
    for i in range(lencarry):
        nextcarryptr[i] = (skip * carryptr[i]) + flatheadptr[advancedptr[i]]
    return


awkward_numpyarray_getitem_next_array_advanced_64
----------------------------------------------------

def awkward_numpyarray_getitem_next_array_advanced_64(
    nextcarryptr: List[int],
    carryptr: List[int],
    advancedptr: List[int],
    flatheadptr: List[int],
    lencarry: int,
    skip: int,
):
    return awkward_numpyarray_getitem_next_array_advanced(
        nextcarryptr, carryptr, advancedptr, flatheadptr, lencarry, skip
    )


awkward_numpyarray_getitem_boolean_numtrue
----------------------------------------------------

def awkward_numpyarray_getitem_boolean_numtrue(
    numtrue: List[int], fromptr: List[int], byteoffset: int, length: int, stride: int
):
    numtrue = 0
    i = 0
    while i < length:
        numtrue = numtrue + (fromptr[byteoffset + i] != 0)
        i = stride
    return


awkward_numpyarray_getitem_boolean_nonzero
----------------------------------------------------

for T in int:

    def awkward_numpyarray_getitem_boolean_nonzero(
        toptr: List[T], fromptr: List[int], byteoffset: int, length: int, stride: int
    ):
        k = 0
        i = 0
        while i < length:
            if fromptr[byteoffset + i] != 0:
                toptr[k] = i
                k = k + 1
            i = stride
        return


awkward_numpyarray_getitem_boolean_nonzero_64
----------------------------------------------------

def awkward_numpyarray_getitem_boolean_nonzero_64(
    toptr: List[int], fromptr: List[int], byteoffset: int, length: int, stride: int
):
    return awkward_numpyarray_getitem_intean_nonzero(
        toptr, fromptr, byteoffset, length, stride
    )


awkward_listarray_getitem_next_at
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_at(
            tocarry: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            lenstarts: int,
            startsoffset: int,
            stopsoffset: int,
            at: int,
        ):
            for i in range(lenstarts):
                length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
                regular_at = at
                if regular_at < 0:
                    regular_at = length
                if not (0 <= regular_at) and (regular_at < length):
                    raise ValueError("index out of range")
                tocarry[i] = fromstarts[startsoffset + i] + regular_at
            return


awkward_listarray32_getitem_next_at_64
----------------------------------------------------

def awkward_listarray32_getitem_next_at_64(
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    at: int,
):
    return awkward_listarray_getitem_next_at(
        tocarry, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset, at
    )


awkward_listarrayU32_getitem_next_at_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_at_64(
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    at: int,
):
    return awkward_listarray_getitem_next_at(
        tocarry, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset, at
    )


awkward_listarray64_getitem_next_at_64
----------------------------------------------------

def awkward_listarray64_getitem_next_at_64(
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    at: int,
):
    return awkward_listarray_getitem_next_at(
        tocarry, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset, at
    )


awkward_listarray_getitem_next_range_carrylength
----------------------------------------------------

for C in int:

    def awkward_listarray_getitem_next_range_carrylength(
        carrylength: List[int],
        fromstarts: List[C],
        fromstops: List[C],
        lenstarts: int,
        startsoffset: int,
        stopsoffset: int,
        start: int,
        stop: int,
        step: int,
    ):
        carrylength = 0
        for i in range(lenstarts):
            length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
            regular_start = start
            regular_stop = stop
            awkward_regularize_rangeslice(
                regular_start,
                regular_stop,
                step > 0,
                start != kSliceNone,
                stop != kSliceNone,
                length,
            )
            if step > 0:
                j = regular_start
                while j < regular_stop:
                    carrylength = carrylength + 1
                    j = step
            else:
                j = regular_start
                while j > regular_stop:
                    carrylength = carrylength + 1
                    j = step
        return


awkward_listarray32_getitem_next_range_carrylength
----------------------------------------------------

def awkward_listarray32_getitem_next_range_carrylength(
    carrylength: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range_carrylength(
        carrylength,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarrayU32_getitem_next_range_carrylength
----------------------------------------------------

def awkward_listarrayU32_getitem_next_range_carrylength(
    carrylength: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range_carrylength(
        carrylength,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarray64_getitem_next_range_carrylength
----------------------------------------------------

def awkward_listarray64_getitem_next_range_carrylength(
    carrylength: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range_carrylength(
        carrylength,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarray_getitem_next_range
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_range(
            tooffsets: List[C],
            tocarry: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            lenstarts: int,
            startsoffset: int,
            stopsoffset: int,
            start: int,
            stop: int,
            step: int,
        ):
            k = 0
            tooffsets[0] = 0
            if step > 0:
                for i in range(lenstarts):
                    length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
                    regular_start = start
                    regular_stop = stop
                    awkward_regularize_rangeslice(
                        regular_start,
                        regular_stop,
                        step > 0,
                        start != kSliceNone,
                        stop != kSliceNone,
                        length,
                    )
                    j = regular_start
                    while j < regular_stop:
                        tocarry[k] = fromstarts[startsoffset + i] + j
                        k = k + 1
                        j = step
                    tooffsets[i + 1] = int(k)
            else:
                for i in range(lenstarts):
                    length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
                    regular_start = start
                    regular_stop = stop
                    awkward_regularize_rangeslice(
                        regular_start,
                        regular_stop,
                        step > 0,
                        start != kSliceNone,
                        stop != kSliceNone,
                        length,
                    )
                    j = regular_start
                    while j > regular_stop:
                        tocarry[k] = fromstarts[startsoffset + i] + j
                        k = k + 1
                        j = step
                    tooffsets[i + 1] = int(k)
            return


awkward_listarray32_getitem_next_range_64
----------------------------------------------------

def awkward_listarray32_getitem_next_range_64(
    tooffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range(
        tooffsets,
        tocarry,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarrayU32_getitem_next_range_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_range_64(
    tooffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range(
        tooffsets,
        tocarry,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarray64_getitem_next_range_64
----------------------------------------------------

def awkward_listarray64_getitem_next_range_64(
    tooffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
    start: int,
    stop: int,
    step: int,
):
    return awkward_listarray_getitem_next_range(
        tooffsets,
        tocarry,
        fromstarts,
        fromstops,
        lenstarts,
        startsoffset,
        stopsoffset,
        start,
        stop,
        step,
    )


awkward_listarray_getitem_next_range_counts
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_range_counts(
            total: List[int], fromoffsets: List[C], lenstarts: int
        ):
            total = 0
            for i in range(lenstarts):
                total = (total + fromoffsets[i + 1]) - fromoffsets[i]
            return


awkward_listarray32_getitem_next_range_counts_64
----------------------------------------------------

def awkward_listarray32_getitem_next_range_counts_64(
    total: List[int], fromoffsets: List[int], lenstarts: int
):
    return awkward_listarray_getitem_next_range_counts(total, fromoffsets, lenstarts)


awkward_listarrayU32_getitem_next_range_counts_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_range_counts_64(
    total: List[int], fromoffsets: List[int], lenstarts: int
):
    return awkward_listarray_getitem_next_range_counts(total, fromoffsets, lenstarts)


awkward_listarray64_getitem_next_range_counts_64
----------------------------------------------------

def awkward_listarray64_getitem_next_range_counts_64(
    total: List[int], fromoffsets: List[int], lenstarts: int
):
    return awkward_listarray_getitem_next_range_counts(total, fromoffsets, lenstarts)


awkward_listarray_getitem_next_range_spreadadvanced
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_range_spreadadvanced(
            toadvanced: List[T],
            fromadvanced: List[T],
            fromoffsets: List[C],
            lenstarts: int,
        ):
            for i in range(lenstarts):
                count = fromoffsets[i + 1] - fromoffsets[i]
                for j in range(count):
                    toadvanced[fromoffsets[i] + j] = fromadvanced[i]
            return


awkward_listarray32_getitem_next_range_spreadadvanced_64
----------------------------------------------------

def awkward_listarray32_getitem_next_range_spreadadvanced_64(
    toadvanced: List[int],
    fromadvanced: List[int],
    fromoffsets: List[int],
    lenstarts: int,
):
    return awkward_listarray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, fromoffsets, lenstarts
    )


awkward_listarrayU32_getitem_next_range_spreadadvanced_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_range_spreadadvanced_64(
    toadvanced: List[int],
    fromadvanced: List[int],
    fromoffsets: List[int],
    lenstarts: int,
):
    return awkward_listarray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, fromoffsets, lenstarts
    )


awkward_listarray64_getitem_next_range_spreadadvanced_64
----------------------------------------------------

def awkward_listarray64_getitem_next_range_spreadadvanced_64(
    toadvanced: List[int],
    fromadvanced: List[int],
    fromoffsets: List[int],
    lenstarts: int,
):
    return awkward_listarray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, fromoffsets, lenstarts
    )


awkward_listarray_getitem_next_array
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_array(
            tocarry: List[T],
            toadvanced: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            fromarray: List[T],
            startsoffset: int,
            stopsoffset: int,
            lenstarts: int,
            lenarray: int,
            lencontent: int,
        ):
            for i in range(lenstarts):
                if fromstops[stopsoffset + i] < fromstarts[startsoffset + i]:
                    raise ValueError("stops[i] < starts[i]")
                if (
                    fromstarts[startsoffset + i] != fromstops[stopsoffset + i]
                ) and lencontent:
                    raise ValueError("stops[i] > len(content)")
                length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
                for j in range(lenarray):
                    regular_at = fromarray[j]
                    if regular_at < 0:
                        regular_at = length
                    if not (0 <= regular_at) and (regular_at < length):
                        raise ValueError("index out of range")
                    tocarry[(i * lenarray) + j] = (
                        fromstarts[startsoffset + i] + regular_at
                    )
                    toadvanced[(i * lenarray) + j] = j
            return


awkward_listarray32_getitem_next_array_64
----------------------------------------------------

def awkward_listarray32_getitem_next_array_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarrayU32_getitem_next_array_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_array_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarray64_getitem_next_array_64
----------------------------------------------------

def awkward_listarray64_getitem_next_array_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarray_getitem_next_array_advanced
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_next_array_advanced(
            tocarry: List[T],
            toadvanced: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            fromarray: List[T],
            fromadvanced: List[T],
            startsoffset: int,
            stopsoffset: int,
            lenstarts: int,
            lenarray: int,
            lencontent: int,
        ):
            for i in range(lenstarts):
                if fromstops[stopsoffset + i] < fromstarts[startsoffset + i]:
                    raise ValueError("stops[i] < starts[i]")
                if (
                    fromstarts[startsoffset + i] != fromstops[stopsoffset + i]
                ) and lencontent:
                    raise ValueError("stops[i] > len(content)")
                length = fromstops[stopsoffset + i] - fromstarts[startsoffset + i]
                regular_at = fromarray[fromadvanced[i]]
                if regular_at < 0:
                    regular_at = length
                if not (0 <= regular_at) and (regular_at < length):
                    raise ValueError("index out of range")
                tocarry[i] = fromstarts[startsoffset + i] + regular_at
                toadvanced[i] = i
            return


awkward_listarray32_getitem_next_array_advanced_64
----------------------------------------------------

def awkward_listarray32_getitem_next_array_advanced_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    fromadvanced: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array_advanced(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        fromadvanced,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarrayU32_getitem_next_array_advanced_64
----------------------------------------------------

def awkward_listarrayU32_getitem_next_array_advanced_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    fromadvanced: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array_advanced(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        fromadvanced,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarray64_getitem_next_array_advanced_64
----------------------------------------------------

def awkward_listarray64_getitem_next_array_advanced_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromarray: List[int],
    fromadvanced: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lenarray: int,
    lencontent: int,
):
    return awkward_listarray_getitem_next_array_advanced(
        tocarry,
        toadvanced,
        fromstarts,
        fromstops,
        fromarray,
        fromadvanced,
        startsoffset,
        stopsoffset,
        lenstarts,
        lenarray,
        lencontent,
    )


awkward_listarray_getitem_carry
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_carry(
            tostarts: List[C],
            tostops: List[C],
            fromstarts: List[C],
            fromstops: List[C],
            fromcarry: List[T],
            startsoffset: int,
            stopsoffset: int,
            lenstarts: int,
            lencarry: int,
        ):
            for i in range(lencarry):
                if fromcarry[i] >= lenstarts:
                    raise ValueError("index out of range")
                tostarts[i] = int(fromstarts[startsoffset + fromcarry[i]])
                tostops[i] = int(fromstops[stopsoffset + fromcarry[i]])
            return


awkward_listarray32_getitem_carry_64
----------------------------------------------------

def awkward_listarray32_getitem_carry_64(
    tostarts: List[int],
    tostops: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromcarry: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lencarry: int,
):
    return awkward_listarray_getitem_carry(
        tostarts,
        tostops,
        fromstarts,
        fromstops,
        fromcarry,
        startsoffset,
        stopsoffset,
        lenstarts,
        lencarry,
    )


awkward_listarrayU32_getitem_carry_64
----------------------------------------------------

def awkward_listarrayU32_getitem_carry_64(
    tostarts: List[int],
    tostops: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromcarry: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lencarry: int,
):
    return awkward_listarray_getitem_carry(
        tostarts,
        tostops,
        fromstarts,
        fromstops,
        fromcarry,
        startsoffset,
        stopsoffset,
        lenstarts,
        lencarry,
    )


awkward_listarray64_getitem_carry_64
----------------------------------------------------

def awkward_listarray64_getitem_carry_64(
    tostarts: List[int],
    tostops: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    fromcarry: List[int],
    startsoffset: int,
    stopsoffset: int,
    lenstarts: int,
    lencarry: int,
):
    return awkward_listarray_getitem_carry(
        tostarts,
        tostops,
        fromstarts,
        fromstops,
        fromcarry,
        startsoffset,
        stopsoffset,
        lenstarts,
        lencarry,
    )


awkward_regulararray_getitem_next_at
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_at(
        tocarry: List[T], at: int, len: int, size: int
    ):
        regular_at = at
        if regular_at < 0:
            regular_at = size
        if not (0 <= regular_at) and (regular_at < size):
            raise ValueError("index out of range")
        for i in range(len):
            tocarry[i] = (i * size) + regular_at
        return


awkward_regulararray_getitem_next_at_64
----------------------------------------------------

def awkward_regulararray_getitem_next_at_64(
    tocarry: List[int], at: int, len: int, size: int
):
    return awkward_regulararray_getitem_next_at(tocarry, at, len, size)


awkward_regulararray_getitem_next_range
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_range(
        tocarry: List[T],
        regular_start: int,
        step: int,
        len: int,
        size: int,
        nextsize: int,
    ):
        for i in range(len):
            for j in range(nextsize):
                tocarry[(i * nextsize) + j] = ((i * size) + regular_start) + (j * step)
        return


awkward_regulararray_getitem_next_range_64
----------------------------------------------------

def awkward_regulararray_getitem_next_range_64(
    tocarry: List[int],
    regular_start: int,
    step: int,
    len: int,
    size: int,
    nextsize: int,
):
    return awkward_regulararray_getitem_next_range(
        tocarry, regular_start, step, len, size, nextsize
    )


awkward_regulararray_getitem_next_range_spreadadvanced
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_range_spreadadvanced(
        toadvanced: List[T], fromadvanced: List[T], len: int, nextsize: int
    ):
        for i in range(len):
            for j in range(nextsize):
                toadvanced[(i * nextsize) + j] = fromadvanced[i]
        return


awkward_regulararray_getitem_next_range_spreadadvanced_64
----------------------------------------------------

def awkward_regulararray_getitem_next_range_spreadadvanced_64(
    toadvanced: List[int], fromadvanced: List[int], len: int, nextsize: int
):
    return awkward_regulararray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, len, nextsize
    )


awkward_regulararray_getitem_next_array_regularize
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_array_regularize(
        toarray: List[T], fromarray: List[T], lenarray: int, size: int
    ):
        for j in range(lenarray):
            toarray[j] = fromarray[j]
            if toarray[j] < 0:
                toarray[j] = size
            if not (0 <= toarray[j]) and (toarray[j] < size):
                raise ValueError("index out of range")
        return


awkward_regulararray_getitem_next_array_regularize_64
----------------------------------------------------

def awkward_regulararray_getitem_next_array_regularize_64(
    toarray: List[int], fromarray: List[int], lenarray: int, size: int
):
    return awkward_regulararray_getitem_next_array_regularize(
        toarray, fromarray, lenarray, size
    )


awkward_regulararray_getitem_next_array
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_array(
        tocarry: List[T],
        toadvanced: List[T],
        fromarray: List[T],
        len: int,
        lenarray: int,
        size: int,
    ):
        for i in range(len):
            for j in range(lenarray):
                tocarry[(i * lenarray) + j] = (i * size) + fromarray[j]
                toadvanced[(i * lenarray) + j] = j
        return


awkward_regulararray_getitem_next_array_64
----------------------------------------------------

def awkward_regulararray_getitem_next_array_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromarray: List[int],
    len: int,
    lenarray: int,
    size: int,
):
    return awkward_regulararray_getitem_next_array(
        tocarry, toadvanced, fromarray, len, lenarray, size
    )


awkward_regulararray_getitem_next_array_advanced
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_next_array_advanced(
        tocarry: List[T],
        toadvanced: List[T],
        fromadvanced: List[T],
        fromarray: List[T],
        len: int,
        lenarray: int,
        size: int,
    ):
        for i in range(len):
            tocarry[i] = (i * size) + fromarray[fromadvanced[i]]
            toadvanced[i] = i
        return


awkward_regulararray_getitem_next_array_advanced_64
----------------------------------------------------

def awkward_regulararray_getitem_next_array_advanced_64(
    tocarry: List[int],
    toadvanced: List[int],
    fromadvanced: List[int],
    fromarray: List[int],
    len: int,
    lenarray: int,
    size: int,
):
    return awkward_regulararray_getitem_next_array_advanced(
        tocarry, toadvanced, fromadvanced, fromarray, len, lenarray, size
    )


awkward_regulararray_getitem_carry
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_carry(
        tocarry: List[T], fromcarry: List[T], lencarry: int, size: int
    ):
        for i in range(lencarry):
            for j in range(size):
                tocarry[(i * size) + j] = (fromcarry[i] * size) + j
        return


awkward_regulararray_getitem_carry_64
----------------------------------------------------

def awkward_regulararray_getitem_carry_64(
    tocarry: List[int], fromcarry: List[int], lencarry: int, size: int
):
    return awkward_regulararray_getitem_carry(tocarry, fromcarry, lencarry, size)


awkward_indexedarray_numnull
----------------------------------------------------

for C in int:

    def awkward_indexedarray_numnull(
        numnull: List[int], fromindex: List[C], indexoffset: int, lenindex: int
    ):
        numnull = 0
        for i in range(lenindex):
            if fromindex[indexoffset + i] < 0:
                numnull = numnull + 1
        return


awkward_indexedarray32_numnull
----------------------------------------------------

def awkward_indexedarray32_numnull(
    numnull: List[int], fromindex: List[int], indexoffset: int, lenindex: int
):
    return awkward_indexedarray_numnull(numnull, fromindex, indexoffset, lenindex)


awkward_indexedarrayU32_numnull
----------------------------------------------------

def awkward_indexedarrayU32_numnull(
    numnull: List[int], fromindex: List[int], indexoffset: int, lenindex: int
):
    return awkward_indexedarray_numnull(numnull, fromindex, indexoffset, lenindex)


awkward_indexedarray64_numnull
----------------------------------------------------

def awkward_indexedarray64_numnull(
    numnull: List[int], fromindex: List[int], indexoffset: int, lenindex: int
):
    return awkward_indexedarray_numnull(numnull, fromindex, indexoffset, lenindex)


awkward_indexedarray_getitem_nextcarry_outindex
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_indexedarray_getitem_nextcarry_outindex(
            tocarry: List[T],
            toindex: List[C],
            fromindex: List[C],
            indexoffset: int,
            lenindex: int,
            lencontent: int,
        ):
            k = 0
            for i in range(lenindex):
                j = fromindex[indexoffset + i]
                if j >= lencontent:
                    raise ValueError("index out of range")
                else:
                    if j < 0:
                        toindex[i] = -1
                    else:
                        tocarry[k] = j
                        toindex[i] = int(k)
                        k = k + 1
            return


awkward_indexedarray32_getitem_nextcarry_outindex_64
----------------------------------------------------

def awkward_indexedarray32_getitem_nextcarry_outindex_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarrayU32_getitem_nextcarry_outindex_64
----------------------------------------------------

def awkward_indexedarrayU32_getitem_nextcarry_outindex_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray64_getitem_nextcarry_outindex_64
----------------------------------------------------

def awkward_indexedarray64_getitem_nextcarry_outindex_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray_getitem_nextcarry_outindex_mask
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_indexedarray_getitem_nextcarry_outindex_mask(
            tocarry: List[T],
            toindex: List[T],
            fromindex: List[C],
            indexoffset: int,
            lenindex: int,
            lencontent: int,
        ):
            k = 0
            for i in range(lenindex):
                j = fromindex[indexoffset + i]
                if j >= lencontent:
                    raise ValueError("index out of range")
                else:
                    if j < 0:
                        toindex[i] = -1
                    else:
                        tocarry[k] = j
                        toindex[i] = int(k)
                        k = k + 1
            return


awkward_indexedarray32_getitem_nextcarry_outindex_mask_64
----------------------------------------------------

def awkward_indexedarray32_getitem_nextcarry_outindex_mask_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex_mask(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarrayU32_getitem_nextcarry_outindex_mask_64
----------------------------------------------------

def awkward_indexedarrayU32_getitem_nextcarry_outindex_mask_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex_mask(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray64_getitem_nextcarry_outindex_mask_64
----------------------------------------------------

def awkward_indexedarray64_getitem_nextcarry_outindex_mask_64(
    tocarry: List[int],
    toindex: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry_outindex_mask(
        tocarry, toindex, fromindex, indexoffset, lenindex, lencontent
    )


awkward_listoffsetarray_getitem_adjust_offsets
----------------------------------------------------

for T in int:

    def awkward_listoffsetarray_getitem_adjust_offsets(
        tooffsets: List[T],
        tononzero: List[T],
        fromoffsets: List[T],
        offsetsoffset: int,
        length: int,
        nonzero: List[T],
        nonzerooffset: int,
        nonzerolength: int,
    ):
        j = 0
        tooffsets[0] = fromoffsets[offsetsoffset + 0]
        for i in range(length):
            slicestart = fromoffsets[offsetsoffset + i]
            slicestop = fromoffsets[(offsetsoffset + i) + 1]
            count = 0
            while (j < nonzerolength) and (nonzero[nonzerooffset + j] < slicestop):
                tononzero[j] = nonzero[nonzerooffset + j] - slicestart
                j = j + 1
                count = count + 1

            tooffsets[i + 1] = tooffsets[i] + count
        return


awkward_listoffsetarray_getitem_adjust_offsets_64
----------------------------------------------------

def awkward_listoffsetarray_getitem_adjust_offsets_64(
    tooffsets: List[int],
    tononzero: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    length: int,
    nonzero: List[int],
    nonzerooffset: int,
    nonzerolength: int,
):
    return awkward_listoffsetarray_getitem_adjust_offsets(
        tooffsets,
        tononzero,
        fromoffsets,
        offsetsoffset,
        length,
        nonzero,
        nonzerooffset,
        nonzerolength,
    )


awkward_listoffsetarray_getitem_adjust_offsets_index
----------------------------------------------------

for T in int:

    def awkward_listoffsetarray_getitem_adjust_offsets_index(
        tooffsets: List[T],
        tononzero: List[T],
        fromoffsets: List[T],
        offsetsoffset: int,
        length: int,
        index: List[T],
        indexoffset: int,
        indexlength: int,
        nonzero: List[T],
        nonzerooffset: int,
        nonzerolength: int,
        originalmask: List[int],
        maskoffset: int,
        masklength: int,
    ):
        k = 0
        tooffsets[0] = fromoffsets[offsetsoffset + 0]
        for i in range(length):
            slicestart = fromoffsets[offsetsoffset + i]
            slicestop = fromoffsets[(offsetsoffset + i) + 1]
            numnull = 0
            j = slicestart
            while j < slicestop:
                numnull = 1 if originalmask[maskoffset + j] != 0 else 0
                j = j + 1
            nullcount = 0
            count = 0
            while (k < indexlength) and (
                ((index[indexoffset + k] < 0) and (nullcount < numnull))
                or (
                    (
                        (index[indexoffset + k] >= 0)
                        and (index[indexoffset + k] < nonzerolength)
                    )
                    and (nonzero[nonzerooffset + index[indexoffset + k]] < slicestop)
                )
            ):
                if index[indexoffset + k] < 0:
                    nullcount = nullcount + 1
                else:
                    j = index[indexoffset + k]
                    tononzero[j] = nonzero[nonzerooffset + j] - slicestart
                k = k + 1
                count = count + 1

            tooffsets[i + 1] = tooffsets[i] + count
        return


awkward_listoffsetarray_getitem_adjust_offsets_index_64
----------------------------------------------------

def awkward_listoffsetarray_getitem_adjust_offsets_index_64(
    tooffsets: List[int],
    tononzero: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    length: int,
    index: List[int],
    indexoffset: int,
    indexlength: int,
    nonzero: List[int],
    nonzerooffset: int,
    nonzerolength: int,
    originalmask: List[int],
    maskoffset: int,
    masklength: int,
):
    return awkward_listoffsetarray_getitem_adjust_offsets_index(
        tooffsets,
        tononzero,
        fromoffsets,
        offsetsoffset,
        length,
        index,
        indexoffset,
        indexlength,
        nonzero,
        nonzerooffset,
        nonzerolength,
        originalmask,
        maskoffset,
        masklength,
    )


awkward_indexedarray_getitem_adjust_outindex
----------------------------------------------------

for T in int:

    def awkward_indexedarray_getitem_adjust_outindex(
        tomask: List[int],
        toindex: List[T],
        tononzero: List[T],
        fromindex: List[T],
        fromindexoffset: int,
        fromindexlength: int,
        nonzero: List[T],
        nonzerooffset: int,
        nonzerolength: int,
    ):
        j = 0
        k = 0
        for i in range(fromindexlength):
            fromval = fromindex[fromindexoffset + i]
            tomask[i] = fromval < 0
            if fromval < 0:
                toindex[k] = -1
                k = k + 1
            else:
                if (j < nonzerolength) and (fromval == nonzero[nonzerooffset + j]):
                    tononzero[j] = fromval + (k - j)
                    toindex[k] = j
                    j = j + 1
                    k = k + 1
        return


awkward_indexedarray_getitem_adjust_outindex_64
----------------------------------------------------

def awkward_indexedarray_getitem_adjust_outindex_64(
    tomask: List[int],
    toindex: List[int],
    tononzero: List[int],
    fromindex: List[int],
    fromindexoffset: int,
    fromindexlength: int,
    nonzero: List[int],
    nonzerooffset: int,
    nonzerolength: int,
):
    return awkward_indexedarray_getitem_adjust_outindex(
        tomask,
        toindex,
        tononzero,
        fromindex,
        fromindexoffset,
        fromindexlength,
        nonzero,
        nonzerooffset,
        nonzerolength,
    )


awkward_indexedarray_getitem_nextcarry
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_indexedarray_getitem_nextcarry(
            tocarry: List[T],
            fromindex: List[C],
            indexoffset: int,
            lenindex: int,
            lencontent: int,
        ):
            k = 0
            for i in range(lenindex):
                j = fromindex[indexoffset + i]
                if (j < 0) or (j >= lencontent):
                    raise ValueError("index out of range")
                else:
                    tocarry[k] = j
                    k = k + 1
            return


awkward_indexedarray32_getitem_nextcarry_64
----------------------------------------------------

def awkward_indexedarray32_getitem_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarrayU32_getitem_nextcarry_64
----------------------------------------------------

def awkward_indexedarrayU32_getitem_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray64_getitem_nextcarry_64
----------------------------------------------------

def awkward_indexedarray64_getitem_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_getitem_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray_getitem_carry
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_indexedarray_getitem_carry(
            toindex: List[C],
            fromindex: List[C],
            fromcarry: List[T],
            indexoffset: int,
            lenindex: int,
            lencarry: int,
        ):
            for i in range(lencarry):
                if fromcarry[i] >= lenindex:
                    raise ValueError("index out of range")
                toindex[i] = int(fromindex[indexoffset + fromcarry[i]])
            return


awkward_indexedarray32_getitem_carry_64
----------------------------------------------------

def awkward_indexedarray32_getitem_carry_64(
    toindex: List[int],
    fromindex: List[int],
    fromcarry: List[int],
    indexoffset: int,
    lenindex: int,
    lencarry: int,
):
    return awkward_indexedarray_getitem_carry(
        toindex, fromindex, fromcarry, indexoffset, lenindex, lencarry
    )


awkward_indexedarrayU32_getitem_carry_64
----------------------------------------------------

def awkward_indexedarrayU32_getitem_carry_64(
    toindex: List[int],
    fromindex: List[int],
    fromcarry: List[int],
    indexoffset: int,
    lenindex: int,
    lencarry: int,
):
    return awkward_indexedarray_getitem_carry(
        toindex, fromindex, fromcarry, indexoffset, lenindex, lencarry
    )


awkward_indexedarray64_getitem_carry_64
----------------------------------------------------

def awkward_indexedarray64_getitem_carry_64(
    toindex: List[int],
    fromindex: List[int],
    fromcarry: List[int],
    indexoffset: int,
    lenindex: int,
    lencarry: int,
):
    return awkward_indexedarray_getitem_carry(
        toindex, fromindex, fromcarry, indexoffset, lenindex, lencarry
    )


awkward_unionarray_regular_index_getsize
----------------------------------------------------

for C in int:

    def awkward_unionarray_regular_index_getsize(
        size: List[int], fromtags: List[C], tagsoffset: int, length: int
    ):
        size = 0
        for i in range(length):
            tag = int(fromtags[tagsoffset + i])
            if size < tag:
                size = tag
        size = size + 1
        return


awkward_unionarray8_regular_index_getsize
----------------------------------------------------

def awkward_unionarray8_regular_index_getsize(
    size: List[int], fromtags: List[int], tagsoffset: int, length: int
):
    return awkward_unionarray_regular_index_getsize(size, fromtags, tagsoffset, length)


awkward_unionarray_regular_index
----------------------------------------------------

for C in int:
    for I in int:

        def awkward_unionarray_regular_index(
            toindex: List[I],
            current: List[I],
            size: int,
            fromtags: List[C],
            tagsoffset: int,
            length: int,
        ):
            count = 0
            for k in range(size):
                current[k] = 0
            for i in range(length):
                tag = fromtags[tagsoffset + i]
                toindex[i] = current[tag]
                current[tag] = current[tag] + 1
            return


awkward_unionarray8_32_regular_index
----------------------------------------------------

def awkward_unionarray8_32_regular_index(
    toindex: List[int],
    current: List[int],
    size: int,
    fromtags: List[int],
    tagsoffset: int,
    length: int,
):
    return awkward_unionarray_regular_index(
        toindex, current, size, fromtags, tagsoffset, length
    )


awkward_unionarray8_U32_regular_index
----------------------------------------------------

def awkward_unionarray8_U32_regular_index(
    toindex: List[int],
    current: List[int],
    size: int,
    fromtags: List[int],
    tagsoffset: int,
    length: int,
):
    return awkward_unionarray_regular_index(
        toindex, current, size, fromtags, tagsoffset, length
    )


awkward_unionarray8_64_regular_index
----------------------------------------------------

def awkward_unionarray8_64_regular_index(
    toindex: List[int],
    current: List[int],
    size: int,
    fromtags: List[int],
    tagsoffset: int,
    length: int,
):
    return awkward_unionarray_regular_index(
        toindex, current, size, fromtags, tagsoffset, length
    )


awkward_unionarray_project
----------------------------------------------------

for T in int:
    for C in int:
        for I in int:

            def awkward_unionarray_project(
                lenout: List[int],
                tocarry: List[T],
                fromtags: List[C],
                tagsoffset: int,
                fromindex: List[I],
                indexoffset: int,
                length: int,
                which: int,
            ):
                lenout = 0
                for i in range(length):
                    if fromtags[tagsoffset + i] == which:
                        lenout
                        tocarry[lenout] = fromindex[indexoffset + i]
                        lenout = lenout + 1
                return


awkward_unionarray8_32_project_64
----------------------------------------------------

def awkward_unionarray8_32_project_64(
    lenout: List[int],
    tocarry: List[int],
    fromtags: List[int],
    tagsoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
    which: int,
):
    return awkward_unionarray_project(
        lenout, tocarry, fromtags, tagsoffset, fromindex, indexoffset, length, which
    )


awkward_unionarray8_U32_project_64
----------------------------------------------------

def awkward_unionarray8_U32_project_64(
    lenout: List[int],
    tocarry: List[int],
    fromtags: List[int],
    tagsoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
    which: int,
):
    return awkward_unionarray_project(
        lenout, tocarry, fromtags, tagsoffset, fromindex, indexoffset, length, which
    )


awkward_unionarray8_64_project_64
----------------------------------------------------

def awkward_unionarray8_64_project_64(
    lenout: List[int],
    tocarry: List[int],
    fromtags: List[int],
    tagsoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
    which: int,
):
    return awkward_unionarray_project(
        lenout, tocarry, fromtags, tagsoffset, fromindex, indexoffset, length, which
    )


awkward_missing_repeat
----------------------------------------------------

for T in int:

    def awkward_missing_repeat(
        outindex: List[T],
        index: List[T],
        indexoffset: int,
        indexlength: int,
        repetitions: int,
        regularsize: int,
    ):
        for i in range(repetitions):
            for j in range(indexlength):
                base = index[indexoffset + j]
                outindex[(i * indexlength) + j] = (
                    base + i * regularsize if base >= 0 else 0
                )
        return


awkward_missing_repeat_64
----------------------------------------------------

def awkward_missing_repeat_64(
    outindex: List[int],
    index: List[int],
    indexoffset: int,
    indexlength: int,
    repetitions: int,
    regularsize: int,
):
    return awkward_missing_repeat(
        outindex, index, indexoffset, indexlength, repetitions, regularsize
    )


awkward_regulararray_getitem_jagged_expand
----------------------------------------------------

for T in int:

    def awkward_regulararray_getitem_jagged_expand(
        multistarts: List[T],
        multistops: List[T],
        singleoffsets: List[T],
        regularsize: int,
        regularlength: int,
    ):
        for i in range(regularlength):
            for j in range(regularsize):
                multistarts[(i * regularsize) + j] = singleoffsets[j]
                multistops[(i * regularsize) + j] = singleoffsets[j + 1]
        return


awkward_regulararray_getitem_jagged_expand_64
----------------------------------------------------

def awkward_regulararray_getitem_jagged_expand_64(
    multistarts: List[int],
    multistops: List[int],
    singleoffsets: List[int],
    regularsize: int,
    regularlength: int,
):
    return awkward_regulararray_getitem_jagged_expand(
        multistarts, multistops, singleoffsets, regularsize, regularlength
    )


awkward_listarray_getitem_jagged_expand
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_jagged_expand(
            multistarts: List[T],
            multistops: List[T],
            singleoffsets: List[T],
            tocarry: List[T],
            fromstarts: List[C],
            fromstartsoffset: int,
            fromstops: List[C],
            fromstopsoffset: int,
            jaggedsize: int,
            length: int,
        ):
            for i in range(length):
                start = fromstarts[fromstartsoffset + i]
                stop = fromstops[fromstopsoffset + i]
                if stop < start:
                    raise ValueError("stops[i] < starts[i]")
                if (stop - start) != jaggedsize:
                    raise ValueError("cannot fit jagged slice into nested list")
                for j in range(jaggedsize):
                    multistarts[(i * jaggedsize) + j] = singleoffsets[j]
                    multistops[(i * jaggedsize) + j] = singleoffsets[j + 1]
                    tocarry[(i * jaggedsize) + j] = start + j
            return


awkward_listarray32_getitem_jagged_expand_64
----------------------------------------------------

def awkward_listarray32_getitem_jagged_expand_64(
    multistarts: List[int],
    multistops: List[int],
    singleoffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    jaggedsize: int,
    length: int,
):
    return awkward_listarray_getitem_jagged_expand(
        multistarts,
        multistops,
        singleoffsets,
        tocarry,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        jaggedsize,
        length,
    )


awkward_listarrayU32_getitem_jagged_expand_64
----------------------------------------------------

def awkward_listarrayU32_getitem_jagged_expand_64(
    multistarts: List[int],
    multistops: List[int],
    singleoffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    jaggedsize: int,
    length: int,
):
    return awkward_listarray_getitem_jagged_expand(
        multistarts,
        multistops,
        singleoffsets,
        tocarry,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        jaggedsize,
        length,
    )


awkward_listarray64_getitem_jagged_expand_64
----------------------------------------------------

def awkward_listarray64_getitem_jagged_expand_64(
    multistarts: List[int],
    multistops: List[int],
    singleoffsets: List[int],
    tocarry: List[int],
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    jaggedsize: int,
    length: int,
):
    return awkward_listarray_getitem_jagged_expand(
        multistarts,
        multistops,
        singleoffsets,
        tocarry,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        jaggedsize,
        length,
    )


awkward_listarray_getitem_jagged_carrylen
----------------------------------------------------

for T in int:

    def awkward_listarray_getitem_jagged_carrylen(
        carrylen: List[int],
        slicestarts: List[T],
        slicestartsoffset: int,
        slicestops: List[T],
        slicestopsoffset: int,
        sliceouterlen: int,
    ):
        carrylen = 0
        for i in range(sliceouterlen):
            carrylen = carrylen + int(
                slicestops[slicestopsoffset + i] - slicestarts[slicestartsoffset + i]
            )
        return


awkward_listarray_getitem_jagged_carrylen_64
----------------------------------------------------

def awkward_listarray_getitem_jagged_carrylen_64(
    carrylen: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
):
    return awkward_listarray_getitem_jagged_carrylen(
        carrylen,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
    )


awkward_listarray_getitem_jagged_apply
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_jagged_apply(
            tooffsets: List[T],
            tocarry: List[T],
            slicestarts: List[T],
            slicestartsoffset: int,
            slicestops: List[T],
            slicestopsoffset: int,
            sliceouterlen: int,
            sliceindex: List[T],
            sliceindexoffset: int,
            sliceinnerlen: int,
            fromstarts: List[C],
            fromstartsoffset: int,
            fromstops: List[C],
            fromstopsoffset: int,
            contentlen: int,
        ):
            k = 0
            for i in range(sliceouterlen):
                slicestart = slicestarts[slicestartsoffset + i]
                slicestop = slicestops[slicestopsoffset + i]
                tooffsets[i] = int(k)
                if slicestart != slicestop:
                    if slicestop < slicestart:
                        raise ValueError("jagged slice's stops[i] < starts[i]")
                    if slicestop > sliceinnerlen:
                        raise ValueError(
                            "jagged slice's offsets extend beyond its content"
                        )
                    start = int(fromstarts[fromstartsoffset + i])
                    stop = int(fromstops[fromstopsoffset + i])
                    if stop < start:
                        raise ValueError("stops[i] < starts[i]")
                    if (start != stop) and (stop > contentlen):
                        raise ValueError("stops[i] > len(content)")
                    count = stop - start
                    j = slicestart
                    while j < slicestop:
                        index = int(sliceindex[sliceindexoffset + j])
                        if index < 0:
                            index = count
                        if not (0 <= index) and (index < count):
                            raise ValueError("index out of range")
                        tocarry[k] = start + index
                        k = k + 1
                        j = j + 1
                tooffsets[i + 1] = int(k)
            return


awkward_listarray32_getitem_jagged_apply_64
----------------------------------------------------

def awkward_listarray32_getitem_jagged_apply_64(
    tooffsets: List[int],
    tocarry: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    sliceindex: List[int],
    sliceindexoffset: int,
    sliceinnerlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    contentlen: int,
):
    return awkward_listarray_getitem_jagged_apply(
        tooffsets,
        tocarry,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        sliceindex,
        sliceindexoffset,
        sliceinnerlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        contentlen,
    )


awkward_listarrayU32_getitem_jagged_apply_64
----------------------------------------------------

def awkward_listarrayU32_getitem_jagged_apply_64(
    tooffsets: List[int],
    tocarry: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    sliceindex: List[int],
    sliceindexoffset: int,
    sliceinnerlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    contentlen: int,
):
    return awkward_listarray_getitem_jagged_apply(
        tooffsets,
        tocarry,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        sliceindex,
        sliceindexoffset,
        sliceinnerlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        contentlen,
    )


awkward_listarray64_getitem_jagged_apply_64
----------------------------------------------------

def awkward_listarray64_getitem_jagged_apply_64(
    tooffsets: List[int],
    tocarry: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    sliceindex: List[int],
    sliceindexoffset: int,
    sliceinnerlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    contentlen: int,
):
    return awkward_listarray_getitem_jagged_apply(
        tooffsets,
        tocarry,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        sliceindex,
        sliceindexoffset,
        sliceinnerlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        contentlen,
    )


awkward_listarray_getitem_jagged_numvalid
----------------------------------------------------

for T in int:

    def awkward_listarray_getitem_jagged_numvalid(
        numvalid: List[int],
        slicestarts: List[T],
        slicestartsoffset: int,
        slicestops: List[T],
        slicestopsoffset: int,
        length: int,
        missing: List[T],
        missingoffset: int,
        missinglength: int,
    ):
        numvalid = 0
        for i in range(length):
            slicestart = slicestarts[slicestartsoffset + i]
            slicestop = slicestops[slicestopsoffset + i]
            if slicestart != slicestop:
                if slicestop < slicestart:
                    raise ValueError("jagged slice's stops[i] < starts[i]")
                if slicestop > missinglength:
                    raise ValueError("jagged slice's offsets extend beyond its content")
                j = slicestart
                while j < slicestop:
                    numvalid = numvalid + 1 if missing[missingoffset + j] >= 0 else 0
                    j = j + 1
        return


awkward_listarray_getitem_jagged_numvalid_64
----------------------------------------------------

def awkward_listarray_getitem_jagged_numvalid_64(
    numvalid: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    length: int,
    missing: List[int],
    missingoffset: int,
    missinglength: int,
):
    return awkward_listarray_getitem_jagged_numvalid(
        numvalid,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        length,
        missing,
        missingoffset,
        missinglength,
    )


awkward_listarray_getitem_jagged_shrink
----------------------------------------------------

for T in int:

    def awkward_listarray_getitem_jagged_shrink(
        tocarry: List[T],
        tosmalloffsets: List[T],
        tolargeoffsets: List[T],
        slicestarts: List[T],
        slicestartsoffset: int,
        slicestops: List[T],
        slicestopsoffset: int,
        length: int,
        missing: List[T],
        missingoffset: int,
    ):
        k = 0
        if length == 0:
            tosmalloffsets[0] = 0
            tolargeoffsets[0] = 0
        else:
            tosmalloffsets[0] = slicestarts[slicestartsoffset + 0]
            tolargeoffsets[0] = slicestarts[slicestartsoffset + 0]
        for i in range(length):
            slicestart = slicestarts[slicestartsoffset + i]
            slicestop = slicestops[slicestopsoffset + i]
            if slicestart != slicestop:
                smallcount = 0
                j = slicestart
                while j < slicestop:
                    if missing[missingoffset + j] >= 0:
                        tocarry[k] = j
                        k = k + 1
                        smallcount = smallcount + 1
                    j = j + 1
                tosmalloffsets[i + 1] = tosmalloffsets[i] + smallcount
            else:
                tosmalloffsets[i + 1] = tosmalloffsets[i]
            tolargeoffsets[i + 1] = tolargeoffsets[i] + (slicestop - slicestart)
        return


awkward_listarray_getitem_jagged_shrink_64
----------------------------------------------------

def awkward_listarray_getitem_jagged_shrink_64(
    tocarry: List[int],
    tosmalloffsets: List[int],
    tolargeoffsets: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    length: int,
    missing: List[int],
    missingoffset: int,
):
    return awkward_listarray_getitem_jagged_shrink(
        tocarry,
        tosmalloffsets,
        tolargeoffsets,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        length,
        missing,
        missingoffset,
    )


awkward_listarray_getitem_jagged_descend
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_getitem_jagged_descend(
            tooffsets: List[T],
            slicestarts: List[T],
            slicestartsoffset: int,
            slicestops: List[T],
            slicestopsoffset: int,
            sliceouterlen: int,
            fromstarts: List[C],
            fromstartsoffset: int,
            fromstops: List[C],
            fromstopsoffset: int,
        ):
            if sliceouterlen == 0:
                tooffsets[0] = 0
            else:
                tooffsets[0] = slicestarts[slicestartsoffset + 0]
            for i in range(sliceouterlen):
                slicecount = int(
                    slicestops[slicestopsoffset + i]
                    - slicestarts[slicestartsoffset + i]
                )
                count = int(
                    fromstops[fromstopsoffset + i] - fromstarts[fromstartsoffset + i]
                )
                if slicecount != count:
                    raise ValueError(
                        "jagged slice inner length differs from array inner length"
                    )
                tooffsets[i + 1] = tooffsets[i] + int(count)
            return


awkward_listarray32_getitem_jagged_descend_64
----------------------------------------------------

def awkward_listarray32_getitem_jagged_descend_64(
    tooffsets: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
):
    return awkward_listarray_getitem_jagged_descend(
        tooffsets,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
    )


awkward_listarrayU32_getitem_jagged_descend_64
----------------------------------------------------

def awkward_listarrayU32_getitem_jagged_descend_64(
    tooffsets: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
):
    return awkward_listarray_getitem_jagged_descend(
        tooffsets,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
    )


awkward_listarray64_getitem_jagged_descend_64
----------------------------------------------------

def awkward_listarray64_getitem_jagged_descend_64(
    tooffsets: List[int],
    slicestarts: List[int],
    slicestartsoffset: int,
    slicestops: List[int],
    slicestopsoffset: int,
    sliceouterlen: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
):
    return awkward_listarray_getitem_jagged_descend(
        tooffsets,
        slicestarts,
        slicestartsoffset,
        slicestops,
        slicestopsoffset,
        sliceouterlen,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
    )


awkward_index8_getitem_at_nowrap
----------------------------------------------------

def awkward_index8_getitem_at_nowrap(ptr: List[int], offset: int, at: int):
    return ptr[offset + at]


awkward_indexU8_getitem_at_nowrap
----------------------------------------------------

def awkward_indexU8_getitem_at_nowrap(ptr: List[int], offset: int, at: int):
    return ptr[offset + at]


awkward_index32_getitem_at_nowrap
----------------------------------------------------

def awkward_index32_getitem_at_nowrap(ptr: List[int], offset: int, at: int):
    return ptr[offset + at]


awkward_indexU32_getitem_at_nowrap
----------------------------------------------------

def awkward_indexU32_getitem_at_nowrap(ptr: List[int], offset: int, at: int):
    return ptr[offset + at]


awkward_index64_getitem_at_nowrap
----------------------------------------------------

def awkward_index64_getitem_at_nowrap(ptr: List[int], offset: int, at: int):
    return ptr[offset + at]


awkward_index8_setitem_at_nowrap
----------------------------------------------------

def awkward_index8_setitem_at_nowrap(ptr: List[int], offset: int, at: int, value: int):
    ptr[offset + at] = value


awkward_indexU8_setitem_at_nowrap
----------------------------------------------------

def awkward_indexU8_setitem_at_nowrap(ptr: List[int], offset: int, at: int, value: int):
    ptr[offset + at] = value


awkward_index32_setitem_at_nowrap
----------------------------------------------------

def awkward_index32_setitem_at_nowrap(ptr: List[int], offset: int, at: int, value: int):
    ptr[offset + at] = value


awkward_indexU32_setitem_at_nowrap
----------------------------------------------------

def awkward_indexU32_setitem_at_nowrap(
    ptr: List[int], offset: int, at: int, value: int
):
    ptr[offset + at] = value


awkward_index64_setitem_at_nowrap
----------------------------------------------------

def awkward_index64_setitem_at_nowrap(ptr: List[int], offset: int, at: int, value: int):
    ptr[offset + at] = value


awkward_bytemaskedarray_getitem_carry
----------------------------------------------------

def awkward_bytemaskedarray_getitem_carry(
    tomask: List[int],
    frommask: List[int],
    frommaskoffset: int,
    lenmask: int,
    fromcarry: List[T],
    lencarry: int,
):
    for i in range(lencarry):
        if fromcarry[i] >= lenmask:
            raise ValueError("index out of range")
        tomask[i] = frommask[frommaskoffset + fromcarry[i]]
    return


awkward_bytemaskedarray_getitem_carry_64
----------------------------------------------------

def awkward_bytemaskedarray_getitem_carry_64(
    tomask: List[int],
    frommask: List[int],
    frommaskoffset: int,
    lenmask: int,
    fromcarry: List[int],
    lencarry: int,
):
    return awkward_bytemaskedarray_getitem_carry(
        tomask, frommask, frommaskoffset, lenmask, fromcarry, lencarry
    )


awkward_bytemaskedarray_numnull
----------------------------------------------------

def awkward_bytemaskedarray_numnull(
    numnull: List[int], mask: List[int], maskoffset: int, length: int, validwhen: bool
):
    numnull = 0
    for i in range(length):
        if (mask[maskoffset + i] != 0) != validwhen:
            numnull = numnull + 1
    return


awkward_bytemaskedarray_getitem_nextcarry
----------------------------------------------------

for T in int:

    def awkward_bytemaskedarray_getitem_nextcarry(
        tocarry: List[T], mask: List[int], maskoffset: int, length: int, validwhen: bool
    ):
        k = 0
        for i in range(length):
            if (mask[maskoffset + i] != 0) == validwhen:
                tocarry[k] = i
                k = k + 1
        return


awkward_bytemaskedarray_getitem_nextcarry_64
----------------------------------------------------

def awkward_bytemaskedarray_getitem_nextcarry_64(
    tocarry: List[int], mask: List[int], maskoffset: int, length: int, validwhen: bool
):
    return awkward_bytemaskedarray_getitem_nextcarry(
        tocarry, mask, maskoffset, length, validwhen
    )


awkward_bytemaskedarray_getitem_nextcarry_outindex
----------------------------------------------------

for T in int:

    def awkward_bytemaskedarray_getitem_nextcarry_outindex(
        tocarry: List[T],
        toindex: List[T],
        mask: List[int],
        maskoffset: int,
        length: int,
        validwhen: bool,
    ):
        k = 0
        for i in range(length):
            if (mask[maskoffset + i] != 0) == validwhen:
                tocarry[k] = i
                toindex[i] = int(k)
                k = k + 1
            else:
                toindex[i] = -1
        return


awkward_bytemaskedarray_getitem_nextcarry_outindex_64
----------------------------------------------------

def awkward_bytemaskedarray_getitem_nextcarry_outindex_64(
    tocarry: List[int],
    toindex: List[int],
    mask: List[int],
    maskoffset: int,
    length: int,
    validwhen: bool,
):
    return awkward_bytemaskedarray_getitem_nextcarry_outindex(
        tocarry, toindex, mask, maskoffset, length, validwhen
    )


awkward_bytemaskedarray_toindexedarray
----------------------------------------------------

for T in int:

    def awkward_bytemaskedarray_toindexedarray(
        toindex: List[T], mask: List[int], maskoffset: int, length: int, validwhen: bool
    ):
        for i in range(length):
            toindex[i] = i if (mask[maskoffset + i] != 0) == validwhen else -1
        return


awkward_bytemaskedarray_toindexedarray_64
----------------------------------------------------

def awkward_bytemaskedarray_toindexedarray_64(
    toindex: List[int], mask: List[int], maskoffset: int, length: int, validwhen: bool
):
    return awkward_bytemaskedarray_toindexedarray(
        toindex, mask, maskoffset, length, validwhen
    )