Kernel interface and specification

All array manipulation that is not performed by NumPy/CuPy/etc. is executed in Awkward Array’s low-level “kernels.” These functions communicate entirely by side-effects, manipulating already-allocated arrays, and therefore can be implemented with a pure C interface. They’re called “kernels” because their signatures are similar to GPU kernels, to make them easier to port to GPUs and similar devices.

All of the kernel functions that Awkward Array uses are documented below. These are internal details of Awkward Array, subject to change at any time, not a public API. The reason that we are documenting the API is to ensure compatibility between the primary CPU-bound kernels and their equivalents, ported to GPUs (and similar devices). The definitions below are expressed in Python code, but the implementations used by Awkward Array are compiled.

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_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_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_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_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_local_preparenext

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_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_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_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_drop_none_indexes

awkward_ListOffsetArray_drop_none_indexes_32(tooffsets: List[int32_t], noneindexes: Const[List[int32_t]], fromoffsets: Const[List[int32_t]], length_offsets: int64_t, length_indexes: int64_t)

awkward_ListOffsetArray_drop_none_indexes_64(tooffsets: List[int64_t], noneindexes: Const[List[int64_t]], fromoffsets: Const[List[int64_t]], length_offsets: int64_t, length_indexes: int64_t)

def awkward_ListOffsetArray_drop_none_indexes(tooffsets, noneindexes, fromoffsets, length_offsets, length_indexes):
    nr_of_nones, offset1, offset2 = 0, 0, 0
    for i in range(length_offsets):
      offset2 = fromoffsets[i]
      for j in range(offset1, offset2):
        if (noneindexes[j] < 0):
          nr_of_nones+=1
      tooffsets[i] = fromoffsets[i] - nr_of_nones
      offset1 = offset2

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_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_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_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_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_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_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_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_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