src/cpu-kernels/operations.cpp

awkward_listarray_num
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_listarray_num(
            tonum: List[T],
            fromstarts: List[C],
            startsoffset: int,
            fromstops: List[C],
            stopsoffset: int,
            length: int,
        ):
            for i in range(length):
                start = fromstarts[startsoffset + i]
                stop = fromstops[stopsoffset + i]
                tonum[i] = int(stop - start)
            return


awkward_listarray32_num_64
----------------------------------------------------

def awkward_listarray32_num_64(
    tonum: List[int],
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_num(
        tonum, fromstarts, startsoffset, fromstops, stopsoffset, length
    )


awkward_listarrayU32_num_64
----------------------------------------------------

def awkward_listarrayU32_num_64(
    tonum: List[int],
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_num(
        tonum, fromstarts, startsoffset, fromstops, stopsoffset, length
    )


awkward_listarray64_num_64
----------------------------------------------------

def awkward_listarray64_num_64(
    tonum: List[int],
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_num(
        tonum, fromstarts, startsoffset, fromstops, stopsoffset, length
    )


awkward_regulararray_num
----------------------------------------------------

for T in int:

    def awkward_regulararray_num(tonum: List[T], size: int, length: int):
        for i in range(length):
            tonum[i] = size
        return


awkward_regulararray_num_64
----------------------------------------------------

def awkward_regulararray_num_64(tonum: List[int], size: int, length: int):
    return awkward_regulararray_num(tonum, size, length)


awkward_listoffsetarray_flatten_offsets
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_listoffsetarray_flatten_offsets(
            tooffsets: List[T],
            outeroffsets: List[C],
            outeroffsetsoffset: int,
            outeroffsetslen: int,
            inneroffsets: List[T],
            inneroffsetsoffset: int,
            inneroffsetslen: int,
        ):
            for i in range(outeroffsetslen):
                tooffsets[i] = inneroffsets[
                    inneroffsetsoffset + outeroffsets[outeroffsetsoffset + i]
                ]
            return


awkward_listoffsetarray32_flatten_offsets_64
----------------------------------------------------

def awkward_listoffsetarray32_flatten_offsets_64(
    tooffsets: List[int],
    outeroffsets: List[int],
    outeroffsetsoffset: int,
    outeroffsetslen: int,
    inneroffsets: List[int],
    inneroffsetsoffset: int,
    inneroffsetslen: int,
):
    return awkward_listoffsetarray_flatten_offsets(
        tooffsets,
        outeroffsets,
        outeroffsetsoffset,
        outeroffsetslen,
        inneroffsets,
        inneroffsetsoffset,
        inneroffsetslen,
    )


awkward_listoffsetarrayU32_flatten_offsets_64
----------------------------------------------------

def awkward_listoffsetarrayU32_flatten_offsets_64(
    tooffsets: List[int],
    outeroffsets: List[int],
    outeroffsetsoffset: int,
    outeroffsetslen: int,
    inneroffsets: List[int],
    inneroffsetsoffset: int,
    inneroffsetslen: int,
):
    return awkward_listoffsetarray_flatten_offsets(
        tooffsets,
        outeroffsets,
        outeroffsetsoffset,
        outeroffsetslen,
        inneroffsets,
        inneroffsetsoffset,
        inneroffsetslen,
    )


awkward_listoffsetarray64_flatten_offsets_64
----------------------------------------------------

def awkward_listoffsetarray64_flatten_offsets_64(
    tooffsets: List[int],
    outeroffsets: List[int],
    outeroffsetsoffset: int,
    outeroffsetslen: int,
    inneroffsets: List[int],
    inneroffsetsoffset: int,
    inneroffsetslen: int,
):
    return awkward_listoffsetarray_flatten_offsets(
        tooffsets,
        outeroffsets,
        outeroffsetsoffset,
        outeroffsetslen,
        inneroffsets,
        inneroffsetsoffset,
        inneroffsetslen,
    )


awkward_indexedarray_flatten_none2empty
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_indexedarray_flatten_none2empty(
            outoffsets: List[T],
            outindex: List[C],
            outindexoffset: int,
            outindexlength: int,
            offsets: List[T],
            offsetsoffset: int,
            offsetslength: int,
        ):
            outoffsets[0] = offsets[offsetsoffset + 0]
            k = 1
            for i in range(outindexlength):
                idx = outindex[outindexoffset + i]
                if idx < 0:
                    outoffsets[k] = outoffsets[k - 1]
                    k = k + 1
                else:
                    if ((offsetsoffset + idx) + 1) >= offsetslength:
                        raise ValueError("flattening offset out of range")
                    else:
                        count = (
                            offsets[(offsetsoffset + idx) + 1]
                            - offsets[offsetsoffset + idx]
                        )
                        outoffsets[k] = outoffsets[k - 1] + count
                        k = k + 1
            return


awkward_indexedarray32_flatten_none2empty_64
----------------------------------------------------

def awkward_indexedarray32_flatten_none2empty_64(
    outoffsets: List[int],
    outindex: List[int],
    outindexoffset: int,
    outindexlength: int,
    offsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
):
    return awkward_indexedarray_flatten_none2empty(
        outoffsets,
        outindex,
        outindexoffset,
        outindexlength,
        offsets,
        offsetsoffset,
        offsetslength,
    )


awkward_indexedarrayU32_flatten_none2empty_64
----------------------------------------------------

def awkward_indexedarrayU32_flatten_none2empty_64(
    outoffsets: List[int],
    outindex: List[int],
    outindexoffset: int,
    outindexlength: int,
    offsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
):
    return awkward_indexedarray_flatten_none2empty(
        outoffsets,
        outindex,
        outindexoffset,
        outindexlength,
        offsets,
        offsetsoffset,
        offsetslength,
    )


awkward_indexedarray64_flatten_none2empty_64
----------------------------------------------------

def awkward_indexedarray64_flatten_none2empty_64(
    outoffsets: List[int],
    outindex: List[int],
    outindexoffset: int,
    outindexlength: int,
    offsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
):
    return awkward_indexedarray_flatten_none2empty(
        outoffsets,
        outindex,
        outindexoffset,
        outindexlength,
        offsets,
        offsetsoffset,
        offsetslength,
    )


awkward_unionarray_flatten_length
----------------------------------------------------

for FROMTAGS in int:
    for FROMINDEX in int:
        for T in int:

            def awkward_unionarray_flatten_length(
                total_length: List[int],
                fromtags: List[FROMTAGS],
                fromtagsoffset: int,
                fromindex: List[FROMINDEX],
                fromindexoffset: int,
                length: int,
                offsetsraws: List[List[int]],
                offsetsoffsets: List[int],
            ):
                total_length = 0
                for i in range(length):
                    tag = fromtags[fromtagsoffset + i]
                    idx = fromindex[fromindexoffset + i]
                    start = offsetsraws[tag][offsetsoffsets[tag] + idx]
                    stop = offsetsraws[tag][(offsetsoffsets[tag] + idx) + 1]
                    total_length = total_length + (stop - start)
                return


awkward_unionarray32_flatten_length_64
----------------------------------------------------

def awkward_unionarray32_flatten_length_64(
    total_length: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_length(
        total_length,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_unionarrayU32_flatten_length_64
----------------------------------------------------

def awkward_unionarrayU32_flatten_length_64(
    total_length: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_length(
        total_length,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_unionarray64_flatten_length_64
----------------------------------------------------

def awkward_unionarray64_flatten_length_64(
    total_length: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_length(
        total_length,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_unionarray_flatten_combine
----------------------------------------------------

for FROMTAGS in int:
    for FROMINDEX in int:
        for TOTAGS in int:
            for TOINDEX in int:
                for T in int:

                    def awkward_unionarray_flatten_combine(
                        totags: List[TOTAGS],
                        toindex: List[TOINDEX],
                        tooffsets: List[T],
                        fromtags: List[FROMTAGS],
                        fromtagsoffset: int,
                        fromindex: List[FROMINDEX],
                        fromindexoffset: int,
                        length: int,
                        offsetsraws: List[List[int]],
                        offsetsoffsets: List[int],
                    ):
                        tooffsets[0] = 0
                        k = 0
                        for i in range(length):
                            tag = fromtags[fromtagsoffset + i]
                            idx = fromindex[fromindexoffset + i]
                            start = offsetsraws[tag][offsetsoffsets[tag] + idx]
                            stop = offsetsraws[tag][(offsetsoffsets[tag] + idx) + 1]
                            tooffsets[i + 1] = tooffsets[i] + (stop - start)
                            j = start
                            while j < stop:
                                totags[k] = tag
                                toindex[k] = j
                                k = k + 1
                                j = j + 1
                        return


awkward_unionarray32_flatten_combine_64
----------------------------------------------------

def awkward_unionarray32_flatten_combine_64(
    totags: List[int],
    toindex: List[int],
    tooffsets: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_combine(
        totags,
        toindex,
        tooffsets,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_unionarrayU32_flatten_combine_64
----------------------------------------------------

def awkward_unionarrayU32_flatten_combine_64(
    totags: List[int],
    toindex: List[int],
    tooffsets: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_combine(
        totags,
        toindex,
        tooffsets,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_unionarray64_flatten_combine_64
----------------------------------------------------

def awkward_unionarray64_flatten_combine_64(
    totags: List[int],
    toindex: List[int],
    tooffsets: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    offsetsraws: List[List[int]],
    offsetsoffsets: List[int],
):
    return awkward_unionarray_flatten_combine(
        totags,
        toindex,
        tooffsets,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        length,
        offsetsraws,
        offsetsoffsets,
    )


awkward_indexedarray_flatten_nextcarry
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_indexedarray_flatten_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 >= lencontent:
                    raise ValueError("index out of range")
                else:
                    if j >= 0:
                        tocarry[k] = j
                        k = k + 1
            return


awkward_indexedarray32_flatten_nextcarry_64
----------------------------------------------------

def awkward_indexedarray32_flatten_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_flatten_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarrayU32_flatten_nextcarry_64
----------------------------------------------------

def awkward_indexedarrayU32_flatten_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_flatten_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray64_flatten_nextcarry_64
----------------------------------------------------

def awkward_indexedarray64_flatten_nextcarry_64(
    tocarry: List[int],
    fromindex: List[int],
    indexoffset: int,
    lenindex: int,
    lencontent: int,
):
    return awkward_indexedarray_flatten_nextcarry(
        tocarry, fromindex, indexoffset, lenindex, lencontent
    )


awkward_indexedarray_overlay_mask
----------------------------------------------------

for C in int:
    for M in int:
        for TO in int:

            def awkward_indexedarray_overlay_mask(
                toindex: List[TO],
                mask: List[M],
                maskoffset: int,
                fromindex: List[C],
                indexoffset: int,
                length: int,
            ):
                for i in range(length):
                    m = mask[maskoffset + i]
                    toindex[i] = -1 if m else fromindex[indexoffset + i]
                return


awkward_indexedarray32_overlay_mask8_to64
----------------------------------------------------

def awkward_indexedarray32_overlay_mask8_to64(
    toindex: List[int],
    mask: List[int],
    maskoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
):
    return awkward_indexedarray_overlay_mask(
        toindex, mask, maskoffset, fromindex, indexoffset, length
    )


awkward_indexedarrayU32_overlay_mask8_to64
----------------------------------------------------

def awkward_indexedarrayU32_overlay_mask8_to64(
    toindex: List[int],
    mask: List[int],
    maskoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
):
    return awkward_indexedarray_overlay_mask(
        toindex, mask, maskoffset, fromindex, indexoffset, length
    )


awkward_indexedarray64_overlay_mask8_to64
----------------------------------------------------

def awkward_indexedarray64_overlay_mask8_to64(
    toindex: List[int],
    mask: List[int],
    maskoffset: int,
    fromindex: List[int],
    indexoffset: int,
    length: int,
):
    return awkward_indexedarray_overlay_mask(
        toindex, mask, maskoffset, fromindex, indexoffset, length
    )


awkward_indexedarray_mask
----------------------------------------------------

for C in int:
    for M in int:

        def awkward_indexedarray_mask(
            tomask: List[M], fromindex: List[C], indexoffset: int, length: int
        ):
            for i in range(length):
                tomask[i] = fromindex[indexoffset + i] < 0
            return


awkward_indexedarray32_mask8
----------------------------------------------------

def awkward_indexedarray32_mask8(
    tomask: List[int], fromindex: List[int], indexoffset: int, length: int
):
    return awkward_indexedarray_mask(tomask, fromindex, indexoffset, length)


awkward_indexedarrayU32_mask8
----------------------------------------------------

def awkward_indexedarrayU32_mask8(
    tomask: List[int], fromindex: List[int], indexoffset: int, length: int
):
    return awkward_indexedarray_mask(tomask, fromindex, indexoffset, length)


awkward_indexedarray64_mask8
----------------------------------------------------

def awkward_indexedarray64_mask8(
    tomask: List[int], fromindex: List[int], indexoffset: int, length: int
):
    return awkward_indexedarray_mask(tomask, fromindex, indexoffset, length)


awkward_bytemaskedarray_mask
----------------------------------------------------

def awkward_bytemaskedarray_mask(
    tomask: List[M], frommask: List[M], maskoffset: int, length: int, validwhen: bool
):
    for i in range(length):
        tomask[i] = (frommask[maskoffset + i] != 0) != validwhen
    return


awkward_bytemaskedarray_mask8
----------------------------------------------------

def awkward_bytemaskedarray_mask8(
    tomask: List[int],
    frommask: List[int],
    maskoffset: int,
    length: int,
    validwhen: bool,
):
    return awkward_bytemaskedarray_mask(tomask, frommask, maskoffset, length, validwhen)


awkward_zero_mask
----------------------------------------------------

def awkward_zero_mask(tomask: List[M], length: int):
    for i in range(length):
        tomask[i] = 0
    return


awkward_zero_mask8
----------------------------------------------------

def awkward_zero_mask8(tomask: List[int], length: int):
    return awkward_zero_mask(tomask, length)


awkward_indexedarray_simplify
----------------------------------------------------

for OUT in int:
    for IN in int:
        for TO in int:

            def awkward_indexedarray_simplify(
                toindex: List[TO],
                outerindex: List[OUT],
                outeroffset: int,
                outerlength: int,
                innerindex: List[IN],
                inneroffset: int,
                innerlength: int,
            ):
                for i in range(outerlength):
                    j = outerindex[outeroffset + i]
                    if j < 0:
                        toindex[i] = -1
                    else:
                        if j >= innerlength:
                            raise ValueError("index out of range")
                        else:
                            toindex[i] = innerindex[inneroffset + j]
                return


awkward_indexedarray32_simplify32_to64
----------------------------------------------------

def awkward_indexedarray32_simplify32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarray32_simplifyU32_to64
----------------------------------------------------

def awkward_indexedarray32_simplifyU32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarray32_simplify64_to64
----------------------------------------------------

def awkward_indexedarray32_simplify64_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarrayU32_simplify32_to64
----------------------------------------------------

def awkward_indexedarrayU32_simplify32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarrayU32_simplifyU32_to64
----------------------------------------------------

def awkward_indexedarrayU32_simplifyU32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarrayU32_simplify64_to64
----------------------------------------------------

def awkward_indexedarrayU32_simplify64_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarray64_simplify32_to64
----------------------------------------------------

def awkward_indexedarray64_simplify32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarray64_simplifyU32_to64
----------------------------------------------------

def awkward_indexedarray64_simplifyU32_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_indexedarray64_simplify64_to64
----------------------------------------------------

def awkward_indexedarray64_simplify64_to64(
    toindex: List[int],
    outerindex: List[int],
    outeroffset: int,
    outerlength: int,
    innerindex: List[int],
    inneroffset: int,
    innerlength: int,
):
    return awkward_indexedarray_simplify(
        toindex,
        outerindex,
        outeroffset,
        outerlength,
        innerindex,
        inneroffset,
        innerlength,
    )


awkward_regulararray_compact_offsets
----------------------------------------------------

for T in int:

    def awkward_regulararray_compact_offsets(
        tooffsets: List[T], length: int, size: int
    ):
        tooffsets[0] = 0
        for i in range(length):
            tooffsets[i + 1] = (i + 1) * size
        return


awkward_regulararray_compact_offsets64
----------------------------------------------------

def awkward_regulararray_compact_offsets64(
    tooffsets: List[int], length: int, size: int
):
    return awkward_regulararray_compact_offsets(tooffsets, length, size)


awkward_listarray_compact_offsets
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_compact_offsets(
            tooffsets: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            startsoffset: int,
            stopsoffset: int,
            length: int,
        ):
            tooffsets[0] = 0
            for i in range(length):
                start = fromstarts[startsoffset + i]
                stop = fromstops[stopsoffset + i]
                if stop < start:
                    raise ValueError("stops[i] < starts[i]")
                tooffsets[i + 1] = tooffsets[i] + (stop - start)
            return


awkward_listarray32_compact_offsets64
----------------------------------------------------

def awkward_listarray32_compact_offsets64(
    tooffsets: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    startsoffset: int,
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_compact_offsets(
        tooffsets, fromstarts, fromstops, startsoffset, stopsoffset, length
    )


awkward_listarrayU32_compact_offsets64
----------------------------------------------------

def awkward_listarrayU32_compact_offsets64(
    tooffsets: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    startsoffset: int,
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_compact_offsets(
        tooffsets, fromstarts, fromstops, startsoffset, stopsoffset, length
    )


awkward_listarray64_compact_offsets64
----------------------------------------------------

def awkward_listarray64_compact_offsets64(
    tooffsets: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    startsoffset: int,
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_compact_offsets(
        tooffsets, fromstarts, fromstops, startsoffset, stopsoffset, length
    )


awkward_listoffsetarray_compact_offsets
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listoffsetarray_compact_offsets(
            tooffsets: List[T], fromoffsets: List[C], offsetsoffset: int, length: int
        ):
            diff = int(fromoffsets[offsetsoffset + 0])
            tooffsets[0] = 0
            for i in range(length):
                tooffsets[i + 1] = fromoffsets[(offsetsoffset + i) + 1] - diff
            return


awkward_listoffsetarray32_compact_offsets64
----------------------------------------------------

def awkward_listoffsetarray32_compact_offsets64(
    tooffsets: List[int], fromoffsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listoffsetarray_compact_offsets(
        tooffsets, fromoffsets, offsetsoffset, length
    )


awkward_listoffsetarrayU32_compact_offsets64
----------------------------------------------------

def awkward_listoffsetarrayU32_compact_offsets64(
    tooffsets: List[int], fromoffsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listoffsetarray_compact_offsets(
        tooffsets, fromoffsets, offsetsoffset, length
    )


awkward_listoffsetarray64_compact_offsets64
----------------------------------------------------

def awkward_listoffsetarray64_compact_offsets64(
    tooffsets: List[int], fromoffsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listoffsetarray_compact_offsets(
        tooffsets, fromoffsets, offsetsoffset, length
    )


awkward_listarray_broadcast_tooffsets
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_broadcast_tooffsets(
            tocarry: List[T],
            fromoffsets: List[T],
            offsetsoffset: int,
            offsetslength: int,
            fromstarts: List[C],
            startsoffset: int,
            fromstops: List[C],
            stopsoffset: int,
            lencontent: int,
        ):
            k = 0
            for i in range(offsetslength - 1):
                start = int(fromstarts[startsoffset + i])
                stop = int(fromstops[stopsoffset + i])
                if (start != stop) and (stop > lencontent):
                    raise ValueError("stops[i] > len(content)")
                count = int(
                    fromoffsets[(offsetsoffset + i) + 1]
                    - fromoffsets[offsetsoffset + i]
                )
                if count < 0:
                    raise ValueError(
                        "broadcast's offsets must be monotonically increasing"
                    )
                if (stop - start) != count:
                    raise ValueError("cannot broadcast nested list")
                j = start
                while j < stop:
                    tocarry[k] = int(j)
                    k = k + 1
                    j = j + 1
            return


awkward_listarray32_broadcast_tooffsets64
----------------------------------------------------

def awkward_listarray32_broadcast_tooffsets64(
    tocarry: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    lencontent: int,
):
    return awkward_listarray_broadcast_tooffsets(
        tocarry,
        fromoffsets,
        offsetsoffset,
        offsetslength,
        fromstarts,
        startsoffset,
        fromstops,
        stopsoffset,
        lencontent,
    )


awkward_listarrayU32_broadcast_tooffsets64
----------------------------------------------------

def awkward_listarrayU32_broadcast_tooffsets64(
    tocarry: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    lencontent: int,
):
    return awkward_listarray_broadcast_tooffsets(
        tocarry,
        fromoffsets,
        offsetsoffset,
        offsetslength,
        fromstarts,
        startsoffset,
        fromstops,
        stopsoffset,
        lencontent,
    )


awkward_listarray64_broadcast_tooffsets64
----------------------------------------------------

def awkward_listarray64_broadcast_tooffsets64(
    tocarry: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    offsetslength: int,
    fromstarts: List[int],
    startsoffset: int,
    fromstops: List[int],
    stopsoffset: int,
    lencontent: int,
):
    return awkward_listarray_broadcast_tooffsets(
        tocarry,
        fromoffsets,
        offsetsoffset,
        offsetslength,
        fromstarts,
        startsoffset,
        fromstops,
        stopsoffset,
        lencontent,
    )


awkward_regulararray_broadcast_tooffsets
----------------------------------------------------

for T in int:

    def awkward_regulararray_broadcast_tooffsets(
        fromoffsets: List[T], offsetsoffset: int, offsetslength: int, size: int
    ):
        for i in range(offsetslength - 1):
            count = int(
                fromoffsets[(offsetsoffset + i) + 1] - fromoffsets[offsetsoffset + i]
            )
            if count < 0:
                raise ValueError("broadcast's offsets must be monotonically increasing")
            if size != count:
                raise ValueError("cannot broadcast nested list")
        return


awkward_regulararray_broadcast_tooffsets64
----------------------------------------------------

def awkward_regulararray_broadcast_tooffsets64(
    fromoffsets: List[int], offsetsoffset: int, offsetslength: int, size: int
):
    return awkward_regulararray_broadcast_tooffsets(
        fromoffsets, offsetsoffset, offsetslength, size
    )


awkward_regulararray_broadcast_tooffsets_size1
----------------------------------------------------

for T in int:

    def awkward_regulararray_broadcast_tooffsets_size1(
        tocarry: List[T], fromoffsets: List[T], offsetsoffset: int, offsetslength: int
    ):
        k = 0
        for i in range(offsetslength - 1):
            count = int(
                fromoffsets[(offsetsoffset + i) + 1] - fromoffsets[offsetsoffset + i]
            )
            if count < 0:
                raise ValueError("broadcast's offsets must be monotonically increasing")
            for j in range(count):
                tocarry[k] = int(i)
                k = k + 1
        return


awkward_regulararray_broadcast_tooffsets64_size1
----------------------------------------------------

def awkward_regulararray_broadcast_tooffsets64_size1(
    tocarry: List[int], fromoffsets: List[int], offsetsoffset: int, offsetslength: int
):
    return awkward_regulararray_broadcast_tooffsets_size1(
        tocarry, fromoffsets, offsetsoffset, offsetslength
    )


awkward_listoffsetarray_toRegularArray
----------------------------------------------------

for C in int:

    def awkward_listoffsetarray_toRegularArray(
        size: List[int], fromoffsets: List[C], offsetsoffset: int, offsetslength: int
    ):
        size = -1
        for i in range(offsetslength - 1):
            count = int(
                fromoffsets[(offsetsoffset + i) + 1] - fromoffsets[offsetsoffset + i]
            )
            if count < 0:
                raise ValueError("offsets must be monotonically increasing")
            if size == -1:
                size = count
            else:
                if size != count:
                    raise ValueError(
                        "cannot convert to RegularArray because subarray lengths are not regular"
                    )
        if size == -1:
            size = 0
        return


awkward_listoffsetarray32_toRegularArray
----------------------------------------------------

def awkward_listoffsetarray32_toRegularArray(
    size: List[int], fromoffsets: List[int], offsetsoffset: int, offsetslength: int
):
    return awkward_listoffsetarray_toRegularArray(
        size, fromoffsets, offsetsoffset, offsetslength
    )


awkward_listoffsetarrayU32_toRegularArray
----------------------------------------------------

def awkward_listoffsetarrayU32_toRegularArray(
    size: List[int], fromoffsets: List[int], offsetsoffset: int, offsetslength: int
):
    return awkward_listoffsetarray_toRegularArray(
        size, fromoffsets, offsetsoffset, offsetslength
    )


awkward_listoffsetarray64_toRegularArray
----------------------------------------------------

def awkward_listoffsetarray64_toRegularArray(
    size: List[int], fromoffsets: List[int], offsetsoffset: int, offsetslength: int
):
    return awkward_listoffsetarray_toRegularArray(
        size, fromoffsets, offsetsoffset, offsetslength
    )


awkward_numpyarray_fill
----------------------------------------------------

for FROM in (float, int):
    for TO in (float, int):

        def awkward_numpyarray_fill(
            toptr: List[TO],
            tooffset: int,
            fromptr: List[FROM],
            fromoffset: int,
            length: int,
        ):
            for i in range(length):
                toptr[tooffset + i] = int(fromptr[fromoffset + i])
            return


awkward_numpyarray_fill_frombool
----------------------------------------------------

for TO in (float, int, bool):

    def awkward_numpyarray_fill_frombool(
        toptr: List[TO],
        tooffset: int,
        fromptr: List[bool],
        fromoffset: int,
        length: int,
    ):
        for i in range(length):
            toptr[tooffset + i] = int(fromptr[fromoffset + i] != 0)
        return


awkward_numpyarray_fill_todouble_fromdouble
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromdouble(
    toptr: List[double],
    tooffset: int,
    fromptr: List[double],
    fromoffset: int,
    length: int,
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_fromfloat
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromfloat(
    toptr: List[double],
    tooffset: int,
    fromptr: List[float],
    fromoffset: int,
    length: int,
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_from64
----------------------------------------------------

def awkward_numpyarray_fill_todouble_from64(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_fromU64
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromU64(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_from32
----------------------------------------------------

def awkward_numpyarray_fill_todouble_from32(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_fromU32
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromU32(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_from16
----------------------------------------------------

def awkward_numpyarray_fill_todouble_from16(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_fromU16
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromU16(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_from8
----------------------------------------------------

def awkward_numpyarray_fill_todouble_from8(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_fromU8
----------------------------------------------------

def awkward_numpyarray_fill_todouble_fromU8(
    toptr: List[double], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_todouble_frombool
----------------------------------------------------

def awkward_numpyarray_fill_todouble_frombool(
    toptr: List[double],
    tooffset: int,
    fromptr: List[bool],
    fromoffset: int,
    length: int,
):
    return awkward_numpyarray_fill_fromint(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_toU64_fromU64
----------------------------------------------------

def awkward_numpyarray_fill_toU64_fromU64(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_from64
----------------------------------------------------

def awkward_numpyarray_fill_to64_from64(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_fromU64
----------------------------------------------------

def awkward_numpyarray_fill_to64_fromU64(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    for i in range(length):
        if fromptr[fromoffset + i] > kMaxInt64:
            raise ValueError("uint64 value too large for int64 output")
        toptr[tooffset + i] = fromptr[fromoffset + i]
    return


awkward_numpyarray_fill_to64_from32
----------------------------------------------------

def awkward_numpyarray_fill_to64_from32(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_fromU32
----------------------------------------------------

def awkward_numpyarray_fill_to64_fromU32(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_from16
----------------------------------------------------

def awkward_numpyarray_fill_to64_from16(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_fromU16
----------------------------------------------------

def awkward_numpyarray_fill_to64_fromU16(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_from8
----------------------------------------------------

def awkward_numpyarray_fill_to64_from8(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_fromU8
----------------------------------------------------

def awkward_numpyarray_fill_to64_fromU8(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_to64_frombool
----------------------------------------------------

def awkward_numpyarray_fill_to64_frombool(
    toptr: List[int], tooffset: int, fromptr: List[bool], fromoffset: int, length: int
):
    return awkward_numpyarray_fill_fromint(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_tobool_frombool
----------------------------------------------------

def awkward_numpyarray_fill_tobool_frombool(
    toptr: List[bool], tooffset: int, fromptr: List[bool], fromoffset: int, length: int
):
    return awkward_numpyarray_fill_fromint(toptr, tooffset, fromptr, fromoffset, length)


awkward_numpyarray_fill_tobyte_frombyte
----------------------------------------------------

def awkward_numpyarray_fill_tobyte_frombyte(
    toptr: List[int], tooffset: int, fromptr: List[int], fromoffset: int, length: int
):
    return awkward_numpyarray_fill(toptr, tooffset, fromptr, fromoffset, length)


awkward_listarray_fill
----------------------------------------------------

for FROM in int:
    for TO in int:

        def awkward_listarray_fill(
            tostarts: List[TO],
            tostartsoffset: int,
            tostops: List[TO],
            tostopsoffset: int,
            fromstarts: List[FROM],
            fromstartsoffset: int,
            fromstops: List[FROM],
            fromstopsoffset: int,
            length: int,
            base: int,
        ):
            for i in range(length):
                tostarts[tostartsoffset + i] = int(
                    fromstarts[fromstartsoffset + i] + base
                )
                tostops[tostopsoffset + i] = int(fromstops[fromstopsoffset + i] + base)
            return


awkward_listarray_fill_to64_from32
----------------------------------------------------

def awkward_listarray_fill_to64_from32(
    tostarts: List[int],
    tostartsoffset: int,
    tostops: List[int],
    tostopsoffset: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    length: int,
    base: int,
):
    return awkward_listarray_fill(
        tostarts,
        tostartsoffset,
        tostops,
        tostopsoffset,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        length,
        base,
    )


awkward_listarray_fill_to64_fromU32
----------------------------------------------------

def awkward_listarray_fill_to64_fromU32(
    tostarts: List[int],
    tostartsoffset: int,
    tostops: List[int],
    tostopsoffset: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    length: int,
    base: int,
):
    return awkward_listarray_fill(
        tostarts,
        tostartsoffset,
        tostops,
        tostopsoffset,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        length,
        base,
    )


awkward_listarray_fill_to64_from64
----------------------------------------------------

def awkward_listarray_fill_to64_from64(
    tostarts: List[int],
    tostartsoffset: int,
    tostops: List[int],
    tostopsoffset: int,
    fromstarts: List[int],
    fromstartsoffset: int,
    fromstops: List[int],
    fromstopsoffset: int,
    length: int,
    base: int,
):
    return awkward_listarray_fill(
        tostarts,
        tostartsoffset,
        tostops,
        tostopsoffset,
        fromstarts,
        fromstartsoffset,
        fromstops,
        fromstopsoffset,
        length,
        base,
    )


awkward_indexedarray_fill
----------------------------------------------------

for FROM in int:
    for TO in int:

        def awkward_indexedarray_fill(
            toindex: List[TO],
            toindexoffset: int,
            fromindex: List[FROM],
            fromindexoffset: int,
            length: int,
            base: int,
        ):
            for i in range(length):
                fromval = fromindex[fromindexoffset + i]
                toindex[toindexoffset + i] = -1 if fromval < 0 else int(fromval + base)
            return


awkward_indexedarray_fill_to64_from32
----------------------------------------------------

def awkward_indexedarray_fill_to64_from32(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    base: int,
):
    return awkward_indexedarray_fill(
        toindex, toindexoffset, fromindex, fromindexoffset, length, base
    )


awkward_indexedarray_fill_to64_fromU32
----------------------------------------------------

def awkward_indexedarray_fill_to64_fromU32(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    base: int,
):
    return awkward_indexedarray_fill(
        toindex, toindexoffset, fromindex, fromindexoffset, length, base
    )


awkward_indexedarray_fill_to64_from64
----------------------------------------------------

def awkward_indexedarray_fill_to64_from64(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
    base: int,
):
    return awkward_indexedarray_fill(
        toindex, toindexoffset, fromindex, fromindexoffset, length, base
    )


awkward_indexedarray_fill_count
----------------------------------------------------

def awkward_indexedarray_fill_count(
    toindex: List[TO], toindexoffset: int, length: int, base: int
):
    for i in range(length):
        toindex[toindexoffset + i] = i + base
    return


awkward_indexedarray_fill_to64_count
----------------------------------------------------

def awkward_indexedarray_fill_to64_count(
    toindex: List[int], toindexoffset: int, length: int, base: int
):
    return awkward_indexedarray_fill_count(toindex, toindexoffset, length, base)


awkward_unionarray_filltags
----------------------------------------------------

for FROM in int:
    for TO in int:

        def awkward_unionarray_filltags(
            totags: List[TO],
            totagsoffset: int,
            fromtags: List[FROM],
            fromtagsoffset: int,
            length: int,
            base: int,
        ):
            for i in range(length):
                totags[totagsoffset + i] = int(fromtags[fromtagsoffset + i] + base)
            return


awkward_unionarray_filltags_to8_from8
----------------------------------------------------

def awkward_unionarray_filltags_to8_from8(
    totags: List[int],
    totagsoffset: int,
    fromtags: List[int],
    fromtagsoffset: int,
    length: int,
    base: int,
):
    return awkward_unionarray_filltags(
        totags, totagsoffset, fromtags, fromtagsoffset, length, base
    )


awkward_unionarray_fillindex
----------------------------------------------------

for FROM in int:
    for TO in int:

        def awkward_unionarray_fillindex(
            toindex: List[TO],
            toindexoffset: int,
            fromindex: List[FROM],
            fromindexoffset: int,
            length: int,
        ):
            for i in range(length):
                toindex[toindexoffset + i] = int(fromindex[fromindexoffset + i])
            return


awkward_unionarray_fillindex_to64_from32
----------------------------------------------------

def awkward_unionarray_fillindex_to64_from32(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_unionarray_fillindex(
        toindex, toindexoffset, fromindex, fromindexoffset, length
    )


awkward_unionarray_fillindex_to64_fromU32
----------------------------------------------------

def awkward_unionarray_fillindex_to64_fromU32(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_unionarray_fillindex(
        toindex, toindexoffset, fromindex, fromindexoffset, length
    )


awkward_unionarray_fillindex_to64_from64
----------------------------------------------------

def awkward_unionarray_fillindex_to64_from64(
    toindex: List[int],
    toindexoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    length: int,
):
    return awkward_unionarray_fillindex(
        toindex, toindexoffset, fromindex, fromindexoffset, length
    )


awkward_unionarray_filltags_const
----------------------------------------------------

for TO in int:

    def awkward_unionarray_filltags_const(
        totags: List[TO], totagsoffset: int, length: int, base: int
    ):
        for i in range(length):
            totags[totagsoffset + i] = int(base)
        return


awkward_unionarray_filltags_to8_const
----------------------------------------------------

def awkward_unionarray_filltags_to8_const(
    totags: List[int], totagsoffset: int, length: int, base: int
):
    return awkward_unionarray_filltags_const(totags, totagsoffset, length, base)


awkward_unionarray_fillindex_count
----------------------------------------------------

for TO in int:

    def awkward_unionarray_fillindex_count(
        toindex: List[TO], toindexoffset: int, length: int
    ):
        for i in range(length):
            toindex[toindexoffset + i] = int(i)
        return


awkward_unionarray_fillindex_to64_count
----------------------------------------------------

def awkward_unionarray_fillindex_to64_count(
    toindex: List[int], toindexoffset: int, length: int
):
    return awkward_unionarray_fillindex_count(toindex, toindexoffset, length)


awkward_unionarray_simplify
----------------------------------------------------

for OUTERTAGS in int:
    for OUTERINDEX in int:
        for INNERTAGS in int:
            for INNERINDEX in int:
                for TOTAGS in int:
                    for TOINDEX in int:

                        def awkward_unionarray_simplify(
                            totags: List[TOTAGS],
                            toindex: List[TOINDEX],
                            outertags: List[OUTERTAGS],
                            outertagsoffset: int,
                            outerindex: List[OUTERINDEX],
                            outerindexoffset: int,
                            innertags: List[INNERTAGS],
                            innertagsoffset: int,
                            innerindex: List[INNERINDEX],
                            innerindexoffset: int,
                            towhich: int,
                            innerwhich: int,
                            outerwhich: int,
                            length: int,
                            base: int,
                        ):
                            for i in range(length):
                                if outertags[outertagsoffset + i] == outerwhich:
                                    j = outerindex[outerindexoffset + i]
                                    if innertags[innertagsoffset + j] == innerwhich:
                                        totags[i] = int(towhich)
                                        toindex[i] = int(
                                            innerindex[innerindexoffset + j] + base
                                        )
                            return


awkward_unionarray8_32_simplify8_32_to8_64
----------------------------------------------------

def awkward_unionarray8_32_simplify8_32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_32_simplify8_U32_to8_64
----------------------------------------------------

def awkward_unionarray8_32_simplify8_U32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_32_simplify8_64_to8_64
----------------------------------------------------

def awkward_unionarray8_32_simplify8_64_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_U32_simplify8_32_to8_64
----------------------------------------------------

def awkward_unionarray8_U32_simplify8_32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_U32_simplify8_U32_to8_64
----------------------------------------------------

def awkward_unionarray8_U32_simplify8_U32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_U32_simplify8_64_to8_64
----------------------------------------------------

def awkward_unionarray8_U32_simplify8_64_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_64_simplify8_32_to8_64
----------------------------------------------------

def awkward_unionarray8_64_simplify8_32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_64_simplify8_U32_to8_64
----------------------------------------------------

def awkward_unionarray8_64_simplify8_U32_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray8_64_simplify8_64_to8_64
----------------------------------------------------

def awkward_unionarray8_64_simplify8_64_to8_64(
    totags: List[int],
    toindex: List[int],
    outertags: List[int],
    outertagsoffset: int,
    outerindex: List[int],
    outerindexoffset: int,
    innertags: List[int],
    innertagsoffset: int,
    innerindex: List[int],
    innerindexoffset: int,
    towhich: int,
    innerwhich: int,
    outerwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify(
        totags,
        toindex,
        outertags,
        outertagsoffset,
        outerindex,
        outerindexoffset,
        innertags,
        innertagsoffset,
        innerindex,
        innerindexoffset,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    )


awkward_unionarray_simplify_one
----------------------------------------------------

for FROMTAGS in int:
    for FROMINDEX in int:
        for TOTAGS in int:
            for TOINDEX in int:

                def awkward_unionarray_simplify_one(
                    totags: List[TOTAGS],
                    toindex: List[TOINDEX],
                    fromtags: List[FROMTAGS],
                    fromtagsoffset: int,
                    fromindex: List[FROMINDEX],
                    fromindexoffset: int,
                    towhich: int,
                    fromwhich: int,
                    length: int,
                    base: int,
                ):
                    for i in range(length):
                        if fromtags[fromtagsoffset + i] == fromwhich:
                            totags[i] = int(towhich)
                            toindex[i] = int(fromindex[fromindexoffset + i] + base)
                    return


awkward_unionarray8_32_simplify_one_to8_64
----------------------------------------------------

def awkward_unionarray8_32_simplify_one_to8_64(
    totags: List[int],
    toindex: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    towhich: int,
    fromwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify_one(
        totags,
        toindex,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        towhich,
        fromwhich,
        length,
        base,
    )


awkward_unionarray8_U32_simplify_one_to8_64
----------------------------------------------------

def awkward_unionarray8_U32_simplify_one_to8_64(
    totags: List[int],
    toindex: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    towhich: int,
    fromwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify_one(
        totags,
        toindex,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        towhich,
        fromwhich,
        length,
        base,
    )


awkward_unionarray8_64_simplify_one_to8_64
----------------------------------------------------

def awkward_unionarray8_64_simplify_one_to8_64(
    totags: List[int],
    toindex: List[int],
    fromtags: List[int],
    fromtagsoffset: int,
    fromindex: List[int],
    fromindexoffset: int,
    towhich: int,
    fromwhich: int,
    length: int,
    base: int,
):
    return awkward_unionarray_simplify_one(
        totags,
        toindex,
        fromtags,
        fromtagsoffset,
        fromindex,
        fromindexoffset,
        towhich,
        fromwhich,
        length,
        base,
    )


awkward_listarray_validity
----------------------------------------------------

for C in int:

    def awkward_listarray_validity(
        starts: List[C],
        startsoffset: int,
        stops: List[C],
        stopsoffset: int,
        length: int,
        lencontent: int,
    ):
        for i in range(length):
            start = starts[startsoffset + i]
            stop = stops[stopsoffset + i]
            if start != stop:
                if start > stop:
                    raise ValueError("start[i] > stop[i]")
                if start < 0:
                    raise ValueError("start[i] < 0")
                if stop > lencontent:
                    raise ValueError("stop[i] > len(content)")
        return


awkward_listarray32_validity
----------------------------------------------------

def awkward_listarray32_validity(
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
    lencontent: int,
):
    return awkward_listarray_validity(
        starts, startsoffset, stops, stopsoffset, length, lencontent
    )


awkward_listarrayU32_validity
----------------------------------------------------

def awkward_listarrayU32_validity(
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
    lencontent: int,
):
    return awkward_listarray_validity(
        starts, startsoffset, stops, stopsoffset, length, lencontent
    )


awkward_listarray64_validity
----------------------------------------------------

def awkward_listarray64_validity(
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
    lencontent: int,
):
    return awkward_listarray_validity(
        starts, startsoffset, stops, stopsoffset, length, lencontent
    )


awkward_indexedarray_validity
----------------------------------------------------

for C in int:
    for ISOPTION in bool:

        def awkward_indexedarray_validity(
            index: List[C], indexoffset: int, length: int, lencontent: int
        ):
            for i in range(length):
                idx = index[indexoffset + i]
                if not ISOPTION:
                    if idx < 0:
                        raise ValueError("index[i] < 0")
                if idx >= lencontent:
                    raise ValueError("index[i] >= len(content)")
            return


awkward_indexedarray32_validity
----------------------------------------------------

def awkward_indexedarray32_validity(
    index: List[int], indexoffset: int, length: int, lencontent: int, isoption: bool
):
    if isoption:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)
    else:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)


awkward_indexedarrayU32_validity
----------------------------------------------------

def awkward_indexedarrayU32_validity(
    index: List[int], indexoffset: int, length: int, lencontent: int, isoption: bool
):
    if isoption:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)
    else:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)


awkward_indexedarray64_validity
----------------------------------------------------

def awkward_indexedarray64_validity(
    index: List[int], indexoffset: int, length: int, lencontent: int, isoption: bool
):
    if isoption:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)
    else:
        return awkward_indexedarray_validity(index, indexoffset, length, lencontent)


awkward_unionarray_validity
----------------------------------------------------

for T in int:
    for I in int:

        def awkward_unionarray_validity(
            tags: List[T],
            tagsoffset: int,
            index: List[I],
            indexoffset: int,
            length: int,
            numcontents: int,
            lencontents: List[int],
        ):
            for i in range(length):
                tag = tags[tagsoffset + i]
                idx = index[indexoffset + i]
                if tag < 0:
                    raise ValueError("tags[i] < 0")
                if idx < 0:
                    raise ValueError("index[i] < 0")
                if tag >= numcontents:
                    raise ValueError("tags[i] >= len(contents)")
                lencontent = lencontents[tag]
                if idx >= lencontent:
                    raise ValueError("index[i] >= len(content[tags[i]])")
            return


awkward_unionarray8_32_validity
----------------------------------------------------

def awkward_unionarray8_32_validity(
    tags: List[int],
    tagsoffset: int,
    index: List[int],
    indexoffset: int,
    length: int,
    numcontents: int,
    lencontents: List[int],
):
    return awkward_unionarray_validity(
        tags, tagsoffset, index, indexoffset, length, numcontents, lencontents
    )


awkward_unionarray8_U32_validity
----------------------------------------------------

def awkward_unionarray8_U32_validity(
    tags: List[int],
    tagsoffset: int,
    index: List[int],
    indexoffset: int,
    length: int,
    numcontents: int,
    lencontents: List[int],
):
    return awkward_unionarray_validity(
        tags, tagsoffset, index, indexoffset, length, numcontents, lencontents
    )


awkward_unionarray8_64_validity
----------------------------------------------------

def awkward_unionarray8_64_validity(
    tags: List[int],
    tagsoffset: int,
    index: List[int],
    indexoffset: int,
    length: int,
    numcontents: int,
    lencontents: List[int],
):
    return awkward_unionarray_validity(
        tags, tagsoffset, index, indexoffset, length, numcontents, lencontents
    )


awkward_UnionArray_fillna
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_UnionArray_fillna(
            toindex: List[T], fromindex: List[C], offset: int, length: int
        ):
            for i in range(length):
                toindex[i] = fromindex[offset + i] if fromindex[offset + i] >= 0 else 0
            return


awkward_UnionArray_fillna_from32_to64
----------------------------------------------------

def awkward_UnionArray_fillna_from32_to64(
    toindex: List[int], fromindex: List[int], offset: int, length: int
):
    return awkward_UnionArray_fillna(toindex, fromindex, offset, length)


awkward_UnionArray_fillna_fromU32_to64
----------------------------------------------------

def awkward_UnionArray_fillna_fromU32_to64(
    toindex: List[int], fromindex: List[int], offset: int, length: int
):
    return awkward_UnionArray_fillna(toindex, fromindex, offset, length)


awkward_UnionArray_fillna_from64_to64
----------------------------------------------------

def awkward_UnionArray_fillna_from64_to64(
    toindex: List[int], fromindex: List[int], offset: int, length: int
):
    return awkward_UnionArray_fillna(toindex, fromindex, offset, length)


awkward_IndexedOptionArray_rpad_and_clip_mask_axis1
----------------------------------------------------

for T in int:

    def awkward_IndexedOptionArray_rpad_and_clip_mask_axis1(
        toindex: List[T], frommask: List[int], length: int
    ):
        count = 0
        for i in range(length):
            if frommask[i]:
                toindex[i] = -1
            else:
                toindex[i] = count = count + 1
        return


awkward_IndexedOptionArray_rpad_and_clip_mask_axis1_64
----------------------------------------------------

def awkward_IndexedOptionArray_rpad_and_clip_mask_axis1_64(
    toindex: List[int], frommask: List[int], length: int
):
    return awkward_IndexedOptionArray_rpad_and_clip_mask_axis1(
        toindex, frommask, length
    )


awkward_index_rpad_and_clip_axis0
----------------------------------------------------

for T in int:

    def awkward_index_rpad_and_clip_axis0(toindex: List[T], target: int, length: int):
        shorter = target if target < length else length
        for i in range(shorter):
            toindex[i] = i
        i = shorter
        while i < target:
            toindex[i] = -1
            i = i + 1
        return


awkward_index_rpad_and_clip_axis0_64
----------------------------------------------------

def awkward_index_rpad_and_clip_axis0_64(toindex: List[int], target: int, length: int):
    return awkward_index_rpad_and_clip_axis0(toindex, target, length)


awkward_index_rpad_and_clip_axis1
----------------------------------------------------

for T in int:

    def awkward_index_rpad_and_clip_axis1(
        tostarts: List[T], tostops: List[T], target: int, length: int
    ):
        offset = 0
        for i in range(length):
            tostarts[i] = offset
            offset = offset + target
            tostops[i] = offset
        return


awkward_index_rpad_and_clip_axis1_64
----------------------------------------------------

def awkward_index_rpad_and_clip_axis1_64(
    tostarts: List[int], tostops: List[int], target: int, length: int
):
    return awkward_index_rpad_and_clip_axis1(tostarts, tostops, target, length)


awkward_RegularArray_rpad_and_clip_axis1
----------------------------------------------------

for T in int:

    def awkward_RegularArray_rpad_and_clip_axis1(
        toindex: List[T], target: int, size: int, length: int
    ):
        shorter = target if target < size else size
        for i in range(length):
            for j in range(shorter):
                toindex[(i * target) + j] = (i * size) + j
            j = shorter
            while j < target:
                toindex[(i * target) + j] = -1
                j = j + 1
        return


awkward_RegularArray_rpad_and_clip_axis1_64
----------------------------------------------------

def awkward_RegularArray_rpad_and_clip_axis1_64(
    toindex: List[int], target: int, size: int, length: int
):
    return awkward_RegularArray_rpad_and_clip_axis1(toindex, target, size, length)


awkward_ListArray_min_range
----------------------------------------------------

for C in int:

    def awkward_ListArray_min_range(
        tomin: List[int],
        fromstarts: List[C],
        fromstops: List[C],
        lenstarts: int,
        startsoffset: int,
        stopsoffset: int,
    ):
        shorter = fromstops[stopsoffset + 0] - fromstarts[startsoffset + 0]
        i = 1
        while i < lenstarts:
            range = fromstops[startsoffset + i] - fromstarts[stopsoffset + i]
            shorter = shorter if shorter < range else range
            i = i + 1
        tomin = shorter
        return


awkward_ListArray32_min_range
----------------------------------------------------

def awkward_ListArray32_min_range(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_min_range(
        tomin, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArrayU32_min_range
----------------------------------------------------

def awkward_ListArrayU32_min_range(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_min_range(
        tomin, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArray64_min_range
----------------------------------------------------

def awkward_ListArray64_min_range(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_min_range(
        tomin, fromstarts, fromstops, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArray_rpad_and_clip_length_axis1
----------------------------------------------------

for C in int:

    def awkward_ListArray_rpad_and_clip_length_axis1(
        tolength: List[int],
        fromstarts: List[C],
        fromstops: List[C],
        target: int,
        lenstarts: int,
        startsoffset: int,
        stopsoffset: int,
    ):
        length = 0
        for i in range(lenstarts):
            range = fromstops[startsoffset + i] - fromstarts[stopsoffset + i]
            length = target if target > range else range
        tolength = length
        return


awkward_ListArray32_rpad_and_clip_length_axis1
----------------------------------------------------

def awkward_ListArray32_rpad_and_clip_length_axis1(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    target: int,
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_and_clip_length_axis1(
        tomin, fromstarts, fromstops, target, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArrayU32_rpad_and_clip_length_axis1
----------------------------------------------------

def awkward_ListArrayU32_rpad_and_clip_length_axis1(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    target: int,
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_and_clip_length_axis1(
        tomin, fromstarts, fromstops, target, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArray64_rpad_and_clip_length_axis1
----------------------------------------------------

def awkward_ListArray64_rpad_and_clip_length_axis1(
    tomin: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    target: int,
    lenstarts: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_and_clip_length_axis1(
        tomin, fromstarts, fromstops, target, lenstarts, startsoffset, stopsoffset
    )


awkward_ListArray_rpad_axis1
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_ListArray_rpad_axis1(
            toindex: List[T],
            fromstarts: List[C],
            fromstops: List[C],
            tostarts: List[C],
            tostops: List[C],
            target: int,
            length: int,
            startsoffset: int,
            stopsoffset: int,
        ):
            offset = 0
            for i in range(length):
                tostarts[i] = offset
                range = fromstops[startsoffset + i] - fromstarts[stopsoffset + i]
                for j in range(range):
                    toindex[offset + j] = fromstarts[startsoffset + i] + j
                j = range
                while j < target:
                    toindex[offset + j] = -1
                    j = j + 1
                offset = tostarts[i] + target if target > range else tostarts[i] + range
                tostops[i] = offset
            return


awkward_ListArray32_rpad_axis1_64
----------------------------------------------------

def awkward_ListArray32_rpad_axis1_64(
    toindex: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    tostarts: List[int],
    tostops: List[int],
    target: int,
    length: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_axis1(
        toindex,
        fromstarts,
        fromstops,
        tostarts,
        tostops,
        target,
        length,
        startsoffset,
        stopsoffset,
    )


awkward_ListArrayU32_rpad_axis1_64
----------------------------------------------------

def awkward_ListArrayU32_rpad_axis1_64(
    toindex: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    tostarts: List[int],
    tostops: List[int],
    target: int,
    length: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_axis1(
        toindex,
        fromstarts,
        fromstops,
        tostarts,
        tostops,
        target,
        length,
        startsoffset,
        stopsoffset,
    )


awkward_ListArray64_rpad_axis1_64
----------------------------------------------------

def awkward_ListArray64_rpad_axis1_64(
    toindex: List[int],
    fromstarts: List[int],
    fromstops: List[int],
    tostarts: List[int],
    tostops: List[int],
    target: int,
    length: int,
    startsoffset: int,
    stopsoffset: int,
):
    return awkward_ListArray_rpad_axis1(
        toindex,
        fromstarts,
        fromstops,
        tostarts,
        tostops,
        target,
        length,
        startsoffset,
        stopsoffset,
    )


awkward_ListOffsetArray_rpad_and_clip_axis1
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_ListOffsetArray_rpad_and_clip_axis1(
            toindex: List[T],
            fromoffsets: List[C],
            offsetsoffset: int,
            length: int,
            target: int,
        ):
            for i in range(length):
                range = int(
                    fromoffsets[(offsetsoffset + i) + 1]
                    - fromoffsets[offsetsoffset + i]
                )
                shorter = target if target < range else range
                for j in range(shorter):
                    toindex[(i * target) + j] = int(fromoffsets[offsetsoffset + i]) + j
                j = shorter
                while j < target:
                    toindex[(i * target) + j] = -1
                    j = j + 1
            return


awkward_ListOffsetArray32_rpad_and_clip_axis1_64
----------------------------------------------------

def awkward_ListOffsetArray32_rpad_and_clip_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    length: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_and_clip_axis1(
        toindex, fromoffsets, offsetsoffset, length, target
    )


awkward_ListOffsetArrayU32_rpad_and_clip_axis1_64
----------------------------------------------------

def awkward_ListOffsetArrayU32_rpad_and_clip_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    length: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_and_clip_axis1(
        toindex, fromoffsets, offsetsoffset, length, target
    )


awkward_ListOffsetArray64_rpad_and_clip_axis1_64
----------------------------------------------------

def awkward_ListOffsetArray64_rpad_and_clip_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    length: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_and_clip_axis1(
        toindex, fromoffsets, offsetsoffset, length, target
    )


awkward_ListOffsetArray_rpad_length_axis1
----------------------------------------------------

for C in int:

    def awkward_ListOffsetArray_rpad_length_axis1(
        tooffsets: List[C],
        fromoffsets: List[C],
        offsetsoffset: int,
        fromlength: int,
        target: int,
        tolength: List[int],
    ):
        length = 0
        tooffsets[0] = 0
        for i in range(fromlength):
            range = (
                fromoffsets[(offsetsoffset + i) + 1] - fromoffsets[offsetsoffset + i]
            )
            longer = range if target < range else target
            length = length + longer
            tooffsets[i + 1] = tooffsets[i] + longer
        tolength = length
        return


awkward_ListOffsetArray32_rpad_length_axis1
----------------------------------------------------

def awkward_ListOffsetArray32_rpad_length_axis1(
    tooffsets: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
    tolength: List[int],
):
    return awkward_ListOffsetArray_rpad_length_axis1(
        tooffsets, fromoffsets, offsetsoffset, fromlength, target, tolength
    )


awkward_ListOffsetArrayU32_rpad_length_axis1
----------------------------------------------------

def awkward_ListOffsetArrayU32_rpad_length_axis1(
    tooffsets: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
    tolength: List[int],
):
    return awkward_ListOffsetArray_rpad_length_axis1(
        tooffsets, fromoffsets, offsetsoffset, fromlength, target, tolength
    )


awkward_ListOffsetArray64_rpad_length_axis1
----------------------------------------------------

def awkward_ListOffsetArray64_rpad_length_axis1(
    tooffsets: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
    tolength: List[int],
):
    return awkward_ListOffsetArray_rpad_length_axis1(
        tooffsets, fromoffsets, offsetsoffset, fromlength, target, tolength
    )


awkward_ListOffsetArray_rpad_axis1
----------------------------------------------------

for T in int:
    for C in int:

        def awkward_ListOffsetArray_rpad_axis1(
            toindex: List[T],
            fromoffsets: List[C],
            offsetsoffset: int,
            fromlength: int,
            target: int,
        ):
            count = 0
            for i in range(fromlength):
                range = int(
                    fromoffsets[(offsetsoffset + i) + 1]
                    - fromoffsets[offsetsoffset + i]
                )
                for j in range(range):
                    count = count + 1
                    toindex[count] = int(fromoffsets[offsetsoffset + i]) + j
                j = range
                while j < target:
                    count = count + 1
                    toindex[count] = -1
                    j = j + 1
            return


awkward_ListOffsetArray32_rpad_axis1_64
----------------------------------------------------

def awkward_ListOffsetArray32_rpad_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_axis1(
        toindex, fromoffsets, offsetsoffset, fromlength, target
    )


awkward_ListOffsetArrayU32_rpad_axis1_64
----------------------------------------------------

def awkward_ListOffsetArrayU32_rpad_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_axis1(
        toindex, fromoffsets, offsetsoffset, fromlength, target
    )


awkward_ListOffsetArray64_rpad_axis1_64
----------------------------------------------------

def awkward_ListOffsetArray64_rpad_axis1_64(
    toindex: List[int],
    fromoffsets: List[int],
    offsetsoffset: int,
    fromlength: int,
    target: int,
):
    return awkward_ListOffsetArray_rpad_axis1(
        toindex, fromoffsets, offsetsoffset, fromlength, target
    )


awkward_localindex
----------------------------------------------------

for T in int:

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


awkward_localindex_64
----------------------------------------------------

def awkward_localindex_64(toindex: List[int], length: int):
    return awkward_localindex(toindex, length)


awkward_listarray_localindex
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_localindex(
            toindex: List[T], offsets: List[C], offsetsoffset: int, length: int
        ):
            for i in range(length):
                start = int(offsets[offsetsoffset + i])
                stop = int(offsets[(offsetsoffset + i) + 1])
                j = start
                while j < stop:
                    toindex[j] = j - start
                    j = j + 1
            return


awkward_listarray32_localindex_64
----------------------------------------------------

def awkward_listarray32_localindex_64(
    toindex: List[int], offsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listarray_localindex(toindex, offsets, offsetsoffset, length)


awkward_listarrayU32_localindex_64
----------------------------------------------------

def awkward_listarrayU32_localindex_64(
    toindex: List[int], offsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listarray_localindex(toindex, offsets, offsetsoffset, length)


awkward_listarray64_localindex_64
----------------------------------------------------

def awkward_listarray64_localindex_64(
    toindex: List[int], offsets: List[int], offsetsoffset: int, length: int
):
    return awkward_listarray_localindex(toindex, offsets, offsetsoffset, length)


awkward_regulararray_localindex
----------------------------------------------------

for T in int:

    def awkward_regulararray_localindex(toindex: List[T], size: int, length: int):
        for i in range(length):
            for j in range(size):
                toindex[(i * size) + j] = j
        return


awkward_regulararray_localindex_64
----------------------------------------------------

def awkward_regulararray_localindex_64(toindex: List[int], size: int, length: int):
    return awkward_regulararray_localindex(toindex, size, length)


awkward_combinations
----------------------------------------------------

for T in int:

    def awkward_combinations(
        toindex: List[T], n: int, replacement: bool, singlelen: int
    ):
        raise ValueError("FIXME: awkward_combinations")


awkward_combinations_64
----------------------------------------------------

def awkward_combinations_64(
    toindex: List[int], n: int, replacement: bool, singlelen: int
):
    return awkward_combinations(toindex, n, replacement, singlelen)


awkward_listarray_combinations_length
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_combinations_length(
            totallen: List[int],
            tooffsets: List[T],
            n: int,
            replacement: bool,
            starts: List[C],
            startsoffset: int,
            stops: List[C],
            stopsoffset: int,
            length: int,
        ):
            totallen = 0
            tooffsets[0] = 0
            for i in range(length):
                size = int(stops[stopsoffset + i] - starts[startsoffset + i])
                if replacement:
                    size = n - 1
                thisn = n

                if thisn > size:
                    combinationslen = 0
                else:
                    if thisn == size:
                        combinationslen = 1
                    else:
                        if (thisn * 2) > size:
                            thisn = size - thisn
                        combinationslen = size
                        j = 2
                        while j <= thisn:
                            combinationslen = (size - j) + 1
                            combinationslen = j
                            j = j + 1
                totallen = totallen + combinationslen
                tooffsets[i + 1] = tooffsets[i] + combinationslen
            return


awkward_listarray32_combinations_length_64
----------------------------------------------------

def awkward_listarray32_combinations_length_64(
    totallen: List[int],
    tooffsets: List[int],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations_length(
        totallen,
        tooffsets,
        n,
        replacement,
        starts,
        startsoffset,
        stops,
        stopsoffset,
        length,
    )


awkward_listarrayU32_combinations_length_64
----------------------------------------------------

def awkward_listarrayU32_combinations_length_64(
    totallen: List[int],
    tooffsets: List[int],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations_length(
        totallen,
        tooffsets,
        n,
        replacement,
        starts,
        startsoffset,
        stops,
        stopsoffset,
        length,
    )


awkward_listarray64_combinations_length_64
----------------------------------------------------

def awkward_listarray64_combinations_length_64(
    totallen: List[int],
    tooffsets: List[int],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations_length(
        totallen,
        tooffsets,
        n,
        replacement,
        starts,
        startsoffset,
        stops,
        stopsoffset,
        length,
    )


awkward_listarray_combinations_step
----------------------------------------------------

def awkward_listarray_combinations_step(
    tocarry: List[List[int]],
    toindex: List[int],
    fromindex: List[int],
    j: int,
    stop: int,
    n: int,
    replacement: bool,
):
    while fromindex[j] < stop:
        if replacement:
            k = j + 1
            while k < n:
                fromindex[k] = fromindex[j]
                k = k + 1
        else:
            k = j + 1
            while k < n:
                fromindex[k] = fromindex[j] + (k - j)
                k = k + 1
        if (j + 1) == n:
            for k in range(n):
                tocarry[k][toindex[k]] = fromindex[k]
                toindex[k] = toindex[k] + 1
        else:
            awkward_listarray_combinations_step(
                tocarry, toindex, fromindex, j + 1, stop, n, replacement
            )
        fromindex[j] = fromindex[j] + 1


awkward_listarray_combinations
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_listarray_combinations(
            tocarry: List[List[int]],
            n: int,
            replacement: bool,
            starts: List[C],
            startsoffset: int,
            stops: List[C],
            stopsoffset: int,
            length: int,
        ):
            toindex = []
            fromindex = []
            for j in range(n):
                toindex[j] = 0
            for i in range(length):
                start = int(starts[startsoffset + i])
                stop = int(stops[stopsoffset + i])
                fromindex[0] = start
                awkward_listarray_combinations_step(
                    tocarry, toindex, fromindex, 0, stop, n, replacement
                )
            return


awkward_listarray32_combinations_64
----------------------------------------------------

def awkward_listarray32_combinations_64(
    tocarry: List[List[int]],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations(
        tocarry, n, replacement, starts, startsoffset, stops, stopsoffset, length
    )


awkward_listarrayU32_combinations_64
----------------------------------------------------

def awkward_listarrayU32_combinations_64(
    tocarry: List[List[int]],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations(
        tocarry, n, replacement, starts, startsoffset, stops, stopsoffset, length
    )


awkward_listarray64_combinations_64
----------------------------------------------------

def awkward_listarray64_combinations_64(
    tocarry: List[List[int]],
    n: int,
    replacement: bool,
    starts: List[int],
    startsoffset: int,
    stops: List[int],
    stopsoffset: int,
    length: int,
):
    return awkward_listarray_combinations(
        tocarry, n, replacement, starts, startsoffset, stops, stopsoffset, length
    )


awkward_regulararray_combinations
----------------------------------------------------

for C in int:
    for T in int:

        def awkward_regulararray_combinations(
            tocarry: List[List[int]], n: int, replacement: bool, size: int, length: int
        ):
            toindex = []
            fromindex = []
            for j in range(n):
                toindex[j] = 0
            for i in range(length):
                start = size * i
                stop = start + size
                fromindex[0] = start
                awkward_listarray_combinations_step(
                    tocarry, toindex, fromindex, 0, stop, n, replacement
                )
            return


awkward_regulararray_combinations_64
----------------------------------------------------

def awkward_regulararray_combinations_64(
    tocarry: List[List[int]], n: int, replacement: bool, size: int, length: int
):
    return awkward_regulararray_combinations(tocarry, n, replacement, size, length)


awkward_bytemaskedarray_overlay_mask
----------------------------------------------------

for M in int:

    def awkward_bytemaskedarray_overlay_mask(
        tomask: List[M],
        theirmask: List[M],
        theirmaskoffset: int,
        mymask: List[M],
        mymaskoffset: int,
        length: int,
        validwhen: bool,
    ):
        for i in range(length):
            theirs = theirmask[theirmaskoffset + i]
            mine = (mymask[mymaskoffset + i] != 0) != validwhen
            tomask[i] = 1 if theirs | mine else 0
        return


awkward_bytemaskedarray_overlay_mask8
----------------------------------------------------

def awkward_bytemaskedarray_overlay_mask8(
    tomask: List[int],
    theirmask: List[int],
    theirmaskoffset: int,
    mymask: List[int],
    mymaskoffset: int,
    length: int,
    validwhen: bool,
):
    return awkward_bytemaskedarray_overlay_mask(
        tomask, theirmask, theirmaskoffset, mymask, mymaskoffset, length, validwhen
    )


awkward_bitmaskedarray_to_bytemaskedarray
----------------------------------------------------

def awkward_bitmaskedarray_to_bytemaskedarray(
    tobytemask: List[int],
    frombitmask: List[int],
    bitmaskoffset: int,
    bitmasklength: int,
    validwhen: bool,
    lsb_order: int,
):
    if lsb_order:
        for i in range(bitmasklength):
            byte = frombitmask[bitmaskoffset + i]
            tobytemask[(i * 8) + 0] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 1] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 2] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 3] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 4] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 5] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 6] = (byte & int(1)) != validwhen
            byte = 1
            tobytemask[(i * 8) + 7] = (byte & int(1)) != validwhen
    else:
        for i in range(bitmasklength):
            byte = frombitmask[bitmaskoffset + i]
            tobytemask[(i * 8) + 0] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 1] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 2] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 3] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 4] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 5] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 6] = ((byte & int(128)) != 0) != validwhen
            byte = 1
            tobytemask[(i * 8) + 7] = ((byte & int(128)) != 0) != validwhen
    return


awkward_bitmaskedarray_to_indexedoptionarray
----------------------------------------------------

for T in int:

    def awkward_bitmaskedarray_to_indexedoptionarray(
        toindex: List[T],
        frombitmask: List[int],
        bitmaskoffset: int,
        bitmasklength: int,
        validwhen: bool,
        lsb_order: int,
    ):
        if lsb_order:
            for i in range(bitmasklength):
                byte = frombitmask[bitmaskoffset + i]
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 0] = (i * 8) + 0
                else:
                    toindex[(i * 8) + 0] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 1] = (i * 8) + 1
                else:
                    toindex[(i * 8) + 1] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 2] = (i * 8) + 2
                else:
                    toindex[(i * 8) + 2] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 3] = (i * 8) + 3
                else:
                    toindex[(i * 8) + 3] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 4] = (i * 8) + 4
                else:
                    toindex[(i * 8) + 4] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 5] = (i * 8) + 5
                else:
                    toindex[(i * 8) + 5] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 6] = (i * 8) + 6
                else:
                    toindex[(i * 8) + 6] = -1
                byte = 1
                if (byte & int(1)) == validwhen:
                    toindex[(i * 8) + 7] = (i * 8) + 7
                else:
                    toindex[(i * 8) + 7] = -1
        else:
            for i in range(bitmasklength):
                byte = frombitmask[bitmaskoffset + i]
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 0] = (i * 8) + 0
                else:
                    toindex[(i * 8) + 0] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 1] = (i * 8) + 1
                else:
                    toindex[(i * 8) + 1] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 2] = (i * 8) + 2
                else:
                    toindex[(i * 8) + 2] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 3] = (i * 8) + 3
                else:
                    toindex[(i * 8) + 3] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 4] = (i * 8) + 4
                else:
                    toindex[(i * 8) + 4] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 5] = (i * 8) + 5
                else:
                    toindex[(i * 8) + 5] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 6] = (i * 8) + 6
                else:
                    toindex[(i * 8) + 6] = -1
                byte = 1
                if ((byte & int(128)) != 0) == validwhen:
                    toindex[(i * 8) + 7] = (i * 8) + 7
                else:
                    toindex[(i * 8) + 7] = -1
        return


awkward_bitmaskedarray_to_indexedoptionarray_64
----------------------------------------------------

def awkward_bitmaskedarray_to_indexedoptionarray_64(
    toindex: List[int],
    frombitmask: List[int],
    bitmaskoffset: int,
    bitmasklength: int,
    validwhen: bool,
    lsb_order: int,
):
    return awkward_bitmaskedarray_to_indexedoptionarray(
        toindex, frombitmask, bitmaskoffset, bitmasklength, validwhen, lsb_order
    )