Kernel interface and specification — Awkward Array documentation

# Kernel interface and specification

All array manipulation takes place in the lowest layer of the Awkward Array project, the “kernels.” The primary implementation of these kernels are in `libawkward-cpu-kernels.so` (or similar names on MacOS and Windows), which has a pure C interface.

A second implementation, `libawkward-cuda-kernels.so`, is provided as a separate package, `awkward-cuda-kernels`, which handles arrays that reside on GPUs if CUDA is available. It satisfies the same C interface and implements the same behaviors.

The functions are implemented in C with templates for integer specializations (cpu-kernels) and as CUDA (cuda-kernels), but the function signatures and normative definitions are expressed below using a subset of the Python language. These normative definitions are used as a stable and easy-to-read standard that both implementations must reproduce in tests, regardless of how they are optimized.

## awkward_BitMaskedArray_to_ByteMaskedArray

awkward_BitMaskedArray_to_ByteMaskedArray(tobytemask: List[int8_t], frombitmask: Const[List[uint8_t]], bitmasklength: int64_t, validwhen: bool, lsb_order: bool)

    def awkward_BitMaskedArray_to_ByteMaskedArray(
        tobytemask, frombitmask, bitmasklength, validwhen, lsb_order
    ):
        if lsb_order:
            for i in range(bitmasklength):
                byte = frombitmask[i]
                tobytemask[(i * 8) + 0] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 1] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 2] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 3] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 4] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 5] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 6] = (byte & uint8(1)) != validwhen
                byte >>= 1
                tobytemask[(i * 8) + 7] = (byte & uint8(1)) != validwhen
        else:
            for i in range(bitmasklength):
                byte = frombitmask[i]
                tobytemask[(i * 8) + 0] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 1] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 2] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 3] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 4] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 5] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 6] = ((byte & uint8(128)) != 0) != validwhen
                byte <<= 1
                tobytemask[(i * 8) + 7] = ((byte & uint8(128)) != 0) != validwhen

## awkward_BitMaskedArray_to_IndexedOptionArray

awkward_BitMaskedArray_to_IndexedOptionArray64(toindex: List[int64_t], frombitmask: Const[List[uint8_t]], bitmasklength: int64_t, validwhen: bool, lsb_order: bool)

    def awkward_BitMaskedArray_to_IndexedOptionArray(
        toindex, frombitmask, bitmasklength, validwhen, lsb_order
    ):
        if lsb_order:
            for i in range(bitmasklength):
                byte = frombitmask[i]
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 0] = (i * 8) + 0
                else:
                    toindex[(i * 8) + 0] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 1] = (i * 8) + 1
                else:
                    toindex[(i * 8) + 1] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 2] = (i * 8) + 2
                else:
                    toindex[(i * 8) + 2] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 3] = (i * 8) + 3
                else:
                    toindex[(i * 8) + 3] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 4] = (i * 8) + 4
                else:
                    toindex[(i * 8) + 4] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 5] = (i * 8) + 5
                else:
                    toindex[(i * 8) + 5] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 6] = (i * 8) + 6
                else:
                    toindex[(i * 8) + 6] = -1
                byte >>= 1
                if (byte & uint8(1)) == validwhen:
                    toindex[(i * 8) + 7] = (i * 8) + 7
                else:
                    toindex[(i * 8) + 7] = -1
        else:
            for i in range(bitmasklength):
                byte = frombitmask[i]
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 0] = (i * 8) + 0
                else:
                    toindex[(i * 8) + 0] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 1] = (i * 8) + 1
                else:
                    toindex[(i * 8) + 1] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 2] = (i * 8) + 2
                else:
                    toindex[(i * 8) + 2] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 3] = (i * 8) + 3
                else:
                    toindex[(i * 8) + 3] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 4] = (i * 8) + 4
                else:
                    toindex[(i * 8) + 4] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 5] = (i * 8) + 5
                else:
                    toindex[(i * 8) + 5] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 6] = (i * 8) + 6
                else:
                    toindex[(i * 8) + 6] = -1
                byte <<= 1
                if ((byte & uint8(128)) != 0) == validwhen:
                    toindex[(i * 8) + 7] = (i * 8) + 7
                else:
                    toindex[(i * 8) + 7] = -1

## awkward_ByteMaskedArray_getitem_carry

awkward_ByteMaskedArray_getitem_carry_64(tomask: List[int8_t], frommask: Const[List[int8_t]], lenmask: int64_t, fromcarry: Const[List[int64_t]], lencarry: int64_t)

    def awkward_ByteMaskedArray_getitem_carry(
        tomask, frommask, lenmask, fromcarry, lencarry
    ):
        for i in range(lencarry):
            if fromcarry[i] >= lenmask:
                raise ValueError("index out of range")
            tomask[i] = frommask[fromcarry[i]]

## awkward_ByteMaskedArray_getitem_nextcarry

