src/cpu-kernels/reducers.cpp

awkward_reduce_count_64
----------------------------------------------------

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


awkward_reduce_countnonzero
----------------------------------------------------

for IN in (bool, int, float):

    def awkward_reduce_countnonzero(
        toptr: List[int],
        fromptr: List[IN],
        fromptroffset: int,
        parents: List[int],
        parentsoffset: int,
        lenparents: int,
        outlength: int,
    ):
        for i in range(outlength):
            toptr[i] = 0
        for i in range(lenparents):
            toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
        return


awkward_reduce_countnonzero_bool_64
----------------------------------------------------

def awkward_reduce_countnonzero_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_int8_64
----------------------------------------------------

def awkward_reduce_countnonzero_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_uint8_64
----------------------------------------------------

def awkward_reduce_countnonzero_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_int16_64
----------------------------------------------------

def awkward_reduce_countnonzero_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_uint16_64
----------------------------------------------------

def awkward_reduce_countnonzero_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_int32_64
----------------------------------------------------

def awkward_reduce_countnonzero_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_uint32_64
----------------------------------------------------

def awkward_reduce_countnonzero_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_int64_64
----------------------------------------------------

def awkward_reduce_countnonzero_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_uint64_64
----------------------------------------------------

def awkward_reduce_countnonzero_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_float32_64
----------------------------------------------------