awkward_ByteMaskedArray_getitem_nextcarry_64(tocarry: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_getitem_nextcarry(tocarry, mask, length, validwhen):
        k = 0
        for i in range(length):
            if (mask[i] != 0) == validwhen:
                tocarry[k] = i
                k = k + 1

## awkward_ByteMaskedArray_getitem_nextcarry_outindex

awkward_ByteMaskedArray_getitem_nextcarry_outindex_64(tocarry: List[int64_t], outindex: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_getitem_nextcarry_outindex(
        tocarry, outindex, mask, length, validwhen
    ):
        k = 0
        for i in range(length):
            if (mask[i] != 0) == validwhen:
                tocarry[k] = i
                outindex[i] = float(k)
                k = k + 1
            else:
                outindex[i] = -1

## awkward_ByteMaskedArray_mask

awkward_ByteMaskedArray_mask8(tomask: List[int8_t], frommask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_mask(tomask, frommask, length, validwhen):
        for i in range(length):
            tomask[i] = (frommask[i] != 0) != validwhen

## awkward_ByteMaskedArray_numnull

awkward_ByteMaskedArray_numnull(numnull: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_numnull(numnull, mask, length, validwhen):
        numnull[0] = 0
        for i in range(length):
            if (mask[i] != 0) != validwhen:
                numnull[0] = numnull[0] + 1

## awkward_ByteMaskedArray_overlay_mask

awkward_ByteMaskedArray_overlay_mask8(tomask: List[int8_t], theirmask: Const[List[int8_t]], mymask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_overlay_mask(tomask, theirmask, mymask, length, validwhen):
        for i in range(length):
            theirs = theirmask[i]
            mine = (mymask[i] != 0) != validwhen
            tomask[i] = 1 if theirs | mine else 0

## awkward_ByteMaskedArray_reduce_next_64

awkward_ByteMaskedArray_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], mask: Const[List[int8_t]], parents: Const[List[int64_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_reduce_next_64(
        nextcarry, nextparents, outindex, mask, parents, length, validwhen
    ):
        k = 0
        for i in range(length):
            if (mask[i] != 0) == validwhen:
                nextcarry[k] = i
                nextparents[k] = parents[i]
                outindex[i] = k
                k = k + 1
            else:
                outindex[i] = -1

## awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64

awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], mask: Const[List[int8_t]], length: int64_t, valid_when: bool)

    def awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64(
        nextshifts, mask, length, valid_when
    ):
        nullsum = 0
        k = 0
        for i in range(length):
            if (mask[i] != 0) == (valid_when != 0):
                nextshifts[k] = nullsum
                k = k + 1
            else:
                nullsum = nullsum + 1

## awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64

awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], mask: Const[List[int8_t]], length: int64_t, valid_when: bool, shifts: Const[List[int64_t]])

    def awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(
        nextshifts, mask, length, valid_when, shifts
    ):
        nullsum = 0
        k = 0
        for i in range(length):
            if (mask[i] != 0) == (valid_when != 0):
                nextshifts[k] = shifts[i] + nullsum
                k = k + 1
            else:
                nullsum = nullsum + 1

## awkward_ByteMaskedArray_toIndexedOptionArray

awkward_ByteMaskedArray_toIndexedOptionArray64(toindex: List[int64_t], mask: Const[List[int8_t]], length: int64_t, validwhen: bool)

    def awkward_ByteMaskedArray_toIndexedOptionArray(toindex, mask, length, validwhen):
        for i in range(length):
            toindex[i] = i if (mask[i] != 0) == validwhen else -1

## awkward_Content_getitem_next_missing_jagged_getmaskstartstop

awkward_Content_getitem_next_missing_jagged_getmaskstartstop(index_in: List[int64_t], offsets_in: List[int64_t], mask_out: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)

    def awkward_Content_getitem_next_missing_jagged_getmaskstartstop(
        index_in, offsets_in, mask_out, starts_out, stops_out, length
    ):
        k = 0
        for i in range(length):
            starts_out[i] = offsets_in[k]
            if index_in[i] < 0:
                mask_out[i] = -1
                stops_out[i] = offsets_in[k]
            else:
                mask_out[i] = i
                k = k + 1
                stops_out[i] = offsets_in[k]

## awkward_Identities32_to_Identities64

awkward_Identities32_to_Identities64(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, width: int64_t)

    def awkward_Identities32_to_Identities64(toptr, fromptr, length, width):
        for i in range(length * width):
            toptr[i] = int(fromptr[i])

## awkward_Identities_extend

awkward_Identities32_extend(toptr: List[int32_t], fromptr: Const[List[int32_t]], fromlength: int64_t, tolength: int64_t)

awkward_Identities64_extend(toptr: List[int64_t], fromptr: Const[List[int64_t]], fromlength: int64_t, tolength: int64_t)

    def awkward_Identities_extend(toptr, fromptr, fromlength, tolength):
        i = 0
        while i < fromlength:
            toptr[i] = fromptr[i]
            i = i + 1
        while i < tolength:
            toptr[i] = -1
            i = i + 1

## awkward_Identities_from_IndexedArray

awkward_Identities32_from_IndexedArray32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromindex: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_IndexedArray64(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromindex: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_IndexedArrayU32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromindex: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_IndexedArray32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromindex: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_IndexedArray64(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromindex: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_IndexedArrayU32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromindex: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

    def awkward_Identities_from_IndexedArray(
        uniquecontents, toptr, fromptr, fromindex, tolength, fromlength, fromwidth
    ):
        for k in range(tolength * fromwidth):
            toptr[k] = -1
        for i in range(fromlength):
            j = fromindex[i]
            if j >= tolength:
                raise ValueError("max(index) > len(content)")
            else:
                if j >= 0:
                    if toptr[j * fromwidth] != -1:
                        uniquecontents[0] = False
                        return
                    for k in range(fromwidth):
                        toptr[(j * fromwidth) + k] = fromptr[(i * fromwidth) + k]
        uniquecontents[0] = True

## awkward_Identities_from_ListArray

awkward_Identities32_from_ListArray32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_ListArray64(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_ListArrayU32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListArray32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListArray64(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListArrayU32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

    def awkward_Identities_from_ListArray(
        uniquecontents,
        toptr,
        fromptr,
        fromstarts,
        fromstops,
        tolength,
        fromlength,
        fromwidth,
    ):
        for k in range(tolength * (fromwidth + 1)):
            toptr[k] = -1
        for i in range(fromlength):
            start = fromstarts[i]
            stop = fromstops[i]
            if (start != stop) and (stop > tolength):
                raise ValueError("max(stop) > len(content)")
            for j in range(start, stop):
                if toptr[(j * (fromwidth + 1)) + fromwidth] != -1:
                    uniquecontents[0] = False
                    return
                for k in range(fromwidth):
                    toptr[(j * (fromwidth + 1)) + k] = fromptr[(i * fromwidth) + k]
                toptr[(j * (fromwidth + 1)) + fromwidth] = float(j - start)
        uniquecontents[0] = True

## awkward_Identities_from_ListOffsetArray

awkward_Identities32_from_ListOffsetArray32(toptr: List[int32_t], fromptr: Const[List[int32_t]], fromoffsets: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_ListOffsetArray64(toptr: List[int32_t], fromptr: Const[List[int32_t]], fromoffsets: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities32_from_ListOffsetArrayU32(toptr: List[int32_t], fromptr: Const[List[int32_t]], fromoffsets: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListOffsetArray32(toptr: List[int64_t], fromptr: Const[List[int64_t]], fromoffsets: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListOffsetArray64(toptr: List[int64_t], fromptr: Const[List[int64_t]], fromoffsets: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_ListOffsetArrayU32(toptr: List[int64_t], fromptr: Const[List[int64_t]], fromoffsets: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

    def awkward_Identities_from_ListOffsetArray(
        toptr, fromptr, fromoffsets, tolength, fromlength, fromwidth
    ):
        globalstart = fromoffsets[0]
        globalstop = fromoffsets[fromlength]
        for k in range(globalstart * (fromwidth + 1)):
            toptr[k] = -1
        k = globalstop * (fromwidth + 1)
        while k < (tolength * (fromwidth + 1)):
            toptr[k] = -1
            k = k + 1
        for i in range(fromlength):
            start = fromoffsets[i]
            stop = fromoffsets[i + 1]
            if (start != stop) and (stop > tolength):
                raise ValueError("max(stop) > len(content)")
            for j in range(start, stop):
                for k in range(fromwidth):
                    toptr[(j * (fromwidth + 1)) + k] = fromptr[(i * fromwidth) + k]
                toptr[(j * (fromwidth + 1)) + fromwidth] = float(j - start)

## awkward_Identities_from_RegularArray

awkward_Identities32_from_RegularArray(toptr: List[int32_t], fromptr: Const[List[int32_t]], size: int64_t, tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

awkward_Identities64_from_RegularArray(toptr: List[int64_t], fromptr: Const[List[int64_t]], size: int64_t, tolength: int64_t, fromlength: int64_t, fromwidth: int64_t)

    def awkward_Identities_from_RegularArray(
        toptr, fromptr, size, tolength, fromlength, fromwidth
    ):
        for i in range(fromlength):
            for j in range(size):
                for k in range(fromwidth):
                    toptr[(((i * size) + j) * (fromwidth + 1)) + k] = fromptr[
                        (i * fromwidth) + k
                    ]
                toptr[(((i * size) + j) * (fromwidth + 1)) + fromwidth] = float(j)
        k = ((fromlength + 1) * size) * (fromwidth + 1)
        while k < (tolength * (fromwidth + 1)):
            toptr[k] = -1
            k = k + 1

## awkward_Identities_from_UnionArray

awkward_Identities32_from_UnionArray8_32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

awkward_Identities32_from_UnionArray8_64(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

awkward_Identities32_from_UnionArray8_U32(uniquecontents: List[bool], toptr: List[int32_t], fromptr: Const[List[int32_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

awkward_Identities64_from_UnionArray8_32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

awkward_Identities64_from_UnionArray8_64(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

awkward_Identities64_from_UnionArray8_U32(uniquecontents: List[bool], toptr: List[int64_t], fromptr: Const[List[int64_t]], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], tolength: int64_t, fromlength: int64_t, fromwidth: int64_t, which: int64_t)

    def awkward_Identities_from_UnionArray(
        uniquecontents,
        toptr,
        fromptr,
        fromtags,
        fromindex,
        tolength,
        fromlength,
        fromwidth,
        which,
    ):
        for k in range(tolength * fromwidth):
            toptr[k] = -1
        for i in range(fromlength):
            if fromtags[i] == which:
                j = fromindex[i]
                if j >= tolength:
                    raise ValueError("max(index) > len(content)")
                else:
                    if j < 0:
                        raise ValueError("min(index) < 0")
                    else:
                        if toptr[j * fromwidth] != -1:
                            uniquecontents[0] = False
                            return
                        for k in range(fromwidth):
                            toptr[(j * fromwidth) + k] = fromptr[(i * fromwidth) + k]
        uniquecontents[0] = True

## awkward_Identities_getitem_carry

awkward_Identities32_getitem_carry_64(newidentitiesptr: List[int32_t], identitiesptr: Const[List[int32_t]], carryptr: Const[List[int64_t]], lencarry: int64_t, width: int64_t, length: int64_t)

awkward_Identities64_getitem_carry_64(newidentitiesptr: List[int64_t], identitiesptr: Const[List[int64_t]], carryptr: Const[List[int64_t]], lencarry: int64_t, width: int64_t, length: int64_t)

    def awkward_Identities_getitem_carry(
        newidentitiesptr, identitiesptr, carryptr, lencarry, width, length
    ):
        for i in range(lencarry):
            if carryptr[i] >= length:
                raise ValueError("index out of range")
            for j in range(width):
                newidentitiesptr[(width * i) + j] = identitiesptr[(width * carryptr[i]) + j]

## awkward_Index_iscontiguous

awkward_Index32_iscontiguous(result: List[bool], fromindex: Const[List[int32_t]], length: int64_t)

awkward_Index64_iscontiguous(result: List[bool], fromindex: Const[List[int64_t]], length: int64_t)

awkward_Index8_iscontiguous(result: List[bool], fromindex: Const[List[int8_t]], length: int64_t)

awkward_IndexU32_iscontiguous(result: List[bool], fromindex: Const[List[uint32_t]], length: int64_t)

awkward_IndexU8_iscontiguous(result: List[bool], fromindex: Const[List[uint8_t]], length: int64_t)

    def awkward_Index_iscontiguous(result, fromindex, length):
        result[0] = True
        expecting = 0
        for i in range(length):
            if fromindex[i] != expecting:
                result[0] = False
                return
            expecting += 1

## awkward_Index_to_Index64

awkward_Index32_to_Index64(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t)

awkward_Index8_to_Index64(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t)

awkward_IndexU32_to_Index64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t)

awkward_IndexU8_to_Index64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t)

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

## awkward_IndexedArray_fill

awkward_IndexedArray_fill_to64_from32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int32_t]], length: int64_t, base: int64_t)

awkward_IndexedArray_fill_to64_from64(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int64_t]], length: int64_t, base: int64_t)

awkward_IndexedArray_fill_to64_fromU32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[uint32_t]], length: int64_t, base: int64_t)

    def awkward_IndexedArray_fill(toindex, toindexoffset, fromindex, length, base):
        for i in range(length):
            fromval = fromindex[i]
            toindex[toindexoffset + i] = -1 if fromval < 0 else float(fromval + base)

## awkward_IndexedArray_fill_count

awkward_IndexedArray_fill_to64_count(toindex: List[int64_t], toindexoffset: int64_t, length: int64_t, base: int64_t)

    def awkward_IndexedArray_fill_count(toindex, toindexoffset, length, base):
        for i in range(length):
            toindex[toindexoffset + i] = i + base

## awkward_IndexedArray_flatten_nextcarry

awkward_IndexedArray32_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArray64_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArrayU32_flatten_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)

    def awkward_IndexedArray_flatten_nextcarry(tocarry, fromindex, lenindex, lencontent):
        k = 0
        for i in range(lenindex):
            j = fromindex[i]
            if j >= lencontent:
                raise ValueError("index out of range")
            else:
                if j >= 0:
                    tocarry[k] = j
                    k = k + 1

## awkward_IndexedArray_flatten_none2empty

awkward_IndexedArray32_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[int32_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)

awkward_IndexedArray64_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[int64_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)

awkward_IndexedArrayU32_flatten_none2empty_64(outoffsets: List[int64_t], outindex: Const[List[uint32_t]], outindexlength: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t)

    def awkward_IndexedArray_flatten_none2empty(
        outoffsets, outindex, outindexlength, offsets, offsetslength
    ):
        outoffsets[0] = offsets[0]
        k = 1
        for i in range(outindexlength):
            idx = outindex[i]
            if idx < 0:
                outoffsets[k] = outoffsets[k - 1]
                k = k + 1
            else:
                if (idx + 1) >= offsetslength:
                    raise ValueError("flattening offset out of range")
                else:
                    count = offsets[idx + 1] - offsets[idx]
                    outoffsets[k] = outoffsets[k - 1] + count
                    k = k + 1

## awkward_IndexedArray_getitem_adjust_outindex

awkward_IndexedArray_getitem_adjust_outindex_64(tomask: List[int8_t], toindex: List[int64_t], tononzero: List[int64_t], fromindex: Const[List[int64_t]], fromindexlength: int64_t, nonzero: Const[List[int64_t]], nonzerolength: int64_t)

    def awkward_IndexedArray_getitem_adjust_outindex(
        tomask, toindex, tononzero, fromindex, fromindexlength, nonzero, nonzerolength
    ):
        j = 0
        k = 0
        for i in range(fromindexlength):
            fromval = fromindex[i]
            tomask[i] = fromval < 0
            if fromval < 0:
                toindex[k] = -1
                k = k + 1
            else:
                if (j < nonzerolength) and (fromval == nonzero[j]):
                    tononzero[j] = fromval + (k - j)
                    toindex[k] = j
                    j = j + 1
                    k = k + 1

## awkward_IndexedArray_getitem_carry

awkward_IndexedArray32_getitem_carry_64(toindex: List[int32_t], fromindex: Const[List[int32_t]], fromcarry: Const[List[int64_t]], lenindex: int64_t, lencarry: int64_t)

awkward_IndexedArray64_getitem_carry_64(toindex: List[int64_t], fromindex: Const[List[int64_t]], fromcarry: Const[List[int64_t]], lenindex: int64_t, lencarry: int64_t)

awkward_IndexedArrayU32_getitem_carry_64(toindex: List[uint32_t], fromindex: Const[List[uint32_t]], fromcarry: Const[List[int64_t]], lenindex: int64_t, lencarry: int64_t)

    def awkward_IndexedArray_getitem_carry(
        toindex, fromindex, fromcarry, lenindex, lencarry
    ):
        for i in range(lencarry):
            if fromcarry[i] >= lenindex:
                raise ValueError("index out of range")
            toindex[i] = float(fromindex[fromcarry[i]])

## awkward_IndexedArray_getitem_nextcarry

awkward_IndexedArray32_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArray64_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArrayU32_getitem_nextcarry_64(tocarry: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)

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

## awkward_IndexedArray_getitem_nextcarry_outindex

awkward_IndexedArray32_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[int32_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArray64_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArrayU32_getitem_nextcarry_outindex_64(tocarry: List[int64_t], toindex: List[uint32_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)

    def awkward_IndexedArray_getitem_nextcarry_outindex(
        tocarry, toindex, fromindex, lenindex, lencontent
    ):
        k = 0
        for i in range(lenindex):
            j = fromindex[i]
            if j >= lencontent:
                raise ValueError("index out of range")
            else:
                if j < 0:
                    toindex[i] = -1
                else:
                    tocarry[k] = j
                    toindex[i] = float(k)
                    k = k + 1

## awkward_IndexedArray_getitem_nextcarry_outindex_mask

awkward_IndexedArray32_getitem_nextcarry_outindex_mask_64(tocarry: List[int64_t], toindex: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArray64_getitem_nextcarry_outindex_mask_64(tocarry: List[int64_t], toindex: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, lencontent: int64_t)

awkward_IndexedArrayU32_getitem_nextcarry_outindex_mask_64(tocarry: List[int64_t], toindex: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, lencontent: int64_t)

    def awkward_IndexedArray_getitem_nextcarry_outindex_mask(
        tocarry, toindex, fromindex, lenindex, lencontent
    ):
        k = 0
        for i in range(lenindex):
            j = fromindex[i]
            if j >= lencontent:
                raise ValueError("index out of range")
            else:
                if j < 0:
                    toindex[i] = -1
                else:
                    tocarry[k] = j
                    toindex[i] = float(k)
                    k = k + 1

## awkward_IndexedArray_local_preparenext_64

awkward_IndexedArray_local_preparenext_64(tocarry: List[int64_t], starts: Const[List[int64_t]], parents: Const[List[int64_t]], parentslength: Const[int64_t], nextparents: Const[List[int64_t]], nextlen: Const[int64_t])

    Insert Python definition here

## awkward_IndexedArray_mask

awkward_IndexedArray32_mask8(tomask: List[int8_t], fromindex: Const[List[int32_t]], length: int64_t)

awkward_IndexedArray64_mask8(tomask: List[int8_t], fromindex: Const[List[int64_t]], length: int64_t)

awkward_IndexedArrayU32_mask8(tomask: List[int8_t], fromindex: Const[List[uint32_t]], length: int64_t)

    def awkward_IndexedArray_mask(tomask, fromindex, length):
        for i in range(length):
            tomask[i] = fromindex[i] < 0

## awkward_IndexedArray_numnull

awkward_IndexedArray32_numnull(numnull: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t)

awkward_IndexedArray64_numnull(numnull: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t)

awkward_IndexedArrayU32_numnull(numnull: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t)

    def awkward_IndexedArray_numnull(numnull, fromindex, lenindex):
        numnull[0] = 0
        for i in range(lenindex):
            if fromindex[i] < 0:
                numnull[0] = numnull[0] + 1

## awkward_IndexedArray_numnull_parents

awkward_IndexedArray32_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t)

awkward_IndexedArray64_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t)

awkward_IndexedArrayU32_numnull_parents(numnull: List[int64_t], tolength: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t)

    def awkward_IndexedArray_numnull_parents(numnull, tolength, fromindex, lenindex):
        tolength[0] = 0
        for i in range(lenindex):
            if fromindex[i] < 0:
                numnull[i] = 1
                tolength[0] = tolength[0] + 1
            else:
                numnull[i] = 0

## awkward_IndexedArray_numnull_unique_64

awkward_IndexedArray_numnull_unique_64(toindex: List[int64_t], lenindex: int64_t)

    def awkward_IndexedArray_numnull_unique_64(toindex, lenindex):
        for i in range(lenindex):
            toindex[i] = i
        toindex[-1] = -1

## awkward_IndexedArray_index_of_nulls

awkward_IndexedArray32_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[int32_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])

awkward_IndexedArray64_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[int64_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])

awkward_IndexedArrayU32_index_of_nulls(toindex: List[int64_t], fromindex: Const[List[uint32_t]], lenindex: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])

    def awkward_IndexedArray_index_of_nulls(toindex, fromindex, lenindex, parents, starts):
        j = 0
        for i in range(lenindex):
            if fromindex[i] < 0:
                parent = parents[i]
                start = starts[parent]
                toindex[j] = i - start
                j = j + 1

## awkward_IndexedArray_overlay_mask

awkward_IndexedArray32_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t)

awkward_IndexedArray64_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t)

awkward_IndexedArrayU32_overlay_mask8_to64(toindex: List[int64_t], mask: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t)

    def awkward_IndexedArray_overlay_mask(toindex, mask, fromindex, length):
        for i in range(length):
            m = mask[i]
            toindex[i] = -1 if m else fromindex[i]

## awkward_IndexedArray_reduce_next_64

awkward_IndexedArray32_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[int32_t]], parents: List[int64_t], length: int64_t)

awkward_IndexedArray64_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[int64_t]], parents: List[int64_t], length: int64_t)

awkward_IndexedArrayU32_reduce_next_64(nextcarry: List[int64_t], nextparents: List[int64_t], outindex: List[int64_t], index: Const[List[uint32_t]], parents: List[int64_t], length: int64_t)

    def awkward_IndexedArray_reduce_next_64(
        nextcarry, nextparents, outindex, index, parents, length
    ):
        k = 0
        for i in range(length):
            if index[i] >= 0:
                nextcarry[k] = index[i]
                nextparents[k] = parents[i]
                outindex[i] = k
                k = k + 1
            else:
                outindex[i] = -1

## awkward_IndexedArray_reduce_next_fix_offsets_64

awkward_IndexedArray_reduce_next_fix_offsets_64(outoffsets: List[int64_t], starts: Const[List[int64_t]], startslength: int64_t, outindexlength: int64_t)

    def awkward_IndexedArray_reduce_next_fix_offsets_64(
        outoffsets, starts, startslength, outindexlength
    ):
        for i in range(startslength):
            outoffsets[i] = starts[i]
        outoffsets[startslength] = outindexlength

## awkward_IndexedArray_unique_next_index_and_offsets_64

awkward_IndexedArray_unique_next_index_and_offsets_64(toindex: List[int64_t], tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], fromnulls: Const[List[int64_t]], startslength: int64_t)

    def awkward_IndexedArray_unique_next_index_and_offsets_64(
        toindex, tooffsets, fromoffsets, fromnulls, startslength
    ):
        k = 0
        ll = 0
        shift = 0
        toindex[0] = ll
        tooffsets[0] = fromoffsets[0]
        for i in range(startslength):
            for _j in range(fromoffsets[i], fromoffsets[i + 1]):
                toindex[k] = ll
                k += 1
                ll += 1
                if fromnulls[k] == 1:
                    toindex[k] = -1
                    k += 1
                    shift += 1
                tooffsets[i + 1] = fromoffsets[i + 1] + shift

## awkward_IndexedArray_reduce_next_nonlocal_nextshifts_64

awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[int32_t]], length: int64_t)

awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[int64_t]], length: int64_t)

awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_64(nextshifts: List[int64_t], index: Const[List[uint32_t]], length: int64_t)

    def awkward_IndexedArray_reduce_next_nonlocal_nextshifts_64(nextshifts, index, length):
        nullsum = 0
        k = 0
        for i in range(length):
            if index[i] >= 0:
                nextshifts[k] = nullsum
                k = k + 1
            else:
                nullsum = nullsum + 1

## awkward_IndexedArray_reduce_next_nonlocal_nextshifts_fromshifts_64

awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[int32_t]], length: int64_t, shifts: Const[List[int64_t]])

awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[int64_t]], length: int64_t, shifts: Const[List[int64_t]])

awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_fromshifts_64(nextshifts: List[int64_t], index: Const[List[uint32_t]], length: int64_t, shifts: Const[List[int64_t]])

    def awkward_IndexedArray_reduce_next_nonlocal_nextshifts_fromshifts_64(
        nextshifts, index, length, shifts
    ):
        nullsum = 0
        k = 0
        for i in range(length):
            if index[i] >= 0:
                nextshifts[k] = shifts[i] + nullsum
                k = k + 1
            else:
                nullsum = nullsum + 1

## awkward_IndexedArray_simplify

awkward_IndexedArray32_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)

awkward_IndexedArray32_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)

awkward_IndexedArray32_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[int32_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)

awkward_IndexedArray64_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)

awkward_IndexedArray64_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)

awkward_IndexedArray64_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[int64_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)

awkward_IndexedArrayU32_simplify32_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[int32_t]], innerlength: int64_t)

awkward_IndexedArrayU32_simplify64_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[int64_t]], innerlength: int64_t)

awkward_IndexedArrayU32_simplifyU32_to64(toindex: List[int64_t], outerindex: Const[List[uint32_t]], outerlength: int64_t, innerindex: Const[List[uint32_t]], innerlength: int64_t)

    def awkward_IndexedArray_simplify(
        toindex, outerindex, outerlength, innerindex, innerlength
    ):
        for i in range(outerlength):
            j = outerindex[i]
            if j < 0:
                toindex[i] = -1
            else:
                if j >= innerlength:
                    raise ValueError("index out of range")
                else:
                    toindex[i] = innerindex[j]

## awkward_IndexedArray_validity

awkward_IndexedArray32_validity(index: Const[List[int32_t]], length: int64_t, lencontent: int64_t, isoption: bool)

awkward_IndexedArray64_validity(index: Const[List[int64_t]], length: int64_t, lencontent: int64_t, isoption: bool)

awkward_IndexedArrayU32_validity(index: Const[List[uint32_t]], length: int64_t, lencontent: int64_t, isoption: bool)

    def awkward_IndexedArray_validity(index, length, lencontent, isoption):
        for i in range(length):
            idx = index[i]
            if not (isoption):
                if idx < 0:
                    raise ValueError("index[i] < 0")
            if idx >= lencontent:
                raise ValueError("index[i] >= len(content)")

## awkward_IndexedArray_ranges_next_64

awkward_IndexedArray32_ranges_next_64(index: Const[List[int32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])

awkward_IndexedArray64_ranges_next_64(index: Const[List[int64_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])

awkward_IndexedArrayU32_ranges_next_64(index: Const[List[uint32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tostarts: List[int64_t], tostops: List[int64_t], tolength: List[int64_t])

    def awkward_IndexedArray_ranges_next_64(
        index, fromstarts, fromstops, length, tostarts, tostops, tolength
    ):
        k = 0
        for i in range(length):
            stride = fromstops[i] - fromstarts[i]
            tostarts[i] = k
            for j in range(stride):
                if index[fromstarts[i] + j] > 0:
                    k = k + 1
            tostops[i] = k
        tolength = k

## awkward_IndexedArray_ranges_carry_next_64

awkward_IndexedArray32_ranges_carry_next_64(index: Const[List[int32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])

awkward_IndexedArray64_ranges_carry_next_64(index: Const[List[int64_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])

awkward_IndexedArrayU32_ranges_carry_next_64(index: Const[List[uint32_t]], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, tocarry: List[int64_t])

    def awkward_IndexedArray_ranges_carry_next_64(
        index, fromstarts, fromstops, length, tocarry
    ):
        k = 0
        for i in range(length):
            stride = fromstops[i] - fromstarts[i]
            for j in range(stride):
                if index[fromstarts[i] + j] > 0:
                    tocarry[k] = index[fromstarts[i] + j]
                    k = k + 1

## awkward_IndexedOptionArray_rpad_and_clip_mask_axis1

awkward_IndexedOptionArray_rpad_and_clip_mask_axis1_64(toindex: List[int64_t], frommask: Const[List[int8_t]], length: int64_t)

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

## awkward_ListArray_broadcast_tooffsets

awkward_ListArray32_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lencontent: int64_t)

awkward_ListArray64_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lencontent: int64_t)

awkward_ListArrayU32_broadcast_tooffsets_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lencontent: int64_t)

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

## awkward_ListArray_combinations

awkward_ListArray32_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t)

awkward_ListArray64_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t)

awkward_ListArrayU32_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t)

    Insert Python definition here

## awkward_ListArray_combinations_length

awkward_ListArray32_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t)

awkward_ListArray64_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t)

awkward_ListArrayU32_combinations_length_64(totallen: List[int64_t], tooffsets: List[int64_t], n: int64_t, replacement: bool, starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t)

    def awkward_ListArray_combinations_length(
        totallen, tooffsets, n, replacement, starts, stops, length
    ):
        totallen[0] = 0
        tooffsets[0] = 0
        for i in range(length):
            size = int(stops[i] - starts[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[0] = totallen[0] + combinationslen
            tooffsets[i + 1] = tooffsets[i] + combinationslen

## awkward_ListArray_compact_offsets

awkward_ListArray32_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], length: int64_t)

awkward_ListArray64_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t)

awkward_ListArrayU32_compact_offsets_64(tooffsets: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], length: int64_t)

    def awkward_ListArray_compact_offsets(tooffsets, fromstarts, fromstops, length):
        tooffsets[0] = 0
        for i in range(length):
            start = fromstarts[i]
            stop = fromstops[i]
            if stop < start:
                raise ValueError("stops[i] < starts[i]")
            tooffsets[i + 1] = tooffsets[i] + (stop - start)

## awkward_ListArray_fill

awkward_ListArray_fill_to64_from32(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], length: int64_t, base: int64_t)

awkward_ListArray_fill_to64_from64(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, base: int64_t)

awkward_ListArray_fill_to64_fromU32(tostarts: List[int64_t], tostartsoffset: int64_t, tostops: List[int64_t], tostopsoffset: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], length: int64_t, base: int64_t)

    def awkward_ListArray_fill(
        tostarts,
        tostartsoffset,
        tostops,
        tostopsoffset,
        fromstarts,
        fromstops,
        length,
        base,
    ):
        for i in range(length):
            tostarts[tostartsoffset + i] = float(fromstarts[i] + base)
            tostops[tostopsoffset + i] = float(fromstops[i] + base)

## awkward_ListArray_getitem_carry

awkward_ListArray32_getitem_carry_64(tostarts: List[int32_t], tostops: List[int32_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], fromcarry: Const[List[int64_t]], lenstarts: int64_t, lencarry: int64_t)

awkward_ListArray64_getitem_carry_64(tostarts: List[int64_t], tostops: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], fromcarry: Const[List[int64_t]], lenstarts: int64_t, lencarry: int64_t)

awkward_ListArrayU32_getitem_carry_64(tostarts: List[uint32_t], tostops: List[uint32_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], fromcarry: Const[List[int64_t]], lenstarts: int64_t, lencarry: int64_t)

    def awkward_ListArray_getitem_carry(
        tostarts, tostops, fromstarts, fromstops, fromcarry, lenstarts, lencarry
    ):
        for i in range(lencarry):
            if fromcarry[i] >= lenstarts:
                raise ValueError("index out of range")
            tostarts[i] = float(fromstarts[fromcarry[i]])
            tostops[i] = float(fromstops[fromcarry[i]])

## awkward_ListArray_getitem_jagged_apply

awkward_ListArray32_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], contentlen: int64_t)

awkward_ListArray64_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], contentlen: int64_t)

awkward_ListArrayU32_getitem_jagged_apply_64(tooffsets: List[int64_t], tocarry: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, sliceindex: Const[List[int64_t]], sliceinnerlen: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], contentlen: int64_t)

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

## awkward_ListArray_getitem_jagged_carrylen

awkward_ListArray_getitem_jagged_carrylen_64(carrylen: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t)

    def awkward_ListArray_getitem_jagged_carrylen(
        carrylen, slicestarts, slicestops, sliceouterlen
    ):
        carrylen[0] = 0
        for i in range(sliceouterlen):
            carrylen[0] = carrylen[0] + int(slicestops[i] - slicestarts[i])

## awkward_ListArray_getitem_jagged_descend

awkward_ListArray32_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]])

awkward_ListArray64_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]])

awkward_ListArrayU32_getitem_jagged_descend_64(tooffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], sliceouterlen: int64_t, fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]])

    def awkward_ListArray_getitem_jagged_descend(
        tooffsets, slicestarts, slicestops, sliceouterlen, fromstarts, fromstops
    ):
        if sliceouterlen == 0:
            tooffsets[0] = 0
        else:
            tooffsets[0] = slicestarts[0]
        for i in range(sliceouterlen):
            slicecount = int(slicestops[i] - slicestarts[i])
            count = int(fromstops[i] - fromstarts[i])
            if slicecount != count:
                raise ValueError(
                    "jagged slice inner length differs from array inner length"
                )
            tooffsets[i + 1] = tooffsets[i] + float(count)

## awkward_ListArray_getitem_jagged_expand

awkward_ListArray32_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], jaggedsize: int64_t, length: int64_t)

awkward_ListArray64_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], jaggedsize: int64_t, length: int64_t)

awkward_ListArrayU32_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], jaggedsize: int64_t, length: int64_t)

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

## awkward_ListArray_getitem_jagged_numvalid

awkward_ListArray_getitem_jagged_numvalid_64(numvalid: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], length: int64_t, missing: Const[List[int64_t]], missinglength: int64_t)

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

## awkward_ListArray_getitem_jagged_shrink

awkward_ListArray_getitem_jagged_shrink_64(tocarry: List[int64_t], tosmalloffsets: List[int64_t], tolargeoffsets: List[int64_t], slicestarts: Const[List[int64_t]], slicestops: Const[List[int64_t]], length: int64_t, missing: Const[List[int64_t]])

    def awkward_ListArray_getitem_jagged_shrink(
        tocarry, tosmalloffsets, tolargeoffsets, slicestarts, slicestops, length, missing
    ):
        k = 0
        if length == 0:
            tosmalloffsets[0] = 0
            tolargeoffsets[0] = 0
        else:
            tosmalloffsets[0] = slicestarts[0]
            tolargeoffsets[0] = slicestarts[0]
        for i in range(length):
            slicestart = slicestarts[i]
            slicestop = slicestops[i]
            if slicestart != slicestop:
                smallcount = 0
                for j in range(slicestart, slicestop):
                    if missing[j] >= 0:
                        tocarry[k] = j
                        k = k + 1
                        smallcount = smallcount + 1
                tosmalloffsets[i + 1] = tosmalloffsets[i] + smallcount
            else:
                tosmalloffsets[i + 1] = tosmalloffsets[i]
            tolargeoffsets[i + 1] = tolargeoffsets[i] + (slicestop - slicestart)

## awkward_ListArray_getitem_next_array

awkward_ListArray32_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

awkward_ListArray64_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

awkward_ListArrayU32_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], fromarray: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

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

## awkward_ListArray_getitem_next_array_advanced

awkward_ListArray32_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

awkward_ListArray64_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

awkward_ListArrayU32_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], fromarray: Const[List[int64_t]], fromadvanced: Const[List[int64_t]], lenstarts: int64_t, lenarray: int64_t, lencontent: int64_t)

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

## awkward_ListArray_getitem_next_at

awkward_ListArray32_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, at: int64_t)

awkward_ListArray64_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, at: int64_t)

awkward_ListArrayU32_getitem_next_at_64(tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, at: int64_t)

    def awkward_ListArray_getitem_next_at(tocarry, fromstarts, fromstops, lenstarts, at):
        for i in range(lenstarts):
            length = fromstops[i] - fromstarts[i]
            regular_at = at
            if regular_at < 0:
                regular_at += length
            if not ((0 <= regular_at) and (regular_at < length)):
                raise ValueError("index out of range")
            tocarry[i] = fromstarts[i] + regular_at

## awkward_ListArray_getitem_next_range