def awkward_reduce_countnonzero_float32_64(
    toptr: List[int],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_countnonzero_float64_64
----------------------------------------------------

def awkward_reduce_countnonzero_float64_64(
    toptr: List[int],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_countnonzero(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum
----------------------------------------------------

for OUT in (int, float):
    for IN in (int, float):

        def awkward_reduce_sum(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
        ):
            for i in range(outlength):
                toptr[i] = int(0)
            for i in range(lenparents):
                toptr[parents[parentsoffset + i]] = int(fromptr[fromptroffset + i])
            return


awkward_reduce_sum_int64_bool_64
----------------------------------------------------

def awkward_reduce_sum_int64_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = 0
    for i in range(lenparents):
        toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
    return


awkward_reduce_sum_int64_int8_64
----------------------------------------------------

def awkward_reduce_sum_int64_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint64_uint8_64
----------------------------------------------------

def awkward_reduce_sum_uint64_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int64_int16_64
----------------------------------------------------

def awkward_reduce_sum_int64_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint64_uint16_64
----------------------------------------------------

def awkward_reduce_sum_uint64_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int64_int32_64
----------------------------------------------------

def awkward_reduce_sum_int64_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint64_uint32_64
----------------------------------------------------

def awkward_reduce_sum_uint64_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int64_int64_64
----------------------------------------------------

def awkward_reduce_sum_int64_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint64_uint64_64
----------------------------------------------------

def awkward_reduce_sum_uint64_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_float32_float32_64
----------------------------------------------------

def awkward_reduce_sum_float32_float32_64(
    toptr: List[float],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_float64_float64_64
----------------------------------------------------

def awkward_reduce_sum_float64_float64_64(
    toptr: List[double],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int32_bool_64
----------------------------------------------------

def awkward_reduce_sum_int32_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = 0
    for i in range(lenparents):
        toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
    return


awkward_reduce_sum_int32_int8_64
----------------------------------------------------

def awkward_reduce_sum_int32_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint32_uint8_64
----------------------------------------------------

def awkward_reduce_sum_uint32_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int32_int16_64
----------------------------------------------------

def awkward_reduce_sum_int32_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint32_uint16_64
----------------------------------------------------

def awkward_reduce_sum_uint32_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_int32_int32_64
----------------------------------------------------

def awkward_reduce_sum_int32_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_uint32_uint32_64
----------------------------------------------------

def awkward_reduce_sum_uint32_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool
----------------------------------------------------

for IN in (bool, int, float):

    def awkward_reduce_sum_bool(
        toptr: List[bool],
        fromptr: List[IN],
        fromptroffset: int,
        parents: List[int],
        parentsoffset: int,
        lenparents: int,
        outlength: int,
    ):
        for i in range(outlength):
            toptr[i] = int(0)
        for i in range(lenparents):
            toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
        return


awkward_reduce_sum_bool_bool_64
----------------------------------------------------

def awkward_reduce_sum_bool_bool_64(
    toptr: List[bool],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_int8_64
----------------------------------------------------

def awkward_reduce_sum_bool_int8_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_uint8_64
----------------------------------------------------

def awkward_reduce_sum_bool_uint8_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_int16_64
----------------------------------------------------

def awkward_reduce_sum_bool_int16_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_uint16_64
----------------------------------------------------

def awkward_reduce_sum_bool_uint16_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_int32_64
----------------------------------------------------

def awkward_reduce_sum_bool_int32_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_uint32_64
----------------------------------------------------

def awkward_reduce_sum_bool_uint32_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_int64_64
----------------------------------------------------

def awkward_reduce_sum_bool_int64_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_uint64_64
----------------------------------------------------

def awkward_reduce_sum_bool_uint64_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_float32_64
----------------------------------------------------

def awkward_reduce_sum_bool_float32_64(
    toptr: List[bool],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_sum_bool_float64_64
----------------------------------------------------

def awkward_reduce_sum_bool_float64_64(
    toptr: List[bool],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_sum_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod
----------------------------------------------------

for OUT in (int, float):
    for IN in (int, float):

        def awkward_reduce_prod(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
        ):
            for i in range(outlength):
                toptr[i] = int(1)
            for i in range(lenparents):
                toptr[parents[parentsoffset + i]] = int(fromptr[fromptroffset + i])
            return


awkward_reduce_prod_int64_bool_64
----------------------------------------------------

def awkward_reduce_prod_int64_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = 1
    for i in range(lenparents):
        toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
    return


awkward_reduce_prod_int64_int8_64
----------------------------------------------------

def awkward_reduce_prod_int64_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint64_uint8_64
----------------------------------------------------

def awkward_reduce_prod_uint64_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int64_int16_64
----------------------------------------------------

def awkward_reduce_prod_int64_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint64_uint16_64
----------------------------------------------------

def awkward_reduce_prod_uint64_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int64_int32_64
----------------------------------------------------

def awkward_reduce_prod_int64_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint64_uint32_64
----------------------------------------------------

def awkward_reduce_prod_uint64_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int64_int64_64
----------------------------------------------------

def awkward_reduce_prod_int64_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint64_uint64_64
----------------------------------------------------

def awkward_reduce_prod_uint64_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_float32_float32_64
----------------------------------------------------

def awkward_reduce_prod_float32_float32_64(
    toptr: List[float],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_float64_float64_64
----------------------------------------------------

def awkward_reduce_prod_float64_float64_64(
    toptr: List[double],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int32_bool_64
----------------------------------------------------

def awkward_reduce_prod_int32_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = 1
    for i in range(lenparents):
        toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
    return


awkward_reduce_prod_int32_int8_64
----------------------------------------------------

def awkward_reduce_prod_int32_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint32_uint8_64
----------------------------------------------------

def awkward_reduce_prod_uint32_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int32_int16_64
----------------------------------------------------

def awkward_reduce_prod_int32_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint32_uint16_64
----------------------------------------------------

def awkward_reduce_prod_uint32_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_int32_int32_64
----------------------------------------------------

def awkward_reduce_prod_int32_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_uint32_uint32_64
----------------------------------------------------

def awkward_reduce_prod_uint32_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool
----------------------------------------------------

for IN in (bool, int, float):

    def awkward_reduce_prod_bool(
        toptr: List[bool],
        fromptr: List[IN],
        fromptroffset: int,
        parents: List[int],
        parentsoffset: int,
        lenparents: int,
        outlength: int,
    ):
        for i in range(outlength):
            toptr[i] = int(1)
        for i in range(lenparents):
            toptr[parents[parentsoffset + i]] = fromptr[fromptroffset + i] != 0
        return


awkward_reduce_prod_bool_bool_64
----------------------------------------------------

def awkward_reduce_prod_bool_bool_64(
    toptr: List[bool],
    fromptr: List[bool],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_int8_64
----------------------------------------------------

def awkward_reduce_prod_bool_int8_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_uint8_64
----------------------------------------------------

def awkward_reduce_prod_bool_uint8_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_int16_64
----------------------------------------------------

def awkward_reduce_prod_bool_int16_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_uint16_64
----------------------------------------------------

def awkward_reduce_prod_bool_uint16_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_int32_64
----------------------------------------------------

def awkward_reduce_prod_bool_int32_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_uint32_64
----------------------------------------------------

def awkward_reduce_prod_bool_uint32_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_int64_64
----------------------------------------------------

def awkward_reduce_prod_bool_int64_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_uint64_64
----------------------------------------------------

def awkward_reduce_prod_bool_uint64_64(
    toptr: List[bool],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_float32_64
----------------------------------------------------

def awkward_reduce_prod_bool_float32_64(
    toptr: List[bool],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_prod_bool_float64_64
----------------------------------------------------

def awkward_reduce_prod_bool_float64_64(
    toptr: List[bool],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_prod_int(
        toptr, fromptr, fromptroffset, parents, parentsoffset, lenparents, outlength
    )


awkward_reduce_min
----------------------------------------------------

for OUT in (int, float):
    for IN in (int, float):

        def awkward_reduce_min(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
            identity: int,
        ):
            for i in range(outlength):
                toptr[i] = identity
            for i in range(lenparents):
                x = fromptr[fromptroffset + i]
                toptr[parents[parentsoffset + i]] = (
                    x
                    if x < toptr[parents[parentsoffset + i]]
                    else toptr[parents[parentsoffset + i]]
                )
            return


awkward_reduce_min_int8_int8_64
----------------------------------------------------

def awkward_reduce_min_int8_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_uint8_uint8_64
----------------------------------------------------

def awkward_reduce_min_uint8_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_int16_int16_64
----------------------------------------------------

def awkward_reduce_min_int16_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_uint16_uint16_64
----------------------------------------------------

def awkward_reduce_min_uint16_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_int32_int32_64
----------------------------------------------------

def awkward_reduce_min_int32_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_uint32_uint32_64
----------------------------------------------------

def awkward_reduce_min_uint32_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_int64_int64_64
----------------------------------------------------

def awkward_reduce_min_int64_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_uint64_uint64_64
----------------------------------------------------

def awkward_reduce_min_uint64_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_float32_float32_64
----------------------------------------------------

def awkward_reduce_min_float32_float32_64(
    toptr: List[float],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: float,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_min_float64_float64_64
----------------------------------------------------

def awkward_reduce_min_float64_float64_64(
    toptr: List[double],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: double,
):
    return awkward_reduce_min(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max
----------------------------------------------------

for OUT in (int, float):
    for IN in (int, float):

        def awkward_reduce_max(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
            identity: int,
        ):
            for i in range(outlength):
                toptr[i] = identity
            for i in range(lenparents):
                x = fromptr[fromptroffset + i]
                toptr[parents[parentsoffset + i]] = (
                    x
                    if x > toptr[parents[parentsoffset + i]]
                    else toptr[parents[parentsoffset + i]]
                )
            return


awkward_reduce_max_int8_int8_64
----------------------------------------------------

def awkward_reduce_max_int8_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_uint8_uint8_64
----------------------------------------------------

def awkward_reduce_max_uint8_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_int16_int16_64
----------------------------------------------------

def awkward_reduce_max_int16_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_uint16_uint16_64
----------------------------------------------------

def awkward_reduce_max_uint16_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_int32_int32_64
----------------------------------------------------

def awkward_reduce_max_int32_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_uint32_uint32_64
----------------------------------------------------

def awkward_reduce_max_uint32_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_int64_int64_64
----------------------------------------------------

def awkward_reduce_max_int64_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_uint64_uint64_64
----------------------------------------------------

def awkward_reduce_max_uint64_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: int,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_float32_float32_64
----------------------------------------------------

def awkward_reduce_max_float32_float32_64(
    toptr: List[float],
    fromptr: List[float],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: float,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_max_float64_float64_64
----------------------------------------------------

def awkward_reduce_max_float64_float64_64(
    toptr: List[double],
    fromptr: List[double],
    fromptroffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
    identity: double,
):
    return awkward_reduce_max(
        toptr,
        fromptr,
        fromptroffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
        identity,
    )


awkward_reduce_argmin
----------------------------------------------------

for OUT in int:
    for IN in (int, float):

        def awkward_reduce_argmin(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            starts: List[int],
            startsoffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
        ):
            for i in range(outlength):
                toptr[i] = -1
            for i in range(lenparents):
                parent = parents[parentsoffset + i]
                start = starts[parent]
                if (toptr[parent] == -1) or (
                    fromptr[fromptroffset + i]
                    < fromptr[(fromptroffset + toptr[parent]) + start]
                ):
                    toptr[parent] = i - start
            return


awkward_reduce_argmin_bool_64
----------------------------------------------------

def awkward_reduce_argmin_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = -1
    for i in range(lenparents):
        parent = parents[parentsoffset + i]
        start = starts[parent]
        if (toptr[parent] == -1) or (
            (fromptr[fromptroffset + i] != 0)
            < (fromptr[(fromptroffset + toptr[parent]) + start] != 0)
        ):
            toptr[parent] = i - start
    return


awkward_reduce_argmin_int8_64
----------------------------------------------------

def awkward_reduce_argmin_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_uint8_64
----------------------------------------------------

def awkward_reduce_argmin_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_int16_64
----------------------------------------------------

def awkward_reduce_argmin_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_uint16_64
----------------------------------------------------

def awkward_reduce_argmin_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_int32_64
----------------------------------------------------

def awkward_reduce_argmin_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_uint32_64
----------------------------------------------------

def awkward_reduce_argmin_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_int64_64
----------------------------------------------------

def awkward_reduce_argmin_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_uint64_64
----------------------------------------------------

def awkward_reduce_argmin_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_float32_64
----------------------------------------------------

def awkward_reduce_argmin_float32_64(
    toptr: List[int],
    fromptr: List[float],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmin_float64_64
----------------------------------------------------

def awkward_reduce_argmin_float64_64(
    toptr: List[int],
    fromptr: List[double],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmin(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax
----------------------------------------------------

for OUT in int:
    for IN in (int, float):

        def awkward_reduce_argmax(
            toptr: List[OUT],
            fromptr: List[IN],
            fromptroffset: int,
            starts: List[int],
            startsoffset: int,
            parents: List[int],
            parentsoffset: int,
            lenparents: int,
            outlength: int,
        ):
            for i in range(outlength):
                toptr[i] = -1
            for i in range(lenparents):
                parent = parents[parentsoffset + i]
                start = starts[parent]
                if (toptr[parent] == -1) or fromptr[
                    (fromptroffset + toptr[parent]) + start
                ]:
                    toptr[parent] = i - start
            return


awkward_reduce_argmax_bool_64
----------------------------------------------------

def awkward_reduce_argmax_bool_64(
    toptr: List[int],
    fromptr: List[bool],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = -1
    for i in range(lenparents):
        parent = parents[parentsoffset + i]
        start = starts[parent]
        if (toptr[parent] == -1) or (
            (fromptr[fromptroffset + i] != 0)
            > (fromptr[(fromptroffset + toptr[parent]) + start] != 0)
        ):
            toptr[parent] = i - start
    return


awkward_reduce_argmax_int8_64
----------------------------------------------------

def awkward_reduce_argmax_int8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_uint8_64
----------------------------------------------------

def awkward_reduce_argmax_uint8_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_int16_64
----------------------------------------------------

def awkward_reduce_argmax_int16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_uint16_64
----------------------------------------------------

def awkward_reduce_argmax_uint16_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_int32_64
----------------------------------------------------

def awkward_reduce_argmax_int32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_uint32_64
----------------------------------------------------

def awkward_reduce_argmax_uint32_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_int64_64
----------------------------------------------------

def awkward_reduce_argmax_int64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_uint64_64
----------------------------------------------------

def awkward_reduce_argmax_uint64_64(
    toptr: List[int],
    fromptr: List[int],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_float32_64
----------------------------------------------------

def awkward_reduce_argmax_float32_64(
    toptr: List[int],
    fromptr: List[float],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_reduce_argmax_float64_64
----------------------------------------------------

def awkward_reduce_argmax_float64_64(
    toptr: List[int],
    fromptr: List[double],
    fromptroffset: int,
    starts: List[int],
    startsoffset: int,
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    return awkward_reduce_argmax(
        toptr,
        fromptr,
        fromptroffset,
        starts,
        startsoffset,
        parents,
        parentsoffset,
        lenparents,
        outlength,
    )


awkward_content_reduce_zeroparents_64
----------------------------------------------------

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


awkward_listoffsetarray_reduce_global_startstop_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_global_startstop_64(
    globalstart: List[int],
    globalstop: List[int],
    offsets: List[int],
    offsetsoffset: int,
    length: int,
):
    globalstart = offsets[offsetsoffset + 0]
    globalstop = offsets[offsetsoffset + length]
    return


awkward_listoffsetarray_reduce_nonlocal_maxcount_offsetscopy_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_nonlocal_maxcount_offsetscopy_64(
    maxcount: List[int],
    offsetscopy: List[int],
    offsets: List[int],
    offsetsoffset: int,
    length: int,
):
    maxcount = 0
    offsetscopy[0] = offsets[offsetsoffset + 0]
    for i in range(length):
        count = offsets[(offsetsoffset + i) + 1] - offsets[offsetsoffset + i]
        if maxcount < count:
            maxcount = count
        offsetscopy[i + 1] = offsets[(offsetsoffset + i) + 1]
    return


awkward_listoffsetarray_reduce_nonlocal_preparenext_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_nonlocal_preparenext_64(
    nextcarry: List[int],
    nextparents: List[int],
    nextlen: int,
    maxnextparents: List[int],
    distincts: List[int],
    distinctslen: int,
    offsetscopy: List[int],
    offsets: List[int],
    offsetsoffset: int,
    length: int,
    parents: List[int],
    parentsoffset: int,
    maxcount: int,
):
    maxnextparents = 0
    for i in range(distinctslen):
        distincts[i] = -1
    k = 0
    while k < nextlen:
        j = 0
        for i in range(length):
            if offsetscopy[i] < offsets[(offsetsoffset + i) + 1]:
                count = offsets[(offsetsoffset + i) + 1] - offsets[offsetsoffset + i]
                diff = offsetscopy[i] - offsets[offsetsoffset + i]
                parent = parents[parentsoffset + i]
                nextcarry[k] = offsetscopy[i]
                nextparents[k] = (parent * maxcount) + diff
                if maxnextparents < nextparents[k]:
                    maxnextparents = nextparents[k]
                if distincts[nextparents[k]] == -1:
                    distincts[nextparents[k]] = j
                    j = j + 1
                k = k + 1
                offsetscopy[i] = offsetscopy[i] + 1
    return


awkward_listoffsetarray_reduce_nonlocal_nextstarts_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_nonlocal_nextstarts_64(
    nextstarts: List[int], nextparents: List[int], nextlen: int
):
    lastnextparent = -1
    for k in range(nextlen):
        if nextparents[k] != lastnextparent:
            nextstarts[nextparents[k]] = k
        lastnextparent = nextparents[k]
    return


awkward_listoffsetarray_reduce_nonlocal_findgaps_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_nonlocal_findgaps_64(
    gaps: List[int], parents: List[int], parentsoffset: int, lenparents: int
):
    k = 0
    last = -1
    for i in range(lenparents):
        parent = parents[parentsoffset + i]
        if last < parent:
            gaps[k] = parent - last
            k = k + 1
            last = parent
    return


awkward_listoffsetarray_reduce_nonlocal_outstartsstops_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_nonlocal_outstartsstops_64(
    outstarts: List[int],
    outstops: List[int],
    distincts: List[int],
    lendistincts: int,
    gaps: List[int],
    outlength: int,
):
    j = 0
    k = 0
    maxdistinct = -1
    for i in range(lendistincts):
        if maxdistinct < distincts[i]:
            maxdistinct = distincts[i]
            for gappy in range(gaps[j]):
                outstarts[k] = i
                outstops[k] = i
                k = k + 1
            j = j + 1
        if distincts[i] != -1:
            outstops[k - 1] = i + 1
    while k < outlength:
        outstarts[k] = lendistincts + 1
        outstops[k] = lendistincts + 1
        k = k + 1
    return


awkward_listoffsetarray_reduce_local_nextparents_64
----------------------------------------------------

def awkward_listoffsetarray_reduce_local_nextparents_64(
    nextparents: List[int], offsets: List[int], offsetsoffset: int, length: int
):
    initialoffset = offsets[offsetsoffset]
    for i in range(length):
        j = offsets[offsetsoffset + i] - initialoffset
        while j < (offsets[(offsetsoffset + i) + 1] - initialoffset):
            nextparents[j] = i
            j = j + 1
    return


awkward_listoffsetarray_reduce_local_outoffsets_64
----------------------------------------------------

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

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


awkward_indexedarray_reduce_next_64
----------------------------------------------------

for T in int:

    def awkward_indexedarray_reduce_next_64(
        nextcarry: List[int],
        nextparents: List[int],
        outindex: List[int],
        index: List[T],
        indexoffset: int,
        parents: List[int],
        parentsoffset: int,
        length: int,
    ):
        k = 0
        for i in range(length):
            if index[indexoffset + i] >= 0:
                nextcarry[k] = index[indexoffset + i]
                nextparents[k] = parents[parentsoffset + i]
                outindex[i] = k
                k = k + 1
            else:
                outindex[i] = -1
        return


awkward_indexedarray32_reduce_next_64
----------------------------------------------------

def awkward_indexedarray32_reduce_next_64(
    nextcarry: List[int],
    nextparents: List[int],
    outindex: List[int],
    index: List[int],
    indexoffset: int,
    parents: List[int],
    parentsoffset: int,
    length: int,
):
    return awkward_indexedarray_reduce_next_64(
        nextcarry,
        nextparents,
        outindex,
        index,
        indexoffset,
        parents,
        parentsoffset,
        length,
    )


awkward_indexedarrayU32_reduce_next_64
----------------------------------------------------

def awkward_indexedarrayU32_reduce_next_64(
    nextcarry: List[int],
    nextparents: List[int],
    outindex: List[int],
    index: List[int],
    indexoffset: int,
    parents: List[int],
    parentsoffset: int,
    length: int,
):
    return awkward_indexedarray_reduce_next_64(
        nextcarry,
        nextparents,
        outindex,
        index,
        indexoffset,
        parents,
        parentsoffset,
        length,
    )


awkward_indexedarray64_reduce_next_64
----------------------------------------------------

def awkward_indexedarray64_reduce_next_64(
    nextcarry: List[int],
    nextparents: List[int],
    outindex: List[int],
    index: List[int],
    indexoffset: int,
    parents: List[int],
    parentsoffset: int,
    length: int,
):
    return awkward_indexedarray_reduce_next_64(
        nextcarry,
        nextparents,
        outindex,
        index,
        indexoffset,
        parents,
        parentsoffset,
        length,
    )


awkward_indexedarray_reduce_next_fix_offsets_64
----------------------------------------------------

def awkward_indexedarray_reduce_next_fix_offsets_64(
    outoffsets: List[int],
    starts: List[int],
    startsoffset: int,
    startslength: int,
    outindexlength: int,
):
    for i in range(startslength):
        outoffsets[i] = starts[startsoffset + i]
    outoffsets[startsoffset + startslength] = outindexlength
    return


awkward_numpyarray_reduce_mask_bytemaskedarray
----------------------------------------------------

def awkward_numpyarray_reduce_mask_bytemaskedarray(
    toptr: List[int],
    parents: List[int],
    parentsoffset: int,
    lenparents: int,
    outlength: int,
):
    for i in range(outlength):
        toptr[i] = 1
    for i in range(lenparents):
        toptr[parents[parentsoffset + i]] = 0
    return


awkward_bytemaskedarray_reduce_next_64
----------------------------------------------------

def awkward_bytemaskedarray_reduce_next_64(
    nextcarry: List[int],
    nextparents: List[int],
    outindex: List[int],
    mask: List[int],
    maskoffset: int,
    parents: List[int],
    parentsoffset: int,
    length: int,
    validwhen: bool,
):
    k = 0
    for i in range(length):
        if (mask[maskoffset + i] != 0) == validwhen:
            nextcarry[k] = i
            nextparents[k] = parents[parentsoffset + i]
            outindex[i] = k
            k = k + 1
        else:
            outindex[i] = -1
    return