awkward_ListArray32_getitem_next_range_64(tooffsets: List[int32_t], tocarry: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

awkward_ListArray64_getitem_next_range_64(tooffsets: List[int64_t], tocarry: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

awkward_ListArrayU32_getitem_next_range_64(tooffsets: List[uint32_t], tocarry: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

    def awkward_ListArray_getitem_next_range(
        tooffsets, tocarry, fromstarts, fromstops, lenstarts, start, stop, step
    ):
        k = 0
        tooffsets[0] = 0
        if step > 0:
            for i in range(lenstarts):
                length = fromstops[i] - fromstarts[i]
                regular_start = start
                regular_stop = stop
                awkward_regularize_rangeslice(
                    regular_start,
                    regular_stop,
                    step > 0,
                    start != kSliceNone,
                    stop != kSliceNone,
                    length,
                )
                j = regular_start
                while j < regular_stop:
                    tocarry[k] = fromstarts[i] + j
                    k = k + 1
                    j += step
                tooffsets[i + 1] = float(k)
        else:
            for i in range(lenstarts):
                length = fromstops[i] - fromstarts[i]
                regular_start = start
                regular_stop = stop
                awkward_regularize_rangeslice(
                    regular_start,
                    regular_stop,
                    step > 0,
                    start != kSliceNone,
                    stop != kSliceNone,
                    length,
                )
                j = regular_start
                while j > regular_stop:
                    tocarry[k] = fromstarts[i] + j
                    k = k + 1
                    j += step
                tooffsets[i + 1] = float(k)

## awkward_ListArray_getitem_next_range_carrylength

awkward_ListArray32_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

awkward_ListArray64_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

awkward_ListArrayU32_getitem_next_range_carrylength(carrylength: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t, start: int64_t, stop: int64_t, step: int64_t)

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

## awkward_ListArray_getitem_next_range_counts

awkward_ListArray32_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[int32_t]], lenstarts: int64_t)

awkward_ListArray64_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[int64_t]], lenstarts: int64_t)

awkward_ListArrayU32_getitem_next_range_counts_64(total: List[int64_t], fromoffsets: Const[List[uint32_t]], lenstarts: int64_t)

    def awkward_ListArray_getitem_next_range_counts(total, fromoffsets, lenstarts):
        total[0] = 0
        for i in range(lenstarts):
            total[0] = (total[0] + fromoffsets[i + 1]) - fromoffsets[i]

## awkward_ListArray_getitem_next_range_spreadadvanced

awkward_ListArray32_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[int32_t]], lenstarts: int64_t)

awkward_ListArray64_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[int64_t]], lenstarts: int64_t)

awkward_ListArrayU32_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromoffsets: Const[List[uint32_t]], lenstarts: int64_t)

    def awkward_ListArray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, fromoffsets, lenstarts
    ):
        for i in range(lenstarts):
            count = fromoffsets[i + 1] - fromoffsets[i]
            for j in range(count):
                toadvanced[fromoffsets[i] + j] = fromadvanced[i]

## awkward_ListArray_localindex

awkward_ListArray32_localindex_64(toindex: List[int64_t], offsets: Const[List[int32_t]], length: int64_t)

awkward_ListArray64_localindex_64(toindex: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)

awkward_ListArrayU32_localindex_64(toindex: List[int64_t], offsets: Const[List[uint32_t]], length: int64_t)

    def awkward_ListArray_localindex(toindex, offsets, length):
        for i in range(length):
            start = int(offsets[i])
            stop = int(offsets[i + 1])
            for j in range(start, stop):
                toindex[j] = j - start

## awkward_ListArray_min_range

awkward_ListArray32_min_range(tomin: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], lenstarts: int64_t)

awkward_ListArray64_min_range(tomin: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], lenstarts: int64_t)

awkward_ListArrayU32_min_range(tomin: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], lenstarts: int64_t)

    def awkward_ListArray_min_range(tomin, fromstarts, fromstops, lenstarts):
        shorter = fromstops[0] - fromstarts[0]
        for i in range(1, lenstarts):
            rangeval = fromstops[i] - fromstarts[i]
            shorter = shorter if shorter < rangeval else rangeval
        tomin[0] = shorter

## awkward_ListArray_num

awkward_ListArray32_num_64(tonum: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], length: int64_t)

awkward_ListArray64_num_64(tonum: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t)

awkward_ListArrayU32_num_64(tonum: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], length: int64_t)

    def awkward_ListArray_num(tonum, fromstarts, fromstops, length):
        for i in range(length):
            start = fromstarts[i]
            stop = fromstops[i]
            tonum[i] = float(stop - start)

## awkward_ListArray_rpad_and_clip_length_axis1

awkward_ListArray32_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], target: int64_t, lenstarts: int64_t)

awkward_ListArray64_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], target: int64_t, lenstarts: int64_t)

awkward_ListArrayU32_rpad_and_clip_length_axis1(tomin: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], target: int64_t, lenstarts: int64_t)

    def awkward_ListArray_rpad_and_clip_length_axis1(
        tomin, fromstarts, fromstops, target, lenstarts
    ):
        length = 0
        for i in range(lenstarts):
            rangeval = fromstops[i] - fromstarts[i]
            length += target if target > rangeval else rangeval
        tomin[0] = length

## awkward_ListArray_rpad_axis1

awkward_ListArray32_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[int32_t]], fromstops: Const[List[int32_t]], tostarts: List[int32_t], tostops: List[int32_t], target: int64_t, length: int64_t)

awkward_ListArray64_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], tostarts: List[int64_t], tostops: List[int64_t], target: int64_t, length: int64_t)

awkward_ListArrayU32_rpad_axis1_64(toindex: List[int64_t], fromstarts: Const[List[uint32_t]], fromstops: Const[List[uint32_t]], tostarts: List[uint32_t], tostops: List[uint32_t], target: int64_t, length: int64_t)

    def awkward_ListArray_rpad_axis1(
        toindex, fromstarts, fromstops, tostarts, tostops, target, length
    ):
        offset = 0
        for i in range(length):
            tostarts[i] = offset
            rangeval = fromstops[i] - fromstarts[i]
            for j in range(rangeval):
                toindex[offset + j] = fromstarts[i] + j
            for j in range(rangeval, target):
                toindex[offset + j] = -1
            offset = tostarts[i] + target if target > rangeval else tostarts[i] + rangeval
            tostops[i] = offset

## awkward_ListArray_validity

awkward_ListArray32_validity(starts: Const[List[int32_t]], stops: Const[List[int32_t]], length: int64_t, lencontent: int64_t)

awkward_ListArray64_validity(starts: Const[List[int64_t]], stops: Const[List[int64_t]], length: int64_t, lencontent: int64_t)

awkward_ListArrayU32_validity(starts: Const[List[uint32_t]], stops: Const[List[uint32_t]], length: int64_t, lencontent: int64_t)

    def awkward_ListArray_validity(starts, stops, length, lencontent):
        for i in range(length):
            start = starts[i]
            stop = stops[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)")

## awkward_ListOffsetArray_compact_offsets

awkward_ListOffsetArray32_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[int32_t]], length: int64_t)

awkward_ListOffsetArray64_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t)

awkward_ListOffsetArrayU32_compact_offsets_64(tooffsets: List[int64_t], fromoffsets: Const[List[uint32_t]], length: int64_t)

    def awkward_ListOffsetArray_compact_offsets(tooffsets, fromoffsets, length):
        diff = int(fromoffsets[0])
        tooffsets[0] = 0
        for i in range(length):
            tooffsets[i + 1] = fromoffsets[i + 1] - diff

## awkward_ListOffsetArray_flatten_offsets

awkward_ListOffsetArray32_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[int32_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]], inneroffsetslen: int64_t)

awkward_ListOffsetArray64_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[int64_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]], inneroffsetslen: int64_t)

awkward_ListOffsetArrayU32_flatten_offsets_64(tooffsets: List[int64_t], outeroffsets: Const[List[uint32_t]], outeroffsetslen: int64_t, inneroffsets: Const[List[int64_t]], inneroffsetslen: int64_t)

    def awkward_ListOffsetArray_flatten_offsets(
        tooffsets, outeroffsets, outeroffsetslen, inneroffsets, inneroffsetslen
    ):
        for i in range(outeroffsetslen):
            tooffsets[i] = inneroffsets[outeroffsets[i]]

## awkward_ListOffsetArray_getitem_adjust_offsets

awkward_ListOffsetArray_getitem_adjust_offsets_64(tooffsets: List[int64_t], tononzero: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t, nonzero: Const[List[int64_t]], nonzerolength: int64_t)

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

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

## awkward_ListOffsetArray_getitem_adjust_offsets_index

awkward_ListOffsetArray_getitem_adjust_offsets_index_64(tooffsets: List[int64_t], tononzero: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t, index: Const[List[int64_t]], indexlength: int64_t, nonzero: Const[List[int64_t]], nonzerolength: int64_t, originalmask: Const[List[int8_t]], masklength: int64_t)

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

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

## awkward_ListOffsetArray_local_preparenext_64

awkward_ListOffsetArray_local_preparenext_64(tocarry: List[int64_t], fromindex: Const[List[int64_t]], length: int64_t)

    Insert Python definition here

## awkward_ListOffsetArray_reduce_global_startstop_64

awkward_ListOffsetArray_reduce_global_startstop_64(globalstart: List[int64_t], globalstop: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)

    def awkward_ListOffsetArray_reduce_global_startstop_64(
        globalstart, globalstop, offsets, length
    ):
        globalstart[0] = offsets[0]
        globalstop[0] = offsets[length]

## awkward_ListOffsetArray_reduce_local_nextparents_64

awkward_ListOffsetArray_reduce_local_nextparents_64(nextparents: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)

    def awkward_ListOffsetArray_reduce_local_nextparents_64(nextparents, offsets, length):
        initialoffset = offsets[0]
        for i in range(length):
            j = offsets[i] - initialoffset
            while j < (offsets[i + 1] - initialoffset):
                nextparents[j] = i
                j = j + 1

## awkward_ListOffsetArray_reduce_local_outoffsets_64

awkward_ListOffsetArray_reduce_local_outoffsets_64(outoffsets: List[int64_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_ListOffsetArray_reduce_local_outoffsets_64(
        outoffsets, parents, lenparents, outlength
    ):
        k = 0
        last = -1
        for i in range(lenparents):
            while last < parents[i]:
                outoffsets[k] = i
                k = k + 1
                last = last + 1

        while k <= outlength:
            outoffsets[k] = lenparents
            k = k + 1

## awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64

awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64(maxcount: List[int64_t], offsetscopy: List[int64_t], offsets: Const[List[int64_t]], length: int64_t)

    def awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64(
        maxcount, offsetscopy, offsets, length
    ):
        maxcount[0] = 0
        offsetscopy[0] = offsets[0]
        for i in range(length):
            count = offsets[i + 1] - offsets[i]
            if maxcount[0] < count:
                maxcount[0] = count
            offsetscopy[i + 1] = offsets[i + 1]

## awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64

awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64(nummissing: List[int64_t], missing: List[int64_t], nextshifts: List[int64_t], offsets: Const[List[int64_t]], length: int64_t, starts: Const[List[int64_t]], parents: Const[List[int64_t]], maxcount: int64_t, nextlen: int64_t, nextcarry: Const[List[int64_t]])

    def awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64(
        nummissing,
        missing,
        nextshifts,
        offsets,
        length,
        starts,
        parents,
        maxcount,
        nextlen,
        nextcarry,
    ):
        for i in range(length):
            start = offsets[i]
            stop = offsets[i + 1]
            count = stop - start
            if starts[parents[i]] == i:
                for k in range(maxcount):
                    nummissing[k] = 0
            for k in range(count, maxcount):
                nummissing[k] = nummissing[k] + 1
            for j in range(count):
                missing[start + j] = nummissing[j]
        for j in range(nextlen):
            nextshifts[j] = missing[nextcarry[j]]

## awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64

awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64(nextstarts: List[int64_t], nextparents: Const[List[int64_t]], nextlen: int64_t)

    def awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64(
        nextstarts, nextparents, nextlen
    ):
        lastnextparent = -1
        for i in range(nextlen):
            if nextparents[i] != lastnextparent:
                nextstarts[nextparents[i]] = i
            lastnextparent = nextparents[i]

## awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64

awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64(outstarts: List[int64_t], outstops: List[int64_t], distincts: Const[List[int64_t]], lendistincts: int64_t, outlength: int64_t)

    def awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64(
        outstarts, outstops, distincts, lendistincts, outlength
    ):
        maxcount = lendistincts if (outlength == 0) else int(lendistincts // outlength)
        if outlength > 0 and lendistincts > 0:
            # The sublist index
            k = 0
            i_next_sublist = 0
            for i in range(lendistincts):
                # Are we now in the next sublist?
                if i == i_next_sublist:
                    # Advance counter
                    i_next_sublist += maxcount

                    # Add a new sublist
                    outstarts[k] = i
                    outstops[k] = i

                    k += 1

                # Expand stop index of previous list
                if distincts[i] != -1:
                    outstops[k - 1] = i + 1
        else:
            for k in range(outlength):
              outstarts[k] = 0
              outstops[k] = 0

## awkward_ListOffsetArray_reduce_nonlocal_preparenext_64

awkward_ListOffsetArray_reduce_nonlocal_preparenext_64(nextcarry: List[int64_t], nextparents: List[int64_t], nextlen: int64_t, maxnextparents: List[int64_t], distincts: List[int64_t], distinctslen: int64_t, offsetscopy: List[int64_t], offsets: Const[List[int64_t]], length: int64_t, parents: Const[List[int64_t]], maxcount: int64_t)

    Insert Python definition here

## awkward_ListOffsetArray_rpad_and_clip_axis1

awkward_ListOffsetArray32_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int32_t]], length: int64_t, target: int64_t)

awkward_ListOffsetArray64_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int64_t]], length: int64_t, target: int64_t)

awkward_ListOffsetArrayU32_rpad_and_clip_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[uint32_t]], length: int64_t, target: int64_t)

    def awkward_ListOffsetArray_rpad_and_clip_axis1(toindex, fromoffsets, length, target):
        for i in range(length):
            rangeval = float(fromoffsets[i + 1] - fromoffsets[i])
            shorter = target if target < rangeval else rangeval
            for j in range(shorter):
                toindex[(i * target) + j] = float(fromoffsets[i]) + j
            for j in range(shorter, target):
                toindex[(i * target) + j] = -1

## awkward_ListOffsetArray_rpad_axis1

awkward_ListOffsetArray32_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int32_t]], fromlength: int64_t, target: int64_t)

awkward_ListOffsetArray64_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[int64_t]], fromlength: int64_t, target: int64_t)

awkward_ListOffsetArrayU32_rpad_axis1_64(toindex: List[int64_t], fromoffsets: Const[List[uint32_t]], fromlength: int64_t, target: int64_t)

    def awkward_ListOffsetArray_rpad_axis1(toindex, fromoffsets, fromlength, target):
        count = 0
        for i in range(fromlength):
            rangeval = float(fromoffsets[i + 1] - fromoffsets[i])
            for j in range(rangeval):
                toindex[count] = float(fromoffsets[i]) + j
                count = count + 1
            for j in range(rangeval, target):
                toindex[count] = -1
                count = count + 1

## awkward_ListOffsetArray_rpad_length_axis1

awkward_ListOffsetArray32_rpad_length_axis1(tooffsets: List[int32_t], fromoffsets: Const[List[int32_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])

awkward_ListOffsetArray64_rpad_length_axis1(tooffsets: List[int64_t], fromoffsets: Const[List[int64_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])

awkward_ListOffsetArrayU32_rpad_length_axis1(tooffsets: List[uint32_t], fromoffsets: Const[List[uint32_t]], fromlength: int64_t, target: int64_t, tolength: List[int64_t])

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

## awkward_ListOffsetArray_toRegularArray

awkward_ListOffsetArray32_toRegularArray(size: List[int64_t], fromoffsets: Const[List[int32_t]], offsetslength: int64_t)

awkward_ListOffsetArray64_toRegularArray(size: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t)

awkward_ListOffsetArrayU32_toRegularArray(size: List[int64_t], fromoffsets: Const[List[uint32_t]], offsetslength: int64_t)

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

## awkward_MaskedArray_getitem_next_jagged_project

awkward_MaskedArray32_getitem_next_jagged_project(index: List[int32_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)

awkward_MaskedArray64_getitem_next_jagged_project(index: List[int64_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)

awkward_MaskedArrayU32_getitem_next_jagged_project(index: List[uint32_t], starts_in: List[int64_t], stops_in: List[int64_t], starts_out: List[int64_t], stops_out: List[int64_t], length: int64_t)

    def awkward_MaskedArray_getitem_next_jagged_project(
        index, starts_in, stops_in, starts_out, stops_out, length
    ):
        k = 0
        for i in range(length):
            if index[i] >= 0:
                starts_out[k] = starts_in[i]
                stops_out[k] = stops_in[i]
                k = k + 1

## awkward_NumpyArray_copy

awkward_NumpyArray_copy(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], len: int64_t)

    Insert Python definition here

## awkward_NumpyArray_contiguous_copy

awkward_NumpyArray_contiguous_copy_64(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], len: int64_t, stride: int64_t, pos: Const[List[int64_t]])

    Insert Python definition here

## awkward_NumpyArray_contiguous_copy_from_many

awkward_NumpyArray_contiguous_copy_from_many_64(toptr: List[uint8_t], fromptrs: Const[List[List[uint8_t]]], fromlens: List[int64_t], len: int64_t, stride: int64_t, pos: Const[List[int64_t]])

    Insert Python definition here

## awkward_NumpyArray_contiguous_init

awkward_NumpyArray_contiguous_init_64(toptr: List[int64_t], skip: int64_t, stride: int64_t)

    def awkward_NumpyArray_contiguous_init(toptr, skip, stride):
        for i in range(skip):
            toptr[i] = i * stride

## awkward_NumpyArray_contiguous_next

awkward_NumpyArray_contiguous_next_64(topos: List[int64_t], frompos: Const[List[int64_t]], length: int64_t, skip: int64_t, stride: int64_t)

    def awkward_NumpyArray_contiguous_next(topos, frompos, length, skip, stride):
        for i in range(length):
            for j in range(skip):
                topos[(i * skip) + j] = frompos[i] + (j * stride)

## awkward_NumpyArray_fill

awkward_NumpyArray_fill_toint8_fromint8(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromint16(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromint32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromint64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromuint8(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromuint16(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromuint32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromuint64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromfloat32(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromfloat64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromint8(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromint16(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromint32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromint64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromuint8(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromuint16(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromuint32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromuint64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromfloat32(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromfloat64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromint8(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromint16(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromint32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromint64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromuint8(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromuint16(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromuint32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromuint64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromfloat32(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromfloat64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromint8(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromint16(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromint32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromint64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromuint8(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromuint16(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromuint32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromuint64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromfloat32(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromfloat64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromint8(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromint16(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromint32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromint64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromuint8(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromuint16(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromuint32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromuint64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromfloat32(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromfloat64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromint8(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromint16(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromint32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromint64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromuint8(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromuint16(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromuint32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromuint64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromfloat32(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromfloat64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromint8(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromint16(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromint32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromint64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromuint8(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromuint16(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromuint32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromuint64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromfloat32(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromfloat64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromint8(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromint16(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromint32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromint64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromuint8(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromuint16(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromuint32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromuint64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromfloat32(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromfloat64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromuint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromuint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromuint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromuint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromfloat32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromfloat64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromuint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromuint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromuint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromuint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromfloat32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromfloat64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

    def awkward_NumpyArray_fill(toptr, tooffset, fromptr, length):
        for i in range(length):
            toptr[tooffset + i] = float(fromptr[i])

## awkward_NumpyArray_fill_tocomplex

awkward_NumpyArray_fill_tocomplex64_frombool(toptr: List[float], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromuint8(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromuint16(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromuint32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromuint64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromfloat32(toptr: List[float], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tocomplex64_fromfloat64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_frombool(toptr: List[double], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromuint8(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromuint16(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromuint32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromuint64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromfloat32(toptr: List[double], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tocomplex128_fromfloat64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

## awkward_NumpyArray_fill_fromcomplex

awkward_NumpyArray_fill_tobool_fromcomplex64(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromcomplex128(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromcomplex64(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint8_fromcomplex128(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromcomplex64(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint16_fromcomplex128(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromcomplex64(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint32_fromcomplex128(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromcomplex64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_toint64_fromcomplex128(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromcomplex64(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint8_fromcomplex128(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromcomplex64(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint16_fromcomplex128(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromcomplex64(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint32_fromcomplex128(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromcomplex64(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_touint64_fromcomplex128(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromcomplex64(toptr: List[float], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_fromcomplex128(toptr: List[float], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromcomplex64(toptr: List[double], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_fromcomplex128(toptr: List[double], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

    def awkward_NumpyArray_fill_fromcomplex(toptr, tooffset, fromptr, length):
        for i in range(length):
            toptr[tooffset + i] = fromptr[i*2]

## awkward_NumpyArray_fill_frombool

awkward_NumpyArray_fill_tobool_frombool(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_toint8_frombool(toptr: List[int8_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_toint16_frombool(toptr: List[int16_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_toint32_frombool(toptr: List[int32_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_toint64_frombool(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_touint8_frombool(toptr: List[uint8_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_touint16_frombool(toptr: List[uint16_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_touint32_frombool(toptr: List[uint32_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_touint64_frombool(toptr: List[uint64_t], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_tofloat32_frombool(toptr: List[float], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

awkward_NumpyArray_fill_tofloat64_frombool(toptr: List[double], tooffset: int64_t, fromptr: Const[List[bool]], length: int64_t)

    def awkward_NumpyArray_fill_frombool(toptr, tooffset, fromptr, length):
        for i in range(length):
            toptr[tooffset + i] = float(1 if fromptr[i] else 0)

## awkward_NumpyArray_fill_tobool

awkward_NumpyArray_fill_tobool_fromint8(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[int8_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromint16(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[int16_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromint32(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[int32_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromint64(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromuint8(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[uint8_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromuint16(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[uint16_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromuint32(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[uint32_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromuint64(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[uint64_t]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromfloat32(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[float]], length: int64_t)

awkward_NumpyArray_fill_tobool_fromfloat64(toptr: List[bool], tooffset: int64_t, fromptr: Const[List[double]], length: int64_t)

    def awkward_NumpyArray_fill_tobool(toptr, tooffset, fromptr, length):
        for i in range(length):
            toptr[tooffset + i] = True if fromptr[i] > 0 else False

## awkward_NumpyArray_fill_scaled

awkward_NumpyArray_fill_scaled_toint64_fromint64(toptr: List[int64_t], tooffset: int64_t, fromptr: Const[List[int64_t]], length: int64_t, scale: double)

    def awkward_NumpyArray_fill_scaled(toptr, tooffset, fromptr, length, scale):
        for i in range(length):
            toptr[tooffset + i] = fromptr[i] * scale

## awkward_NumpyArray_rearrange_shifted

awkward_NumpyArray_rearrange_shifted_toint64_fromint64(toptr: List[int64_t], fromshifts: Const[List[int64_t]], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, fromparents: Const[List[int64_t]], parentslength: int64_t, fromstarts: Const[List[int64_t]], startslength: int64_t)

    def awkward_NumpyArray_rearrange_shifted(toptr, fromshifts, length, fromoffsets, offsetslength, fromparents, parentslength):
        k = 0
        for i in range(offsetslength - 1):
            for j in rage(fromoffsets[i + 1] - fromoffsets[i]):
                toptr[k] = toptr[k] + fromoffsets[i]
                k = k + 1

        for i in range(length):
            parent = fromparents[i]
            start = fromstarts[parent]
            toptr[i] = toptr[i] + fromshifts[toptr[i]] - start

## awkward_NumpyArray_getitem_boolean_nonzero

awkward_NumpyArray_getitem_boolean_nonzero_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, stride: int64_t)

    def awkward_NumpyArray_getitem_boolean_nonzero(toptr, fromptr, length, stride):
        k = 0
        i = 0
        while i < length:
            if fromptr[i] != 0:
                toptr[k] = i
                k = k + 1
            i += stride

## awkward_NumpyArray_getitem_boolean_numtrue

awkward_NumpyArray_getitem_boolean_numtrue(numtrue: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, stride: int64_t)

    def awkward_NumpyArray_getitem_boolean_numtrue(numtrue, fromptr, length, stride):
        numtrue[0] = 0
        i = 0
        while i < length:
            numtrue[0] = numtrue[0] + (fromptr[i] != 0)
            i += stride

## awkward_NumpyArray_getitem_next_array

awkward_NumpyArray_getitem_next_array_64(nextcarryptr: List[int64_t], nextadvancedptr: List[int64_t], carryptr: Const[List[int64_t]], flatheadptr: Const[List[int64_t]], lencarry: int64_t, lenflathead: int64_t, skip: int64_t)

    def awkward_NumpyArray_getitem_next_array(
        nextcarryptr, nextadvancedptr, carryptr, flatheadptr, lencarry, lenflathead, skip
    ):
        for i in range(lencarry):
            for j in range(lenflathead):
                nextcarryptr[(i * lenflathead) + j] = (skip * carryptr[i]) + flatheadptr[j]
                nextadvancedptr[(i * lenflathead) + j] = j

## awkward_NumpyArray_getitem_next_array_advanced

awkward_NumpyArray_getitem_next_array_advanced_64(nextcarryptr: List[int64_t], carryptr: Const[List[int64_t]], advancedptr: Const[List[int64_t]], flatheadptr: Const[List[int64_t]], lencarry: int64_t, skip: int64_t)

    def awkward_NumpyArray_getitem_next_array_advanced(
        nextcarryptr, carryptr, advancedptr, flatheadptr, lencarry, skip
    ):
        for i in range(lencarry):
            nextcarryptr[i] = (skip * carryptr[i]) + flatheadptr[advancedptr[i]]

## awkward_NumpyArray_getitem_next_at

awkward_NumpyArray_getitem_next_at_64(nextcarryptr: List[int64_t], carryptr: Const[List[int64_t]], lencarry: int64_t, skip: int64_t, at: int64_t)

    def awkward_NumpyArray_getitem_next_at(nextcarryptr, carryptr, lencarry, skip, at):
        for i in range(lencarry):
            nextcarryptr[i] = (skip * carryptr[i]) + at

## awkward_NumpyArray_getitem_next_null

awkward_NumpyArray_getitem_next_null_64(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], len: int64_t, stride: int64_t, pos: Const[List[int64_t]])

    Insert Python definition here

## awkward_NumpyArray_getitem_next_range

awkward_NumpyArray_getitem_next_range_64(nextcarryptr: List[int64_t], carryptr: Const[List[int64_t]], lencarry: int64_t, lenhead: int64_t, skip: int64_t, start: int64_t, step: int64_t)

    def awkward_NumpyArray_getitem_next_range(
        nextcarryptr, carryptr, lencarry, lenhead, skip, start, step
    ):
        for i in range(lencarry):
            for j in range(lenhead):
                nextcarryptr[(i * lenhead) + j] = ((skip * carryptr[i]) + start) + (
                    j * step
                )

## awkward_NumpyArray_getitem_next_range_advanced

awkward_NumpyArray_getitem_next_range_advanced_64(nextcarryptr: List[int64_t], nextadvancedptr: List[int64_t], carryptr: Const[List[int64_t]], advancedptr: Const[List[int64_t]], lencarry: int64_t, lenhead: int64_t, skip: int64_t, start: int64_t, step: int64_t)

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

## awkward_NumpyArray_reduce_adjust_starts_64

awkward_NumpyArray_reduce_adjust_starts_64(toptr: List[int64_t], outlength: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]])

    def awkward_NumpyArray_reduce_adjust_starts_64(toptr, outlength, parents, starts):
        for k in range(outlength):
            i = toptr[k]
            if i >= 0:
                parent = parents[i]
                start = starts[parent]
                toptr[k] += -start

## awkward_NumpyArray_reduce_adjust_starts_shifts_64

awkward_NumpyArray_reduce_adjust_starts_shifts_64(toptr: List[int64_t], outlength: int64_t, parents: Const[List[int64_t]], starts: Const[List[int64_t]], shifts: Const[List[int64_t]])

    def awkward_NumpyArray_reduce_adjust_starts_shifts_64(
        toptr, outlength, parents, starts, shifts
    ):
        for k in range(outlength):
            i = toptr[k]
            if i >= 0:
                parent = parents[i]
                start = starts[parent]
                toptr[k] += shifts[i] - start

## awkward_NumpyArray_reduce_mask_ByteMaskedArray_64

awkward_NumpyArray_reduce_mask_ByteMaskedArray_64(toptr: List[int8_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_NumpyArray_reduce_mask_ByteMaskedArray_64(
        toptr, parents, lenparents, outlength
    ):
        for i in range(outlength):
            toptr[i] = 1
        for i in range(lenparents):
            toptr[parents[i]] = 0

## awkward_ListOffsetArray_argsort_strings

awkward_ListOffsetArray_argsort_strings(tocarry: List[int64_t], fromparents: Const[List[int64_t]], length: int64_t, stringdata: Const[List[uint8_t]], stringstarts: Const[List[int64_t]], stringstops: Const[List[int64_t]], is_stable: bool, is_ascending: bool, is_local: bool)

    Insert Python definition here

## awkward_NumpyArray_sort_asstrings_uint8

awkward_NumpyArray_sort_asstrings_uint8(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], ascending: bool, stable: bool)

    Insert Python definition here

## awkward_NumpyArray_unique_ranges

awkward_NumpyArray_unique_ranges_int8(toptr: List[int8_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_int16(toptr: List[int16_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_int32(toptr: List[int32_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_int64(toptr: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_uint8(toptr: List[uint8_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_uint16(toptr: List[uint16_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_uint32(toptr: List[uint32_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_uint64(toptr: List[uint64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_float32(toptr: List[float], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

awkward_NumpyArray_unique_ranges_float64(toptr: List[double], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

    Insert Python definition here

## awkward_NumpyArray_unique_strings

awkward_NumpyArray_unique_strings_uint8(toptr: List[uint8_t], offsets: Const[List[int64_t]], offsetslength: int64_t, outoffsets: List[int64_t], tolength: List[int64_t])

    Insert Python definition here

## awkward_NumpyArray_subrange_equal

awkward_NumpyArray_subrange_equal_bool(tmpptr: List[bool], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_int8(tmpptr: List[int8_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_int16(tmpptr: List[int16_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_int32(tmpptr: List[int32_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_int64(tmpptr: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_uint8(tmpptr: List[uint8_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_uint16(tmpptr: List[uint16_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_uint32(tmpptr: List[uint32_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_uint64(tmpptr: List[uint64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_float32(tmpptr: List[float], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

awkward_NumpyArray_subrange_equal_float64(tmpptr: List[double], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], length: int64_t, toequal: List[bool])

    Insert Python definition here

## awkward_RegularArray_broadcast_tooffsets

awkward_RegularArray_broadcast_tooffsets_64(fromoffsets: Const[List[int64_t]], offsetslength: int64_t, size: int64_t)

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

## awkward_RegularArray_broadcast_tooffsets_size1

awkward_RegularArray_broadcast_tooffsets_size1_64(tocarry: List[int64_t], fromoffsets: Const[List[int64_t]], offsetslength: int64_t)

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

## awkward_RegularArray_combinations_64

awkward_RegularArray_combinations_64(tocarry: List[List[int64_t]], toindex: List[int64_t], fromindex: List[int64_t], n: int64_t, replacement: bool, size: int64_t, length: int64_t)

    Insert Python definition here

## awkward_RegularArray_compact_offsets

awkward_RegularArray_compact_offsets64(tooffsets: List[int64_t], length: int64_t, size: int64_t)

    def awkward_RegularArray_compact_offsets(tooffsets, length, size):
        tooffsets[0] = 0
        for i in range(length):
            tooffsets[i + 1] = (i + 1) * size

## awkward_RegularArray_getitem_carry

awkward_RegularArray_getitem_carry_64(tocarry: List[int64_t], fromcarry: Const[List[int64_t]], lencarry: int64_t, size: int64_t)

    def awkward_RegularArray_getitem_carry(tocarry, fromcarry, lencarry, size):
        for i in range(lencarry):
            for j in range(size):
                tocarry[(i * size) + j] = (fromcarry[i] * size) + j

## awkward_RegularArray_getitem_jagged_expand

awkward_RegularArray_getitem_jagged_expand_64(multistarts: List[int64_t], multistops: List[int64_t], singleoffsets: Const[List[int64_t]], regularsize: int64_t, regularlength: int64_t)

    def awkward_RegularArray_getitem_jagged_expand(
        multistarts, multistops, singleoffsets, regularsize, regularlength
    ):
        for i in range(regularlength):
            for j in range(regularsize):
                multistarts[(i * regularsize) + j] = singleoffsets[j]
                multistops[(i * regularsize) + j] = singleoffsets[j + 1]

## awkward_RegularArray_getitem_next_array

awkward_RegularArray_getitem_next_array_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromarray: Const[List[int64_t]], length: int64_t, lenarray: int64_t, size: int64_t)

    def awkward_RegularArray_getitem_next_array(
        tocarry, toadvanced, fromarray, length, lenarray, size
    ):
        for i in range(length):
            for j in range(lenarray):
                tocarry[(i * lenarray) + j] = (i * size) + fromarray[j]
                toadvanced[(i * lenarray) + j] = j

## awkward_RegularArray_getitem_next_array_advanced

awkward_RegularArray_getitem_next_array_advanced_64(tocarry: List[int64_t], toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], fromarray: Const[List[int64_t]], length: int64_t, lenarray: int64_t, size: int64_t)

    def awkward_RegularArray_getitem_next_array_advanced(
        tocarry, toadvanced, fromadvanced, fromarray, length, lenarray, size
    ):
        for i in range(length):
            tocarry[i] = (i * size) + fromarray[fromadvanced[i]]
            toadvanced[i] = i

## awkward_RegularArray_getitem_next_array_regularize

awkward_RegularArray_getitem_next_array_regularize_64(toarray: List[int64_t], fromarray: Const[List[int64_t]], lenarray: int64_t, size: int64_t)

    def awkward_RegularArray_getitem_next_array_regularize(
        toarray, fromarray, lenarray, size
    ):
        for j in range(lenarray):
            toarray[j] = fromarray[j]
            if toarray[j] < 0:
                toarray[j] += size
            if not ((0 <= toarray[j]) and (toarray[j] < size)):
                raise ValueError("index out of range")

## awkward_RegularArray_getitem_next_at

awkward_RegularArray_getitem_next_at_64(tocarry: List[int64_t], at: int64_t, length: int64_t, size: int64_t)

    def awkward_RegularArray_getitem_next_at(tocarry, at, length, size):
        regular_at = at
        if regular_at < 0:
            regular_at += size
        if not ((0 <= regular_at) and (regular_at < size)):
            raise ValueError("index out of range")
        for i in range(length):
            tocarry[i] = (i * size) + regular_at

## awkward_RegularArray_getitem_next_range

awkward_RegularArray_getitem_next_range_64(tocarry: List[int64_t], regular_start: int64_t, step: int64_t, length: int64_t, size: int64_t, nextsize: int64_t)

    def awkward_RegularArray_getitem_next_range(
        tocarry, regular_start, step, length, size, nextsize
    ):
        for i in range(length):
            for j in range(nextsize):
                tocarry[(i * nextsize) + j] = ((i * size) + regular_start) + (j * step)

## awkward_RegularArray_getitem_next_range_spreadadvanced

awkward_RegularArray_getitem_next_range_spreadadvanced_64(toadvanced: List[int64_t], fromadvanced: Const[List[int64_t]], length: int64_t, nextsize: int64_t)

    def awkward_RegularArray_getitem_next_range_spreadadvanced(
        toadvanced, fromadvanced, length, nextsize
    ):
        for i in range(length):
            for j in range(nextsize):
                toadvanced[(i * nextsize) + j] = fromadvanced[i]

## awkward_RegularArray_localindex

awkward_RegularArray_localindex_64(toindex: List[int64_t], size: int64_t, length: int64_t)

    def awkward_RegularArray_localindex(toindex, size, length):
        for i in range(length):
            for j in range(size):
                toindex[(i * size) + j] = j

## awkward_RegularArray_num

awkward_RegularArray_num_64(tonum: List[int64_t], size: int64_t, length: int64_t)

    def awkward_RegularArray_num(tonum, size, length):
        for i in range(length):
            tonum[i] = size

## awkward_RegularArray_reduce_local_nextparents

awkward_RegularArray_reduce_local_nextparents_64(nextparents: List[int64_t], size: int64_t, length: int64_t)

    def awkward_RegularArray_reduce_local_nextparents(nextparents, size, length):
        k = 0
        for i in range(length):
            for _ in range(size):
                # nextparents should contain the row index
                nextparents[k] = i
                k += 1

## awkward_RegularArray_reduce_nonlocal_preparenext

awkward_RegularArray_reduce_nonlocal_preparenext_64(nextcarry: List[int64_t], nextparents: List[int64_t], parents: Const[List[int64_t]], size: int64_t, length: int64_t)

    def awkward_RegularArray_reduce_nonlocal_preparenext(nextcarry, nextparents, parents, size, length):
        k = 0
        for j in range(size):
            for i in range(length):
                # nextparents needs to be locally contiguous
                # so order our arrays by the transpose
                nextcarry[k] = i * size + j
                nextparents[k] = parents[i] * size + j
                k += 1

## awkward_RegularArray_rpad_and_clip_axis1

awkward_RegularArray_rpad_and_clip_axis1_64(toindex: List[int64_t], target: int64_t, size: int64_t, length: int64_t)

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

## awkward_UnionArray_fillindex

awkward_UnionArray_fillindex_to64_from32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int32_t]], length: int64_t)

awkward_UnionArray_fillindex_to64_from64(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[int64_t]], length: int64_t)

awkward_UnionArray_fillindex_to64_fromU32(toindex: List[int64_t], toindexoffset: int64_t, fromindex: Const[List[uint32_t]], length: int64_t)

    def awkward_UnionArray_fillindex(toindex, toindexoffset, fromindex, length):
        for i in range(length):
            toindex[toindexoffset + i] = float(fromindex[i])

## awkward_UnionArray_fillindex_count

awkward_UnionArray_fillindex_to64_count(toindex: List[int64_t], toindexoffset: int64_t, length: int64_t)

    def awkward_UnionArray_fillindex_count(toindex, toindexoffset, length):
        for i in range(length):
            toindex[toindexoffset + i] = float(i)

## awkward_UnionArray_fillna

awkward_UnionArray_fillna_from32_to64(toindex: List[int64_t], fromindex: Const[List[int32_t]], length: int64_t)

awkward_UnionArray_fillna_from64_to64(toindex: List[int64_t], fromindex: Const[List[int64_t]], length: int64_t)

awkward_UnionArray_fillna_fromU32_to64(toindex: List[int64_t], fromindex: Const[List[uint32_t]], length: int64_t)

    def awkward_UnionArray_fillna(toindex, fromindex, length):
        for i in range(length):
            toindex[i] = fromindex[i] if fromindex[i] >= 0 else 0

## awkward_UnionArray_filltags

awkward_UnionArray_filltags_to8_from8(totags: List[int8_t], totagsoffset: int64_t, fromtags: Const[List[int8_t]], length: int64_t, base: int64_t)

    def awkward_UnionArray_filltags(totags, totagsoffset, fromtags, length, base):
        for i in range(length):
            totags[totagsoffset + i] = float(fromtags[i] + base)

## awkward_UnionArray_filltags_const

awkward_UnionArray_filltags_to8_const(totags: List[int8_t], totagsoffset: int64_t, length: int64_t, base: int64_t)

    def awkward_UnionArray_filltags_const(totags, totagsoffset, length, base):
        for i in range(length):
            totags[totagsoffset + i] = float(base)

## awkward_UnionArray_flatten_combine

awkward_UnionArray32_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, offsetsraws: List[List[int64_t]])

awkward_UnionArray64_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, offsetsraws: List[List[int64_t]])

awkward_UnionArrayU32_flatten_combine_64(totags: List[int8_t], toindex: List[int64_t], tooffsets: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, offsetsraws: List[List[int64_t]])

    def awkward_UnionArray_flatten_combine(
        totags, toindex, tooffsets, fromtags, fromindex, length, offsetsraws
    ):
        tooffsets[0] = 0
        k = 0
        for i in range(length):
            tag = fromtags[i]
            idx = fromindex[i]
            start = offsetsraws[tag][idx]
            stop = offsetsraws[tag][idx + 1]
            tooffsets[i + 1] = tooffsets[i] + (stop - start)
            for j in range(start, stop):
                totags[k] = tag
                toindex[k] = j
                k = k + 1

## awkward_UnionArray_flatten_length

awkward_UnionArray32_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, offsetsraws: List[List[int64_t]])

awkward_UnionArray64_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, offsetsraws: List[List[int64_t]])

awkward_UnionArrayU32_flatten_length_64(total_length: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, offsetsraws: List[List[int64_t]])

    def awkward_UnionArray_flatten_length(
        total_length, fromtags, fromindex, length, offsetsraws
    ):
        total_length[0] = 0
        for i in range(length):
            tag = fromtags[i]
            idx = fromindex[i]
            start = offsetsraws[tag][idx]
            stop = offsetsraws[tag][idx + 1]
            total_length[0] = total_length[0] + (stop - start)

## awkward_UnionArray_nestedfill_tags_index

awkward_UnionArray8_32_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[int32_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)

awkward_UnionArray8_64_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[int64_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)

awkward_UnionArray8_U32_nestedfill_tags_index_64(totags: List[int8_t], toindex: List[uint32_t], tmpstarts: List[int64_t], tag: int8_t, fromcounts: Const[List[int64_t]], length: int64_t)

    def awkward_UnionArray_nestedfill_tags_index(
        totags, toindex, tmpstarts, tag, fromcounts, length
    ):
        k = 0
        for i in range(length):
            start = tmpstarts[i]
            stop = start + fromcounts[i]
            for j in range(start, stop):
                totags[j] = tag
                toindex[j] = k
                k += 1
            tmpstarts[i] = stop

## awkward_UnionArray_project

awkward_UnionArray8_32_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], length: int64_t, which: int64_t)

awkward_UnionArray8_64_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], length: int64_t, which: int64_t)

awkward_UnionArray8_U32_project_64(lenout: List[int64_t], tocarry: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], length: int64_t, which: int64_t)

    def awkward_UnionArray_project(lenout, tocarry, fromtags, fromindex, length, which):
        lenout[0] = 0
        for i in range(length):
            if fromtags[i] == which:
                tocarry[lenout[0]] = fromindex[i]
                lenout[0] = lenout[0] + 1

## awkward_UnionArray_regular_index

awkward_UnionArray8_32_regular_index(toindex: List[int32_t], current: List[int32_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)

awkward_UnionArray8_64_regular_index(toindex: List[int64_t], current: List[int64_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)

awkward_UnionArray8_U32_regular_index(toindex: List[uint32_t], current: List[uint32_t], size: int64_t, fromtags: Const[List[int8_t]], length: int64_t)

    def awkward_UnionArray_regular_index(toindex, current, size, fromtags, length):
        count = 0
        for k in range(size):
            current[k] = 0
        for i in range(length):
            tag = fromtags[i]
            toindex[i] = current[tag]
            current[tag] = current[tag] + 1

## awkward_UnionArray_regular_index_getsize

awkward_UnionArray8_regular_index_getsize(size: List[int64_t], fromtags: Const[List[int8_t]], length: int64_t)

    def awkward_UnionArray_regular_index_getsize(size, fromtags, length):
        size[0] = 0
        for i in range(length):
            tag = int(fromtags[i])
            if size[0] < tag:
                size[0] = tag
        size[0] = size[0] + 1

## awkward_UnionArray_simplify

awkward_UnionArray8_32_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_32_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_32_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_64_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_64_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_64_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[int64_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_U32_simplify8_32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_U32_simplify8_64_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[int64_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_U32_simplify8_U32_to8_64(totags: List[int8_t], toindex: List[int64_t], outertags: Const[List[int8_t]], outerindex: Const[List[uint32_t]], innertags: Const[List[int8_t]], innerindex: Const[List[uint32_t]], towhich: int64_t, innerwhich: int64_t, outerwhich: int64_t, length: int64_t, base: int64_t)

    def awkward_UnionArray_simplify(
        totags,
        toindex,
        outertags,
        outerindex,
        innertags,
        innerindex,
        towhich,
        innerwhich,
        outerwhich,
        length,
        base,
    ):
        for i in range(length):
            if outertags[i] == outerwhich:
                j = outerindex[i]
                if innertags[j] == innerwhich:
                    totags[i] = float(towhich)
                    toindex[i] = float(innerindex[j] + base)

## awkward_UnionArray_simplify_one

awkward_UnionArray8_32_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int32_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_64_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[int64_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)

awkward_UnionArray8_U32_simplify_one_to8_64(totags: List[int8_t], toindex: List[int64_t], fromtags: Const[List[int8_t]], fromindex: Const[List[uint32_t]], towhich: int64_t, fromwhich: int64_t, length: int64_t, base: int64_t)

    def awkward_UnionArray_simplify_one(
        totags, toindex, fromtags, fromindex, towhich, fromwhich, length, base
    ):
        for i in range(length):
            if fromtags[i] == fromwhich:
                totags[i] = float(towhich)
                toindex[i] = float(fromindex[i] + base)

## awkward_UnionArray_validity

awkward_UnionArray8_32_validity(tags: Const[List[int8_t]], index: Const[List[int32_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])

awkward_UnionArray8_64_validity(tags: Const[List[int8_t]], index: Const[List[int64_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])

awkward_UnionArray8_U32_validity(tags: Const[List[int8_t]], index: Const[List[uint32_t]], length: int64_t, numcontents: int64_t, lencontents: Const[List[int64_t]])

    def awkward_UnionArray_validity(tags, index, length, numcontents, lencontents):
        for i in range(length):
            tag = tags[i]
            idx = index[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]])")

## awkward_argsort

awkward_argsort_bool(toptr: List[int64_t], fromptr: Const[List[bool]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_int8(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_int16(toptr: List[int64_t], fromptr: Const[List[int16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_int32(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_uint8(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_uint16(toptr: List[int64_t], fromptr: Const[List[uint16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_uint32(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_uint64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_float32(toptr: List[int64_t], fromptr: Const[List[float]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_argsort_float64(toptr: List[int64_t], fromptr: Const[List[double]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

    Insert Python definition here

## awkward_ListOffsetArray_argsort

awkward_ListOffsetArray_argsort_bool(toptr: List[int64_t], fromptr: Const[List[bool]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_int8(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_int16(toptr: List[int64_t], fromptr: Const[List[int16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_int32(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_uint8(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_uint16(toptr: List[int64_t], fromptr: Const[List[uint16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_uint32(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_uint64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_float32(toptr: List[int64_t], fromptr: Const[List[float]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

awkward_ListOffsetArray_argsort_float64(toptr: List[int64_t], fromptr: Const[List[double]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool)

    Insert Python definition here

## awkward_ListArray_argsort

awkward_ListArray_argsort_bool(toptr: List[int64_t], fromptr: Const[List[bool]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_int8(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_int16(toptr: List[int64_t], fromptr: Const[List[int16_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_int32(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_uint8(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_uint16(toptr: List[int64_t], fromptr: Const[List[uint16_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_uint32(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_uint64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_float32(toptr: List[int64_t], fromptr: Const[List[float]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

awkward_ListArray_argsort_float64(toptr: List[int64_t], fromptr: Const[List[double]], length: int64_t, starts: Const[List[int64_t]], stops: Const[List[int64_t]], startslength: int64_t, ascending: bool, stable: bool)

    Insert Python definition here

## awkward_quick_argsort

awkward_quick_argsort_bool(toptr: List[int64_t], fromptr: Const[List[bool]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_int8(toptr: List[int64_t], fromptr: Const[List[int8_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_int16(toptr: List[int64_t], fromptr: Const[List[int16_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_int32(toptr: List[int64_t], fromptr: Const[List[int32_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_uint8(toptr: List[int64_t], fromptr: Const[List[uint8_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_uint16(toptr: List[int64_t], fromptr: Const[List[uint16_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_uint32(toptr: List[int64_t], fromptr: Const[List[uint32_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_uint64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_float32(toptr: List[int64_t], fromptr: Const[List[float]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

awkward_quick_argsort_float64(toptr: List[int64_t], fromptr: Const[List[double]], length: int64_t, tmpbeg: List[int64_t], tmpend: List[int64_t], offsets: Const[List[int64_t]], offsetslength: int64_t, ascending: bool, stable: bool, maxlevels: int64_t)

    Insert Python definition here

## awkward_carry_arange

awkward_carry_arange32(toptr: List[int32_t], length: int64_t)

awkward_carry_arange64(toptr: List[int64_t], length: int64_t)

awkward_carry_arangeU32(toptr: List[uint32_t], length: int64_t)

    def awkward_carry_arange(toptr, length):
        for i in range(length):
            toptr[i] = i

## awkward_combinations

awkward_combinations_64(toindex: List[int64_t], n: int64_t, replacement: bool, singlelen: int64_t)

    def awkward_combinations(toindex, n, replacement, singlelen):
        raise ValueError("FIXME: awkward_combinations")

## awkward_content_reduce_zeroparents_64

awkward_content_reduce_zeroparents_64(toparents: List[int64_t], length: int64_t)

    def awkward_content_reduce_zeroparents_64(toparents, length):
        for i in range(length):
            toparents[i] = 0

## awkward_index_carry

awkward_Index32_carry_64(toindex: List[int32_t], fromindex: Const[List[int32_t]], carry: Const[List[int64_t]], lenfromindex: int64_t, length: int64_t)

awkward_Index64_carry_64(toindex: List[int64_t], fromindex: Const[List[int64_t]], carry: Const[List[int64_t]], lenfromindex: int64_t, length: int64_t)

awkward_Index8_carry_64(toindex: List[int8_t], fromindex: Const[List[int8_t]], carry: Const[List[int64_t]], lenfromindex: int64_t, length: int64_t)

awkward_IndexU32_carry_64(toindex: List[uint32_t], fromindex: Const[List[uint32_t]], carry: Const[List[int64_t]], lenfromindex: int64_t, length: int64_t)

awkward_IndexU8_carry_64(toindex: List[uint8_t], fromindex: Const[List[uint8_t]], carry: Const[List[int64_t]], lenfromindex: int64_t, length: int64_t)

    def awkward_index_carry(toindex, fromindex, carry, lenfromindex, length):
        for i in range(length):
            j = carry[i]
            if j > lenfromindex:
                raise ValueError("index out of range")
            toindex[i] = fromindex[j]

## awkward_index_carry_nocheck

awkward_Index32_carry_nocheck_64(toindex: List[int32_t], fromindex: Const[List[int32_t]], carry: Const[List[int64_t]], length: int64_t)

awkward_Index64_carry_nocheck_64(toindex: List[int64_t], fromindex: Const[List[int64_t]], carry: Const[List[int64_t]], length: int64_t)

awkward_Index8_carry_nocheck_64(toindex: List[int8_t], fromindex: Const[List[int8_t]], carry: Const[List[int64_t]], length: int64_t)

awkward_IndexU32_carry_nocheck_64(toindex: List[uint32_t], fromindex: Const[List[uint32_t]], carry: Const[List[int64_t]], length: int64_t)

awkward_IndexU8_carry_nocheck_64(toindex: List[uint8_t], fromindex: Const[List[uint8_t]], carry: Const[List[int64_t]], length: int64_t)

    def awkward_index_carry_nocheck(toindex, fromindex, carry, length):
        for i in range(length):
            toindex[i] = fromindex[carry[i]]

## awkward_index_rpad_and_clip_axis0

awkward_index_rpad_and_clip_axis0_64(toindex: List[int64_t], target: int64_t, length: int64_t)

    def awkward_index_rpad_and_clip_axis0(toindex, target, length):
        shorter = target if target < length else length
        for i in range(shorter):
            toindex[i] = i
        for i in range(shorter, target):
            toindex[i] = -1

## awkward_index_rpad_and_clip_axis1

awkward_index_rpad_and_clip_axis1_64(tostarts: List[int64_t], tostops: List[int64_t], target: int64_t, length: int64_t)

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

## awkward_Index_nones_as_index

awkward_Index_nones_as_index_64(toindex: List[int64_t], length: int64_t)

    def awkward_Index_nones_as_index(toindex, length):
        last_index = 0
        for i in range(length):
            if toindex[i] > last_index:
                last_index = toindex[i]
        for i in range(length):
            if toindex[i] == -1:
                last_index = last_index + 1
                toindex[i] = last_index

## awkward_localindex

awkward_localindex_64(toindex: List[int64_t], length: int64_t)

    def awkward_localindex(toindex, length):
        for i in range(length):
            toindex[i] = i

## awkward_missing_repeat

awkward_missing_repeat_64(outindex: List[int64_t], index: Const[List[int64_t]], indexlength: int64_t, repetitions: int64_t, regularsize: int64_t)

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

## awkward_new_Identities

awkward_new_Identities32(toptr: List[int32_t], length: int64_t)

awkward_new_Identities64(toptr: List[int64_t], length: int64_t)

    def awkward_new_Identities(toptr, length):
        for i in range(length):
            toptr[i] = i

## awkward_reduce_argmax

awkward_reduce_argmax_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_argmax(toptr, fromptr, parents, lenparents, outlength):
        for k in range(outlength):
            toptr[k] = -1
        for i in range(lenparents):
            parent = parents[i]
            if (toptr[parent] == -1) or (fromptr[i] > fromptr[toptr[parent]]):
                toptr[parent] = i

## awkward_reduce_argmax_complex

awkward_reduce_argmax_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmax_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_argmax_bool_64

awkward_reduce_argmax_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_argmax_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for k in range(outlength):
            toptr[k] = -1
        for i in range(lenparents):
            parent = parents[i]
            if (toptr[parent] == -1) or ((fromptr[i] != 0) > (fromptr[toptr[parent]] != 0)):
                toptr[parent] = i

## awkward_reduce_argmin

awkward_reduce_argmin_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_argmin(toptr, fromptr, parents, lenparents, outlength):
        for k in range(outlength):
            toptr[k] = -1
        for i in range(lenparents):
            parent = parents[i]
            if (toptr[parent] == -1) or (fromptr[i] < fromptr[toptr[parent]]):
                toptr[parent] = i

## awkward_reduce_argmin_bool_64

awkward_reduce_argmin_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_argmin_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for k in range(outlength):
            toptr[k] = -1
        for i in range(lenparents):
            parent = parents[i]
            if (toptr[parent] == -1) or ((fromptr[i] != 0) < (fromptr[toptr[parent]] != 0)):
                toptr[parent] = i

## awkward_reduce_argmin_complex

awkward_reduce_argmin_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_argmin_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_count_64

awkward_reduce_count_64(toptr: List[int64_t], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_count_64(toptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 0
        for i in range(lenparents):
            toptr[parents[i]] = toptr[parents[i]] + 1

## awkward_reduce_countnonzero

awkward_reduce_countnonzero_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_uint8_64(toptr: List[int64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_uint16_64(toptr: List[int64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_uint32_64(toptr: List[int64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_uint64_64(toptr: List[int64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_float32_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_float64_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_countnonzero(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 0
        for i in range(lenparents):
            toptr[parents[i]] += fromptr[i] != 0

## awkward_reduce_countnonzero_complex

awkward_reduce_countnonzero_complex64_64(toptr: List[int64_t], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_countnonzero_complex128_64(toptr: List[int64_t], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_max

awkward_reduce_max_int8_int8_64(toptr: List[int8_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int8_t)

awkward_reduce_max_int16_int16_64(toptr: List[int16_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int16_t)

awkward_reduce_max_int32_int32_64(toptr: List[int32_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int32_t)

awkward_reduce_max_int64_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int64_t)

awkward_reduce_max_uint8_uint8_64(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint8_t)

awkward_reduce_max_uint16_uint16_64(toptr: List[uint16_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint16_t)

awkward_reduce_max_uint32_uint32_64(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint32_t)

awkward_reduce_max_uint64_uint64_64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint64_t)

awkward_reduce_max_float32_float32_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)

awkward_reduce_max_float64_float64_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: double)

    def awkward_reduce_max(toptr, fromptr, parents, lenparents, outlength, identity):
        for i in range(outlength):
            toptr[i] = identity
        for i in range(lenparents):
            x = fromptr[i]
            toptr[parents[i]] = x if x > toptr[parents[i]] else toptr[parents[i]]

## awkward_reduce_max_complex

awkward_reduce_max_complex64_complex64_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)

awkward_reduce_max_complex128_complex128_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: double)

## awkward_reduce_min

awkward_reduce_min_int8_int8_64(toptr: List[int8_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int8_t)

awkward_reduce_min_int16_int16_64(toptr: List[int16_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int16_t)

awkward_reduce_min_int32_int32_64(toptr: List[int32_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int32_t)

awkward_reduce_min_int64_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: int64_t)

awkward_reduce_min_uint8_uint8_64(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint8_t)

awkward_reduce_min_uint16_uint16_64(toptr: List[uint16_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint16_t)

awkward_reduce_min_uint32_uint32_64(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint32_t)

awkward_reduce_min_uint64_uint64_64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: uint64_t)

awkward_reduce_min_float32_float32_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)

awkward_reduce_min_float64_float64_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: double)

    def awkward_reduce_min(toptr, fromptr, parents, lenparents, outlength, identity):
        for i in range(outlength):
            toptr[i] = identity
        for i in range(lenparents):
            x = fromptr[i]
            toptr[parents[i]] = x if x < toptr[parents[i]] else toptr[parents[i]]

## awkward_reduce_min_complex

awkward_reduce_min_complex64_complex64_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: float)

awkward_reduce_min_complex128_complex128_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t, identity: double)

## awkward_reduce_prod

awkward_reduce_prod_int32_int8_64(toptr: List[int32_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int32_int16_64(toptr: List[int32_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int32_int32_64(toptr: List[int32_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int64_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int64_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int64_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_int64_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint32_uint8_64(toptr: List[uint32_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint32_uint16_64(toptr: List[uint32_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint32_uint32_64(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint64_uint8_64(toptr: List[uint64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint64_uint16_64(toptr: List[uint64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint64_uint32_64(toptr: List[uint64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_uint64_uint64_64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_float32_float32_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_float64_float64_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_prod(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = float(1)
        for i in range(lenparents):
            toptr[parents[i]] *= float(fromptr[i])

## awkward_reduce_prod_complex

awkward_reduce_prod_complex64_complex64_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_complex128_complex128_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_prod_bool

awkward_reduce_prod_bool_bool_64(toptr: List[bool], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_int8_64(toptr: List[bool], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_int16_64(toptr: List[bool], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_int32_64(toptr: List[bool], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_int64_64(toptr: List[bool], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_uint8_64(toptr: List[bool], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_uint16_64(toptr: List[bool], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_uint32_64(toptr: List[bool], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_uint64_64(toptr: List[bool], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_float32_64(toptr: List[bool], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_float64_64(toptr: List[bool], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_prod_bool(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = True
        for i in range(lenparents):
            toptr[parents[i]] &= fromptr[i] != 0

## awkward_reduce_prod_bool_complex

awkward_reduce_prod_bool_complex64_64(toptr: List[bool], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_prod_bool_complex128_64(toptr: List[bool], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_prod_int32_bool_64

awkward_reduce_prod_int32_bool_64(toptr: List[int32_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_prod_int32_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 1
        for i in range(lenparents):
            toptr[parents[i]] *= fromptr[i] != 0

## awkward_reduce_prod_int64_bool_64

awkward_reduce_prod_int64_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_prod_int64_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 1
        for i in range(lenparents):
            toptr[parents[i]] *= fromptr[i] != 0

## awkward_reduce_sum

awkward_reduce_sum_int32_int8_64(toptr: List[int32_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int32_int16_64(toptr: List[int32_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int32_int32_64(toptr: List[int32_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int64_int8_64(toptr: List[int64_t], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int64_int16_64(toptr: List[int64_t], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int64_int32_64(toptr: List[int64_t], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_int64_int64_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint32_uint8_64(toptr: List[uint32_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint32_uint16_64(toptr: List[uint32_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint32_uint32_64(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint64_uint8_64(toptr: List[uint64_t], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint64_uint16_64(toptr: List[uint64_t], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint64_uint32_64(toptr: List[uint64_t], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_uint64_uint64_64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_float32_float32_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_float64_float64_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_sum(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = float(0)
        for i in range(lenparents):
            toptr[parents[i]] += float(fromptr[i])

## awkward_reduce_sum_complex

awkward_reduce_sum_complex64_complex64_64(toptr: List[float], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_complex128_complex128_64(toptr: List[double], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_sum_bool

awkward_reduce_sum_bool_bool_64(toptr: List[bool], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_int8_64(toptr: List[bool], fromptr: Const[List[int8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_int16_64(toptr: List[bool], fromptr: Const[List[int16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_int32_64(toptr: List[bool], fromptr: Const[List[int32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_int64_64(toptr: List[bool], fromptr: Const[List[int64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_uint8_64(toptr: List[bool], fromptr: Const[List[uint8_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_uint16_64(toptr: List[bool], fromptr: Const[List[uint16_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_uint32_64(toptr: List[bool], fromptr: Const[List[uint32_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_uint64_64(toptr: List[bool], fromptr: Const[List[uint64_t]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_float32_64(toptr: List[bool], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_float64_64(toptr: List[bool], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_sum_bool(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = False
        for i in range(lenparents):
            toptr[parents[i]] |= fromptr[i] != 0

## awkward_reduce_sum_bool_complex

awkward_reduce_sum_bool_complex64_64(toptr: List[bool], fromptr: Const[List[float]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

awkward_reduce_sum_bool_complex128_64(toptr: List[bool], fromptr: Const[List[double]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

## awkward_reduce_sum_int32_bool_64

awkward_reduce_sum_int32_bool_64(toptr: List[int32_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_sum_int32_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 0
        for i in range(lenparents):
            toptr[parents[i]] += fromptr[i] != 0

## awkward_reduce_sum_int64_bool_64

awkward_reduce_sum_int64_bool_64(toptr: List[int64_t], fromptr: Const[List[bool]], parents: Const[List[int64_t]], lenparents: int64_t, outlength: int64_t)

    def awkward_reduce_sum_int64_bool_64(toptr, fromptr, parents, lenparents, outlength):
        for i in range(outlength):
            toptr[i] = 0
        for i in range(lenparents):
            toptr[parents[i]] += fromptr[i] != 0

## awkward_regularize_arrayslice

awkward_regularize_arrayslice_64(flatheadptr: List[int64_t], lenflathead: int64_t, length: int64_t)

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

## awkward_slicearray_ravel

awkward_slicearray_ravel_64(toptr: List[int64_t], fromptr: Const[List[int64_t]], ndim: int64_t, shape: Const[List[int64_t]], strides: Const[List[int64_t]])

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

## awkward_slicemissing_check_same

awkward_slicemissing_check_same(same: List[bool], bytemask: Const[List[int8_t]], missingindex: Const[List[int64_t]], length: int64_t)

    def awkward_slicemissing_check_same(same, bytemask, missingindex, length):
        same[0] = True
        for i in range(length):
            left = bytemask[i] != 0
            right = missingindex[i] < 0
            if left != right:
                same[0] = False
                return

## awkward_quick_sort

awkward_quick_sort_bool(tmpptr: List[bool], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_int8(tmpptr: List[int8_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_int16(tmpptr: List[int16_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_int32(tmpptr: List[int32_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_int64(tmpptr: List[int64_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_uint8(tmpptr: List[uint8_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_uint16(tmpptr: List[uint16_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_uint32(tmpptr: List[uint32_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_uint64(tmpptr: List[uint64_t], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_float32(tmpptr: List[float], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

awkward_quick_sort_float64(tmpptr: List[double], tmpbeg: List[int64_t], tmpend: List[int64_t], fromstarts: Const[List[int64_t]], fromstops: Const[List[int64_t]], ascending: bool, length: int64_t, maxlevels: int64_t)

    Insert Python definition here

## awkward_sort

awkward_sort_bool(toptr: List[bool], fromptr: Const[List[bool]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_int8(toptr: List[int8_t], fromptr: Const[List[int8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_int16(toptr: List[int16_t], fromptr: Const[List[int16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_int32(toptr: List[int32_t], fromptr: Const[List[int32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_uint8(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_uint16(toptr: List[uint16_t], fromptr: Const[List[uint16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_uint32(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_uint64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_float32(toptr: List[float], fromptr: Const[List[float]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

awkward_sort_float64(toptr: List[double], fromptr: Const[List[double]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t, ascending: bool, stable: bool)

    Insert Python definition here

## awkward_sort_ascending

awkward_sort_ascending_bool(toptr: List[bool], fromptr: Const[List[bool]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_int8(toptr: List[int8_t], fromptr: Const[List[int8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_int16(toptr: List[int16_t], fromptr: Const[List[int16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_int32(toptr: List[int32_t], fromptr: Const[List[int32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_int64(toptr: List[int64_t], fromptr: Const[List[int64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_uint8(toptr: List[uint8_t], fromptr: Const[List[uint8_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_uint16(toptr: List[uint16_t], fromptr: Const[List[uint16_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_uint32(toptr: List[uint32_t], fromptr: Const[List[uint32_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_uint64(toptr: List[uint64_t], fromptr: Const[List[uint64_t]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_float32(toptr: List[float], fromptr: Const[List[float]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

awkward_sort_ascending_float64(toptr: List[double], fromptr: Const[List[double]], length: int64_t, offsets: Const[List[int64_t]], offsetslength: int64_t, parentslength: int64_t)

    Insert Python definition here

## awkward_unique

awkward_unique_bool(toptr: List[bool], length: int64_t, tolength: List[int64_t])

awkward_unique_int8(toptr: List[int8_t], length: int64_t, tolength: List[int64_t])

awkward_unique_int16(toptr: List[int16_t], length: int64_t, tolength: List[int64_t])

awkward_unique_int32(toptr: List[int32_t], length: int64_t, tolength: List[int64_t])

awkward_unique_int64(toptr: List[int64_t], length: int64_t, tolength: List[int64_t])

awkward_unique_uint8(toptr: List[uint8_t], length: int64_t, tolength: List[int64_t])

awkward_unique_uint16(toptr: List[uint16_t], length: int64_t, tolength: List[int64_t])

awkward_unique_uint32(toptr: List[uint32_t], length: int64_t, tolength: List[int64_t])

awkward_unique_uint64(toptr: List[uint64_t], length: int64_t, tolength: List[int64_t])

awkward_unique_float32(toptr: List[float], length: int64_t, tolength: List[int64_t])

awkward_unique_float64(toptr: List[double], length: int64_t, tolength: List[int64_t])

    Insert Python definition here

## awkward_unique_copy

awkward_unique_copy_bool(fromptr: Const[List[bool]], toptr: List[bool], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_int8(fromptr: Const[List[int8_t]], toptr: List[int8_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_int16(fromptr: Const[List[int16_t]], toptr: List[int16_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_int32(fromptr: Const[List[int32_t]], toptr: List[int32_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_int64(fromptr: Const[List[int64_t]], toptr: List[int64_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_uint8(fromptr: Const[List[uint8_t]], toptr: List[uint8_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_uint16(fromptr: Const[List[uint16_t]], toptr: List[uint16_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_uint32(fromptr: Const[List[uint32_t]], toptr: List[uint32_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_uint64(fromptr: Const[List[uint64_t]], toptr: List[uint64_t], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_float32(fromptr: Const[List[float]], toptr: List[float], length: int64_t, tolength: List[int64_t])

awkward_unique_copy_float64(fromptr: Const[List[double]], toptr: List[double], length: int64_t, tolength: List[int64_t])

    Insert Python definition here

## awkward_unique_offsets

awkward_unique_offsets_int8(tooffsets: List[int8_t], length: int64_t, fromoffsets: Const[List[int64_t]], starts: Const[List[int64_t]], startslength: int64_t)

awkward_unique_offsets_int16(tooffsets: List[int16_t], length: int64_t, fromoffsets: Const[List[int64_t]], starts: Const[List[int64_t]], startslength: int64_t)

awkward_unique_offsets_int32(tooffsets: List[int32_t], length: int64_t, fromoffsets: Const[List[int64_t]], starts: Const[List[int64_t]], startslength: int64_t)

awkward_unique_offsets_int64(tooffsets: List[int64_t], length: int64_t, fromoffsets: Const[List[int64_t]], starts: Const[List[int64_t]], startslength: int64_t)

    Insert Python definition here

## awkward_unique_ranges

awkward_unique_ranges_bool(toptr: List[bool], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_int8(toptr: List[int8_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_int16(toptr: List[int16_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_int32(toptr: List[int32_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_int64(toptr: List[int64_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_uint8(toptr: List[uint8_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_uint16(toptr: List[uint16_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_uint32(toptr: List[uint32_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_uint64(toptr: List[uint64_t], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_float32(toptr: List[float], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

awkward_unique_ranges_float64(toptr: List[double], length: int64_t, fromoffsets: Const[List[int64_t]], offsetslength: int64_t, tooffsets: List[int64_t])

    Insert Python definition here

## awkward_sorting_ranges

awkward_sorting_ranges(toindex: List[int64_t], tolength: int64_t, parents: Const[List[int64_t]], parentslength: int64_t)

    Insert Python definition here

## awkward_sorting_ranges_length

awkward_sorting_ranges_length(tolength: List[int64_t], parents: Const[List[int64_t]], parentslength: int64_t)

    Insert Python definition here

## awkward_one_mask

awkward_one_mask8(tomask: List[int8_t], length: int64_t)

    def awkward_one_mask(tomask, length):
        for i in range(length):
            tomask[i] = 1

## awkward_zero_mask

awkward_zero_mask8(tomask: List[int8_t], length: int64_t)

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