kernel-specification.yml

kernels:
  - name: awkward_BitMaskedArray_to_ByteMaskedArray
    specializations:
      - name: awkward_BitMaskedArray_to_ByteMaskedArray
        args:
          - {name: tobytemask, type: "List[int8_t]", dir: out}
          - {name: frombitmask, type: "Const[List[uint8_t]]", dir: in, role: BitMaskedArray-mask}
          - {name: bitmasklength, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: BitMaskedArray-valid_when}
          - {name: lsb_order, type: "bool", dir: in, role: BitMaskedArray-lsb_order}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_BitMaskedArray_to_IndexedOptionArray
    specializations:
      - name: awkward_BitMaskedArray_to_IndexedOptionArray64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: frombitmask, type: "Const[List[uint8_t]]", dir: in, role: BitMaskedArray-mask}
          - {name: bitmasklength, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: BitMaskedArray-valid_when}
          - {name: lsb_order, type: "bool", dir: in, role: BitMaskedArray-lsb_order}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_getitem_carry
    specializations:
      - name: awkward_ByteMaskedArray_getitem_carry_64
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: frommask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: lenmask, type: "int64_t", dir: in, role: ByteMaskedArray-length}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ByteMaskedArray_getitem_carry(
          tomask, frommask, lenmask, fromcarry, lencarry
      ):
          for i in range(lencarry):
              if fromcarry[i] >= lenmask:
                  raise ValueError("index out of range")
              tomask[i] = frommask[fromcarry[i]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_getitem_nextcarry
    specializations:
      - name: awkward_ByteMaskedArray_getitem_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_getitem_nextcarry_outindex
    specializations:
      - name: awkward_ByteMaskedArray_getitem_nextcarry_outindex_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_mask
    specializations:
      - name: awkward_ByteMaskedArray_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: frommask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      def awkward_ByteMaskedArray_mask(tomask, frommask, length, validwhen):
          for i in range(length):
              tomask[i] = (frommask[i] != 0) != validwhen
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_numnull
    specializations:
      - name: awkward_ByteMaskedArray_numnull
        args:
          - {name: numnull, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_overlay_mask
    specializations:
      - name: awkward_ByteMaskedArray_overlay_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: theirmask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: mymask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray2-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_reduce_next_64
    specializations:
      - name: awkward_ByteMaskedArray_reduce_next_64
        args:
          - {name: nextcarry, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: reducer-mask}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: validwhen, type: "bool", dir: in, role: reducer-validwhen}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64
    specializations:
      - name: awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: reducer-mask}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: valid_when, type: "bool", dir: in, role: reducer-valid_when}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64
    specializations:
      - name: awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: reducer-mask}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: valid_when, type: "bool", dir: in, role: reducer-valid_when}
          - {name: shifts, type: "Const[List[int64_t]]", dir: in, role: reducer-shifts}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ByteMaskedArray_toIndexedOptionArray
    specializations:
      - name: awkward_ByteMaskedArray_toIndexedOptionArray64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: validwhen, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      def awkward_ByteMaskedArray_toIndexedOptionArray(toindex, mask, length, validwhen):
          for i in range(length):
              toindex[i] = i if (mask[i] != 0) == validwhen else -1
    automatic-tests: true
    manual-tests: []

  - name: awkward_Content_getitem_next_missing_jagged_getmaskstartstop
    specializations:
      - name: awkward_Content_getitem_next_missing_jagged_getmaskstartstop
        args:
          - {name: index_in, type: "List[int64_t]", dir: in, role: IndexedArray-index}
          - {name: offsets_in, type: "List[int64_t]", dir: in, role: ListOffsetArray-offsets}
          - {name: mask_out, type: "List[int64_t]", dir: out}
          - {name: starts_out, type: "List[int64_t]", dir: out}
          - {name: stops_out, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities32_to_Identities64
    specializations:
      - name: awkward_Identities32_to_Identities64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: width, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities32_to_Identities64(toptr, fromptr, length, width):
          for i in range(length * width):
              toptr[i] = int(fromptr[i])
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_extend
    specializations:
      - name: awkward_Identities32_extend
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: tolength, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_extend
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: tolength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_extend(toptr, fromptr, fromlength, tolength):
          i = 0
          while i < fromlength:
              toptr[i] = fromptr[i]
              i = i + 1
          while i < tolength:
              toptr[i] = -1
              i = i + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_from_IndexedArray
    specializations:
      - name: awkward_Identities32_from_IndexedArray32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_IndexedArray64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_IndexedArrayU32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_IndexedArray32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_IndexedArray64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_IndexedArrayU32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_from_IndexedArray(
          uniquecontents, toptr, fromptr, fromindex, tolength, fromlength, fromwidth
      ):
          for k in range(tolength * fromwidth):
              toptr[k] = -1
          for i in range(fromlength):
              j = fromindex[i]
              if j >= tolength:
                  raise ValueError("max(index) > len(content)")
              else:
                  if j >= 0:
                      if toptr[j * fromwidth] != -1:
                          uniquecontents[0] = False
                          return
                      for k in range(fromwidth):
                          toptr[(j * fromwidth) + k] = fromptr[(i * fromwidth) + k]
          uniquecontents[0] = True
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_from_ListArray
    specializations:
      - name: awkward_Identities32_from_ListArray32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_ListArray64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_ListArrayU32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListArray32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListArray64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListArrayU32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: tolength, type: "int64_t", dir: in, role: ListArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_from_ListArray(
          uniquecontents,
          toptr,
          fromptr,
          fromstarts,
          fromstops,
          tolength,
          fromlength,
          fromwidth,
      ):
          for k in range(tolength * (fromwidth + 1)):
              toptr[k] = -1
          for i in range(fromlength):
              start = fromstarts[i]
              stop = fromstops[i]
              if (start != stop) and (stop > tolength):
                  raise ValueError("max(stop) > len(content)")
              for j in range(start, stop):
                  if toptr[(j * (fromwidth + 1)) + fromwidth] != -1:
                      uniquecontents[0] = False
                      return
                  for k in range(fromwidth):
                      toptr[(j * (fromwidth + 1)) + k] = fromptr[(i * fromwidth) + k]
                  toptr[(j * (fromwidth + 1)) + fromwidth] = float(j - start)
          uniquecontents[0] = True
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_from_ListOffsetArray
    specializations:
      - name: awkward_Identities32_from_ListOffsetArray32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_ListOffsetArray64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities32_from_ListOffsetArrayU32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListOffsetArray32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListOffsetArray64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_ListOffsetArrayU32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tolength, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_from_ListOffsetArray(
          toptr, fromptr, fromoffsets, tolength, fromlength, fromwidth
      ):
          globalstart = fromoffsets[0]
          globalstop = fromoffsets[fromlength]
          for k in range(globalstart * (fromwidth + 1)):
              toptr[k] = -1
          k = globalstop * (fromwidth + 1)
          while k < (tolength * (fromwidth + 1)):
              toptr[k] = -1
              k = k + 1
          for i in range(fromlength):
              start = fromoffsets[i]
              stop = fromoffsets[i + 1]
              if (start != stop) and (stop > tolength):
                  raise ValueError("max(stop) > len(content)")
              for j in range(start, stop):
                  for k in range(fromwidth):
                      toptr[(j * (fromwidth + 1)) + k] = fromptr[(i * fromwidth) + k]
                  toptr[(j * (fromwidth + 1)) + fromwidth] = float(j - start)
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_from_RegularArray
    specializations:
      - name: awkward_Identities32_from_RegularArray
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
          - {name: tolength, type: "int64_t", dir: in, role: default}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_from_RegularArray
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
          - {name: tolength, type: "int64_t", dir: in, role: default}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_from_RegularArray(
          toptr, fromptr, size, tolength, fromlength, fromwidth
      ):
          for i in range(fromlength):
              for j in range(size):
                  for k in range(fromwidth):
                      toptr[(((i * size) + j) * (fromwidth + 1)) + k] = fromptr[
                          (i * fromwidth) + k
                      ]
                  toptr[(((i * size) + j) * (fromwidth + 1)) + fromwidth] = float(j)
          k = ((fromlength + 1) * size) * (fromwidth + 1)
          while k < (tolength * (fromwidth + 1)):
              toptr[k] = -1
              k = k + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_from_UnionArray
    specializations:
      - name: awkward_Identities32_from_UnionArray8_32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_Identities32_from_UnionArray8_64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_Identities32_from_UnionArray8_U32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_Identities64_from_UnionArray8_32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_Identities64_from_UnionArray8_64
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_Identities64_from_UnionArray8_U32
        args:
          - {name: uniquecontents, type: "List[bool]", dir: out}
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: Identities-array}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: tolength, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: fromwidth, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
    description: null
    definition: |
      def awkward_Identities_from_UnionArray(
          uniquecontents,
          toptr,
          fromptr,
          fromtags,
          fromindex,
          tolength,
          fromlength,
          fromwidth,
          which,
      ):
          for k in range(tolength * fromwidth):
              toptr[k] = -1
          for i in range(fromlength):
              if fromtags[i] == which:
                  j = fromindex[i]
                  if j >= tolength:
                      raise ValueError("max(index) > len(content)")
                  else:
                      if j < 0:
                          raise ValueError("min(index) < 0")
                      else:
                          if toptr[j * fromwidth] != -1:
                              uniquecontents[0] = False
                              return
                          for k in range(fromwidth):
                              toptr[(j * fromwidth) + k] = fromptr[(i * fromwidth) + k]
          uniquecontents[0] = True
    automatic-tests: true
    manual-tests: []

  - name: awkward_Identities_getitem_carry
    specializations:
      - name: awkward_Identities32_getitem_carry_64
        args:
          - {name: newidentitiesptr, type: "List[int32_t]", dir: out}
          - {name: identitiesptr, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: width, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Identities64_getitem_carry_64
        args:
          - {name: newidentitiesptr, type: "List[int64_t]", dir: out}
          - {name: identitiesptr, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: width, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Identities_getitem_carry(
          newidentitiesptr, identitiesptr, carryptr, lencarry, width, length
      ):
          for i in range(lencarry):
              if carryptr[i] >= length:
                  raise ValueError("index out of range")
              for j in range(width):
                  newidentitiesptr[(width * i) + j] = identitiesptr[(width * carryptr[i]) + j]
    automatic-tests: true
    manual-tests: []

  - name: awkward_Index_to_Index64
    specializations:
      - name: awkward_Index32_to_Index64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Index8_to_Index64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU32_to_Index64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU8_to_Index64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_Index_to_Index64(toptr, fromptr, length):
          for i in range(length):
              toptr[i] = int(fromptr[i])
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_fill
    specializations:
      - name: awkward_IndexedArray_fill_to64_from32
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray_fill_to64_from64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray_fill_to64_fromU32
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_fill_count
    specializations:
      - name: awkward_IndexedArray_fill_to64_count
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_fill_count(toindex, toindexoffset, length, base):
          for i in range(length):
              toindex[toindexoffset + i] = i + base
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_flatten_nextcarry
    specializations:
      - name: awkward_IndexedArray32_flatten_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_flatten_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_flatten_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_flatten_none2empty
    specializations:
      - name: awkward_IndexedArray32_flatten_none2empty_64
        args:
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: outindexlength, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_flatten_none2empty_64
        args:
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: outindexlength, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_flatten_none2empty_64
        args:
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: outindexlength, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_getitem_adjust_outindex
    specializations:
      - name: awkward_IndexedArray_getitem_adjust_outindex_64
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: tononzero, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: fromindexlength, type: "int64_t", dir: in, role: default}
          - {name: nonzero, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: nonzerolength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_getitem_adjust_outindex(
          tomask, toindex, tononzero, fromindex, fromindexlength, nonzero, nonzerolength
      ):
          j = 0
          k = 0
          for i in range(fromindexlength):
              fromval = fromindex[i]
              tomask[i] = fromval < 0
              if fromval < 0:
                  toindex[k] = -1
                  k = k + 1
              else:
                  if (j < nonzerolength) and (fromval == nonzero[j]):
                      tononzero[j] = fromval + (k - j)
                      toindex[k] = j
                      j = j + 1
                      k = k + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_getitem_carry
    specializations:
      - name: awkward_IndexedArray32_getitem_carry_64
        args:
          - {name: toindex, type: "List[int32_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_getitem_carry_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_getitem_carry_64
        args:
          - {name: toindex, type: "List[uint32_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_getitem_carry(
          toindex, fromindex, fromcarry, lenindex, lencarry
      ):
          for i in range(lencarry):
              if fromcarry[i] >= lenindex:
                  raise ValueError("index out of range")
              toindex[i] = float(fromindex[fromcarry[i]])
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_getitem_nextcarry
    specializations:
      - name: awkward_IndexedArray32_getitem_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_getitem_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_getitem_nextcarry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_getitem_nextcarry_outindex
    specializations:
      - name: awkward_IndexedArray32_getitem_nextcarry_outindex_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[int32_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray64_getitem_nextcarry_outindex_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArrayU32_getitem_nextcarry_outindex_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[uint32_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_getitem_nextcarry_outindex_mask
    specializations:
      - name: awkward_IndexedArray32_getitem_nextcarry_outindex_mask_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_getitem_nextcarry_outindex_mask_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_getitem_nextcarry_outindex_mask_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_getitem_nextcarry_outindex_mask(
          tocarry, toindex, fromindex, lenindex, lencontent
      ):
          k = 0
          for i in range(lenindex):
              j = fromindex[i]
              if j >= lencontent:
                  raise ValueError("index out of range")
              else:
                  if j < 0:
                      toindex[i] = -1
                  else:
                      tocarry[k] = j
                      toindex[i] = float(k)
                      k = k + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_local_preparenext_64
    specializations:
      - name: awkward_IndexedArray_local_preparenext_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: parentslength, type: "const int64_t", dir: in, role: default}
          - {name: nextparents, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: nextlen, type: "const int64_t", dir: in, role: default}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_IndexedArray_mask
    specializations:
      - name: awkward_IndexedArray32_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_mask(tomask, fromindex, length):
          for i in range(length):
              tomask[i] = fromindex[i] < 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_numnull
    specializations:
      - name: awkward_IndexedArray32_numnull
        args:
          - {name: numnull, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_numnull
        args:
          - {name: numnull, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_numnull
        args:
          - {name: numnull, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: lenindex, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_IndexedArray_numnull(numnull, fromindex, lenindex):
          numnull[0] = 0
          for i in range(lenindex):
              if fromindex[i] < 0:
                  numnull[0] = numnull[0] + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_overlay_mask
    specializations:
      - name: awkward_IndexedArray32_overlay_mask8_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArray64_overlay_mask8_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexedArrayU32_overlay_mask8_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: mask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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]
    automatic-tests: false
    manual-tests: []

  - name: awkward_IndexedArray_reduce_next_64
    specializations:
      - name: awkward_IndexedArray32_reduce_next_64
        args:
          - {name: nextcarry, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int32_t]]", dir: in, role: reducer-index}
          - {name: parents, type: "List[int64_t]", dir: in, role: reducer-parents}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
      - name: awkward_IndexedArray64_reduce_next_64
        args:
          - {name: nextcarry, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: reducer-index}
          - {name: parents, type: "List[int64_t]", dir: in, role: reducer-parents}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
      - name: awkward_IndexedArrayU32_reduce_next_64
        args:
          - {name: nextcarry, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[uint32_t]]", dir: in, role: reducer-index}
          - {name: parents, type: "List[int64_t]", dir: in, role: reducer-parents}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_reduce_next_fix_offsets_64
    specializations:
      - name: awkward_IndexedArray_reduce_next_fix_offsets_64
        args:
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: reducer-starts}
          - {name: startslength, type: "int64_t", dir: in, role: reducer-startslength}
          - {name: outindexlength, type: "int64_t", dir: in, role: reducer-outindexlength}
    description: null
    definition: |
      def awkward_IndexedArray_reduce_next_fix_offsets_64(
          outoffsets, starts, startslength, outindexlength
      ):
          for i in range(startslength):
              outoffsets[i] = starts[i]
          outoffsets[startslength] = outindexlength
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_reduce_next_nonlocal_nextshifts_64
    specializations:
      - name: awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int32_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
      - name: awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
      - name: awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[uint32_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_reduce_next_nonlocal_nextshifts_fromshifts_64
    specializations:
      - name: awkward_IndexedArray32_reduce_next_nonlocal_nextshifts_fromshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int32_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: shifts, type: "Const[List[int64_t]]", dir: in, role: reducer-shifts}
      - name: awkward_IndexedArray64_reduce_next_nonlocal_nextshifts_fromshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: shifts, type: "Const[List[int64_t]]", dir: in, role: reducer-shifts}
      - name: awkward_IndexedArrayU32_reduce_next_nonlocal_nextshifts_fromshifts_64
        args:
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[uint32_t]]", dir: in, role: reducer-nextshifts}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: shifts, type: "Const[List[int64_t]]", dir: in, role: reducer-shifts}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_simplify
    specializations:
      - name: awkward_IndexedArray32_simplify32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray32_simplify64_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray32_simplifyU32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray64_simplify32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray64_simplify64_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArray64_simplifyU32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArrayU32_simplify32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArrayU32_simplify64_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
      - name: awkward_IndexedArrayU32_simplifyU32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: outerlength, type: "int64_t", dir: in, role: default}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: innerlength, type: "int64_t", dir: in, role: IndexedArray-length}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedArray_validity
    specializations:
      - name: awkward_IndexedArray32_validity
        args:
          - {name: index, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: isoption, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
      - name: awkward_IndexedArray64_validity
        args:
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: isoption, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
      - name: awkward_IndexedArrayU32_validity
        args:
          - {name: index, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: isoption, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
    description: null
    definition: |
      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)")
    automatic-tests: true
    manual-tests: []

  - name: awkward_IndexedOptionArray_rpad_and_clip_mask_axis1
    specializations:
      - name: awkward_IndexedOptionArray_rpad_and_clip_mask_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: frommask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_broadcast_tooffsets
    specializations:
      - name: awkward_ListArray32_broadcast_tooffsets_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArray64_broadcast_tooffsets_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArrayU32_broadcast_tooffsets_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_combinations
    specializations:
      - name: awkward_ListArray32_combinations_64
        args:
          - {name: tocarry, type: "List[List[int64_t]]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "List[int64_t]", dir: in}
          - {name: n, type: "int64_t", dir: in}
          - {name: replacement, type: "bool", dir: in}
          - {name: starts, type: "Const[List[int32_t]]", dir: in}
          - {name: stops, type: "Const[List[int32_t]]", dir: in}
          - {name: length, type: "int64_t", dir: in}
      - name: awkward_ListArray64_combinations_64
        args:
          - {name: tocarry, type: "List[List[int64_t]]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "List[int64_t]", dir: in}
          - {name: n, type: "int64_t", dir: in}
          - {name: replacement, type: "bool", dir: in}
          - {name: starts, type: "Const[List[int64_t]]", dir: in}
          - {name: stops, type: "Const[List[int64_t]]", dir: in}
          - {name: length, type: "int64_t", dir: in}
      - name: awkward_ListArrayU32_combinations_64
        args:
          - {name: tocarry, type: "List[List[int64_t]]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "List[int64_t]", dir: in}
          - {name: n, type: "int64_t", dir: in}
          - {name: replacement, type: "bool", dir: in}
          - {name: starts, type: "Const[List[uint32_t]]", dir: in}
          - {name: stops, type: "Const[List[uint32_t]]", dir: in}
          - {name: length, type: "int64_t", dir: in}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListArray_combinations_length
    specializations:
      - name: awkward_ListArray32_combinations_length_64
        args:
          - {name: totallen, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: n, type: "int64_t", dir: in, role: default}
          - {name: replacement, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
          - {name: starts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_combinations_length_64
        args:
          - {name: totallen, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: n, type: "int64_t", dir: in, role: default}
          - {name: replacement, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_combinations_length_64
        args:
          - {name: totallen, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: n, type: "int64_t", dir: in, role: default}
          - {name: replacement, type: "bool", dir: in, role: ByteMaskedArray-valid_when}
          - {name: starts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_compact_offsets
    specializations:
      - name: awkward_ListArray32_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_fill
    specializations:
      - name: awkward_ListArray_fill_to64_from32
        args:
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostartsoffset, type: "int64_t", dir: in, role: default}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: tostopsoffset, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray_fill_to64_from64
        args:
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostartsoffset, type: "int64_t", dir: in, role: default}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: tostopsoffset, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray_fill_to64_fromU32
        args:
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostartsoffset, type: "int64_t", dir: in, role: default}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: tostopsoffset, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_carry
    specializations:
      - name: awkward_ListArray32_getitem_carry_64
        args:
          - {name: tostarts, type: "List[int32_t]", dir: out}
          - {name: tostops, type: "List[int32_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_carry_64
        args:
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_carry_64
        args:
          - {name: tostarts, type: "List[uint32_t]", dir: out}
          - {name: tostops, type: "List[uint32_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListArray_getitem_carry(
          tostarts, tostops, fromstarts, fromstops, fromcarry, lenstarts, lencarry
      ):
          for i in range(lencarry):
              if fromcarry[i] >= lenstarts:
                  raise ValueError("index out of range")
              tostarts[i] = float(fromstarts[fromcarry[i]])
              tostops[i] = float(fromstops[fromcarry[i]])
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_apply
    specializations:
      - name: awkward_ListArray32_getitem_jagged_apply_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: ListArray-length}
          - {name: sliceindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: sliceinnerlen, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray2-stops}
          - {name: contentlen, type: "int64_t", dir: in, role: ListArray2-length}
      - name: awkward_ListArray64_getitem_jagged_apply_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: ListArray-length}
          - {name: sliceindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: sliceinnerlen, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray2-stops}
          - {name: contentlen, type: "int64_t", dir: in, role: ListArray2-length}
      - name: awkward_ListArrayU32_getitem_jagged_apply_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: ListArray-length}
          - {name: sliceindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: sliceinnerlen, type: "int64_t", dir: in, role: IndexedArray-length}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray2-stops}
          - {name: contentlen, type: "int64_t", dir: in, role: ListArray2-length}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_carrylen
    specializations:
      - name: awkward_ListArray_getitem_jagged_carrylen_64
        args:
          - {name: carrylen, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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])
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_descend
    specializations:
      - name: awkward_ListArray32_getitem_jagged_descend_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray2-stops}
      - name: awkward_ListArray64_getitem_jagged_descend_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray2-stops}
      - name: awkward_ListArrayU32_getitem_jagged_descend_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: sliceouterlen, type: "int64_t", dir: in, role: default}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray2-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray2-stops}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_expand
    specializations:
      - name: awkward_ListArray32_getitem_jagged_expand_64
        args:
          - {name: multistarts, type: "List[int64_t]", dir: out}
          - {name: multistops, type: "List[int64_t]", dir: out}
          - {name: singleoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: jaggedsize, type: "int64_t", dir: in, role: ListArray-at}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_jagged_expand_64
        args:
          - {name: multistarts, type: "List[int64_t]", dir: out}
          - {name: multistops, type: "List[int64_t]", dir: out}
          - {name: singleoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: jaggedsize, type: "int64_t", dir: in, role: ListArray-at}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_jagged_expand_64
        args:
          - {name: multistarts, type: "List[int64_t]", dir: out}
          - {name: multistops, type: "List[int64_t]", dir: out}
          - {name: singleoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: jaggedsize, type: "int64_t", dir: in, role: ListArray-at}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_numvalid
    specializations:
      - name: awkward_ListArray_getitem_jagged_numvalid_64
        args:
          - {name: numvalid, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: missing, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: missinglength, type: "int64_t", dir: in, role: IndexedArray-length}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListArray_getitem_jagged_shrink
    specializations:
      - name: awkward_ListArray_getitem_jagged_shrink_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: tosmalloffsets, type: "List[int64_t]", dir: out}
          - {name: tolargeoffsets, type: "List[int64_t]", dir: out}
          - {name: slicestarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: slicestops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: missing, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_next_array
    specializations:
      - name: awkward_ListArray32_getitem_next_array_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArray64_getitem_next_array_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArrayU32_getitem_next_array_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_next_array_advanced
    specializations:
      - name: awkward_ListArray32_getitem_next_array_advanced_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArray64_getitem_next_array_advanced_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
      - name: awkward_ListArrayU32_getitem_next_array_advanced_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: ListArray-length}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_next_at
    specializations:
      - name: awkward_ListArray32_getitem_next_at_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: at, type: "int64_t", dir: in, role: ListArray-at}
      - name: awkward_ListArray64_getitem_next_at_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: at, type: "int64_t", dir: in, role: ListArray-at}
      - name: awkward_ListArrayU32_getitem_next_at_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: at, type: "int64_t", dir: in, role: ListArray-at}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_next_range
    specializations:
      - name: awkward_ListArray32_getitem_next_range_64
        args:
          - {name: tooffsets, type: "List[int32_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_next_range_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_next_range_64
        args:
          - {name: tooffsets, type: "List[uint32_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListArray_getitem_next_range_carrylength
    specializations:
      - name: awkward_ListArray32_getitem_next_range_carrylength
        args:
          - {name: carrylength, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_next_range_carrylength
        args:
          - {name: carrylength, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_next_range_carrylength
        args:
          - {name: carrylength, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: default}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: stop, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListArray_getitem_next_range_counts
    specializations:
      - name: awkward_ListArray32_getitem_next_range_counts_64
        args:
          - {name: total, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_next_range_counts_64
        args:
          - {name: total, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_next_range_counts_64
        args:
          - {name: total, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_getitem_next_range_spreadadvanced
    specializations:
      - name: awkward_ListArray32_getitem_next_range_spreadadvanced_64
        args:
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_getitem_next_range_spreadadvanced_64
        args:
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_getitem_next_range_spreadadvanced_64
        args:
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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]
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListArray_localindex
    specializations:
      - name: awkward_ListArray32_localindex_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_localindex_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_localindex_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_min_range
    specializations:
      - name: awkward_ListArray32_min_range
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_min_range
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_min_range
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_num
    specializations:
      - name: awkward_ListArray32_num_64
        args:
          - {name: tonum, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_num_64
        args:
          - {name: tonum, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_num_64
        args:
          - {name: tonum, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListArray_num(tonum, fromstarts, fromstops, length):
          for i in range(length):
              start = fromstarts[i]
              stop = fromstops[i]
              tonum[i] = float(stop - start)
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_rpad_and_clip_length_axis1
    specializations:
      - name: awkward_ListArray32_rpad_and_clip_length_axis1
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_rpad_and_clip_length_axis1
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_rpad_and_clip_length_axis1
        args:
          - {name: tomin, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: lenstarts, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_rpad_axis1
    specializations:
      - name: awkward_ListArray32_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: tostarts, type: "List[int32_t]", dir: out}
          - {name: tostops, type: "List[int32_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromstarts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: fromstops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: tostarts, type: "List[uint32_t]", dir: out}
          - {name: tostops, type: "List[uint32_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListArray_validity
    specializations:
      - name: awkward_ListArray32_validity
        args:
          - {name: starts, type: "Const[List[int32_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[int32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArray64_validity
        args:
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[int64_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
      - name: awkward_ListArrayU32_validity
        args:
          - {name: starts, type: "Const[List[uint32_t]]", dir: in, role: ListArray-starts}
          - {name: stops, type: "Const[List[uint32_t]]", dir: in, role: ListArray-stops}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lencontent, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)")
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_compact_offsets
    specializations:
      - name: awkward_ListOffsetArray32_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArray64_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArrayU32_compact_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_flatten_offsets
    specializations:
      - name: awkward_ListOffsetArray32_flatten_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: outeroffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: outeroffsetslen, type: "int64_t", dir: in, role: default}
          - {name: inneroffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: inneroffsetslen, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArray64_flatten_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: outeroffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: outeroffsetslen, type: "int64_t", dir: in, role: default}
          - {name: inneroffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: inneroffsetslen, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArrayU32_flatten_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: outeroffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: outeroffsetslen, type: "int64_t", dir: in, role: default}
          - {name: inneroffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: inneroffsetslen, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListOffsetArray_flatten_offsets(
          tooffsets, outeroffsets, outeroffsetslen, inneroffsets, inneroffsetslen
      ):
          for i in range(outeroffsetslen):
              tooffsets[i] = inneroffsets[outeroffsets[i]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_merge_offsets
    specializations:
      - name: awkward_ListOffsetArray64_merge_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListOffsetArray_merge_offsets(
          tooffsets, fromoffsets, length
      ):
          for i in range(length):
              tooffsets[i] = tooffsets[i] + fromoffsets[i]
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_getitem_adjust_offsets
    specializations:
      - name: awkward_ListOffsetArray_getitem_adjust_offsets_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tononzero, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: nonzero, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: nonzerolength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListOffsetArray_getitem_adjust_offsets(
          tooffsets, tononzero, fromoffsets, length, nonzero, nonzerolength
      ):
          j = 0
          tooffsets[0] = fromoffsets[0]
          for i in range(length):
              slicestart = fromoffsets[i]
              slicestop = fromoffsets[i + 1]
              count = 0
              while (j < nonzerolength) and (nonzero[j] < slicestop):
                  tononzero[j] = nonzero[j] - slicestart
                  j = j + 1
                  count = count + 1

              tooffsets[i + 1] = tooffsets[i] + count
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_getitem_adjust_offsets_index
    specializations:
      - name: awkward_ListOffsetArray_getitem_adjust_offsets_index_64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: tononzero, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: indexlength, type: "int64_t", dir: in, role: default}
          - {name: nonzero, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: nonzerolength, type: "int64_t", dir: in, role: default}
          - {name: originalmask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: masklength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_ListOffsetArray_getitem_adjust_offsets_index(
          tooffsets,
          tononzero,
          fromoffsets,
          length,
          index,
          indexlength,
          nonzero,
          nonzerolength,
          originalmask,
          masklength,
      ):
          k = 0
          tooffsets[0] = fromoffsets[0]
          for i in range(length):
              slicestart = fromoffsets[i]
              slicestop = fromoffsets[i + 1]
              numnull = 0
              for j in range(slicestart, slicestop):
                  numnull += 1 if originalmask[j] != 0 else 0
              nullcount = 0
              count = 0
              while (k < indexlength) and (
                  ((index[k] < 0) and (nullcount < numnull))
                  or (
                      ((index[k] >= 0) and (index[k] < nonzerolength))
                      and (nonzero[index[k]] < slicestop)
                  )
              ):
                  if index[k] < 0:
                      nullcount = nullcount + 1
                  else:
                      j = index[k]
                      tononzero[j] = nonzero[j] - slicestart
                  k = k + 1
                  count = count + 1

              tooffsets[i + 1] = tooffsets[i] + count
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_local_preparenext_64
    specializations:
      - name: awkward_ListOffsetArray_local_preparenext_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_global_startstop_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_global_startstop_64
        args:
          - {name: globalstart, type: "List[int64_t]", dir: out}
          - {name: globalstop, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: reducer-offsets}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      def awkward_ListOffsetArray_reduce_global_startstop_64(
          globalstart, globalstop, offsets, length
      ):
          globalstart[0] = offsets[0]
          globalstop[0] = offsets[length]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_local_nextparents_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_local_nextparents_64
        args:
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: reducer-offsets}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_local_outoffsets_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_local_outoffsets_64
        args:
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_findgaps_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_findgaps_64
        args:
          - {name: gaps, type: "List[int64_t]", dir: out}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
    description: null
    definition: |
      def awkward_ListOffsetArray_reduce_nonlocal_findgaps_64(gaps, parents, lenparents):
          k = 0
          last = -1
          for i in range(lenparents):
              parent = parents[i]
              if last < parent:
                  gaps[k] = parent - last
                  k = k + 1
                  last = parent
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_maxcount_offsetscopy_64
        args:
          - {name: maxcount, type: "List[int64_t]", dir: out}
          - {name: offsetscopy, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: reducer-offsets}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_nextshifts_64
        args:
          - {name: nummissing, type: "List[int64_t]", dir: out}
          - {name: missing, type: "List[int64_t]", dir: out}
          - {name: nextshifts, type: "List[int64_t]", dir: out}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: reducer-offsets}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: reducer-starts}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: maxcount, type: "int64_t", dir: in, role: reducer-maxcount}
          - {name: nextlen, type: "int64_t", dir: in, role: reducer-nextlen}
          - {name: nextcarry, type: "Const[List[int64_t]]", dir: in, role: reducer-nextcarry}
    description: null
    definition: |
      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]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64
        args:
          - {name: nextstarts, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "Const[List[int64_t]]", dir: in, role: reducer-nextparents}
          - {name: nextlen, type: "int64_t", dir: in, role: reducer-nextlen}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64
        args:
          - {name: outstarts, type: "List[int64_t]", dir: out}
          - {name: outstops, type: "List[int64_t]", dir: out}
          - {name: distincts, type: "Const[List[int64_t]]", dir: in, role: reducer-distincts}
          - {name: lendistincts, type: "int64_t", dir: in, role: reducer-lendistincts}
          - {name: gaps, type: "Const[List[int64_t]]", dir: in, role: reducer-gaps}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_ListOffsetArray_reduce_nonlocal_outstartsstops_64(
          outstarts, outstops, distincts, lendistincts, gaps, outlength
      ):
          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
    automatic-tests: true
    manual-tests: []

  - name: awkward_ListOffsetArray_reduce_nonlocal_preparenext_64
    specializations:
      - name: awkward_ListOffsetArray_reduce_nonlocal_preparenext_64
        args:
          - {name: nextcarry, type: "List[int64_t]", dir: out}
          - {name: nextparents, type: "List[int64_t]", dir: out}
          - {name: nextlen, type: "int64_t", dir: in}
          - {name: maxnextparents, type: "List[int64_t]", dir: out}
          - {name: distincts, type: "List[int64_t]", dir: out}
          - {name: distinctslen, type: "int64_t", dir: in}
          - {name: offsetscopy, type: "List[int64_t]", dir: in}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in}
          - {name: length, type: "int64_t", dir: in}
          - {name: parents, type: "Const[List[int64_t]]", dir: in}
          - {name: maxcount, type: "int64_t", dir: in}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_rpad_and_clip_axis1
    specializations:
      - name: awkward_ListOffsetArray32_rpad_and_clip_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArray64_rpad_and_clip_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArrayU32_rpad_and_clip_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_rpad_axis1
    specializations:
      - name: awkward_ListOffsetArray32_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArray64_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArrayU32_rpad_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_rpad_length_axis1
    specializations:
      - name: awkward_ListOffsetArray32_rpad_length_axis1
        args:
          - {name: tooffsets, type: "List[int32_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: tolength, type: "List[int64_t]", dir: out}
      - name: awkward_ListOffsetArray64_rpad_length_axis1
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: tolength, type: "List[int64_t]", dir: out}
      - name: awkward_ListOffsetArrayU32_rpad_length_axis1
        args:
          - {name: tooffsets, type: "List[uint32_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromlength, type: "int64_t", dir: in, role: default}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: tolength, type: "List[int64_t]", dir: out}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_ListOffsetArray_toRegularArray
    specializations:
      - name: awkward_ListOffsetArray32_toRegularArray
        args:
          - {name: size, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArray64_toRegularArray
        args:
          - {name: size, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
      - name: awkward_ListOffsetArrayU32_toRegularArray
        args:
          - {name: size, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[uint32_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_MaskedArray_getitem_next_jagged_project
    specializations:
      - name: awkward_MaskedArray32_getitem_next_jagged_project
        args:
          - {name: index, type: "List[int32_t]", dir: in, role: IndexedArray-index}
          - {name: starts_in, type: "List[int64_t]", dir: in, role: ListArray-starts}
          - {name: stops_in, type: "List[int64_t]", dir: in, role: ListArray-stops}
          - {name: starts_out, type: "List[int64_t]", dir: out}
          - {name: stops_out, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_MaskedArray64_getitem_next_jagged_project
        args:
          - {name: index, type: "List[int64_t]", dir: in, role: IndexedArray-index}
          - {name: starts_in, type: "List[int64_t]", dir: in, role: ListArray-starts}
          - {name: stops_in, type: "List[int64_t]", dir: in, role: ListArray-stops}
          - {name: starts_out, type: "List[int64_t]", dir: out}
          - {name: stops_out, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_MaskedArrayU32_getitem_next_jagged_project
        args:
          - {name: index, type: "List[uint32_t]", dir: in, role: IndexedArray-index}
          - {name: starts_in, type: "List[int64_t]", dir: in, role: ListArray-starts}
          - {name: stops_in, type: "List[int64_t]", dir: in, role: ListArray-stops}
          - {name: starts_out, type: "List[int64_t]", dir: out}
          - {name: stops_out, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_copy
    specializations:
      - name: awkward_NumpyArray_copy
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: len, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_NumpyArray_contiguous_copy
    specializations:
      - name: awkward_NumpyArray_contiguous_copy_64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: len, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
          - {name: pos, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_NumpyArray_contiguous_init
    specializations:
      - name: awkward_NumpyArray_contiguous_init_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: skip, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_contiguous_init(toptr, skip, stride):
          for i in range(skip):
              toptr[i] = i * stride
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_contiguous_next
    specializations:
      - name: awkward_NumpyArray_contiguous_next_64
        args:
          - {name: topos, type: "List[int64_t]", dir: out}
          - {name: frompos, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_contiguous_next(topos, frompos, length, skip, stride):
          for i in range(length):
              for j in range(skip):
                  topos[(i * skip) + j] = frompos[i] + (j * stride)
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_fill
    specializations:
      - name: awkward_NumpyArray_fill_toint8_fromint8
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromint16
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromint32
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromint64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromuint8
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromuint16
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromuint32
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromuint64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromfloat32
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_fromfloat64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromint8
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromint16
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromint32
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromint64
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromuint8
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromuint16
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromuint32
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromuint64
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromfloat32
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_fromfloat64
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromint8
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromint16
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromint32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromint64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromuint8
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromuint16
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromuint32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromuint64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromfloat32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_fromfloat64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromint8
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromint16
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromint32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromint64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromuint8
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromuint16
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromuint32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromuint64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromfloat32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_fromfloat64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromint8
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromint16
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromint32
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromint64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromuint8
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromuint16
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromuint32
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromuint64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromfloat32
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_fromfloat64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromint8
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromint16
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromint32
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromint64
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromuint8
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromuint16
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromuint32
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromuint64
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromfloat32
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_fromfloat64
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromint8
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromint16
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromint32
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromint64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromuint8
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromuint16
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromuint32
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromuint64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromfloat32
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_fromfloat64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromint8
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromint16
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromint32
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromint64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromuint8
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromuint16
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromuint32
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromuint64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromfloat32
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_fromfloat64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromint8
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromint16
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromint32
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromint64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromuint8
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromuint16
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromuint32
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromuint64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromfloat32
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_fromfloat64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromint8
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromint16
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromint32
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromint64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromuint8
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromuint16
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromuint32
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromuint64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromfloat32
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_fromfloat64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_fill(toptr, tooffset, fromptr, length):
          for i in range(length):
              toptr[tooffset + i] = float(fromptr[i])
    automatic-tests: false
    manual-tests: []

  - name: awkward_NumpyArray_fill_frombool
    specializations:
      - name: awkward_NumpyArray_fill_tobool_frombool
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint8_frombool
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint16_frombool
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint32_frombool
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_toint64_frombool
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint8_frombool
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint16_frombool
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint32_frombool
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_touint64_frombool
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat32_frombool
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tofloat64_frombool
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_fill_frombool(toptr, tooffset, fromptr, length):
          for i in range(length):
              toptr[tooffset + i] = float(1 if fromptr[i] else 0)
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_fill_tobool
    specializations:
      - name: awkward_NumpyArray_fill_tobool_fromint8
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromint16
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromint32
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromint64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromuint8
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromuint16
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromuint32
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromuint64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromfloat32
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_NumpyArray_fill_tobool_fromfloat64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: tooffset, type: "int64_t", dir: in, role: IndexedArray-index-offset}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: NumpyArray-ptr}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_fill_tobool(toptr, tooffset, fromptr, length):
          for i in range(length):
              toptr[tooffset + i] = True if fromptr[i] > 0 else False
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_boolean_nonzero
    specializations:
      - name: awkward_NumpyArray_getitem_boolean_nonzero_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_boolean_nonzero(toptr, fromptr, length, stride):
          k = 0
          i = 0
          while i < length:
              if fromptr[i] != 0:
                  toptr[k] = i
                  k = k + 1
              i += stride
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_boolean_numtrue
    specializations:
      - name: awkward_NumpyArray_getitem_boolean_numtrue
        args:
          - {name: numtrue, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_boolean_numtrue(numtrue, fromptr, length, stride):
          numtrue[0] = 0
          i = 0
          while i < length:
              numtrue[0] = numtrue[0] + (fromptr[i] != 0)
              i += stride
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_array
    specializations:
      - name: awkward_NumpyArray_getitem_next_array_64
        args:
          - {name: nextcarryptr, type: "List[int64_t]", dir: out}
          - {name: nextadvancedptr, type: "List[int64_t]", dir: out}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: flatheadptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray2-ptr}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: lenflathead, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_next_array(
          nextcarryptr, nextadvancedptr, carryptr, flatheadptr, lencarry, lenflathead, skip
      ):
          for i in range(lencarry):
              for j in range(lenflathead):
                  nextcarryptr[(i * lenflathead) + j] = (skip * carryptr[i]) + flatheadptr[j]
                  nextadvancedptr[(i * lenflathead) + j] = j
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_array_advanced
    specializations:
      - name: awkward_NumpyArray_getitem_next_array_advanced_64
        args:
          - {name: nextcarryptr, type: "List[int64_t]", dir: out}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: advancedptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray2-ptr}
          - {name: flatheadptr, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_next_array_advanced(
          nextcarryptr, carryptr, advancedptr, flatheadptr, lencarry, skip
      ):
          for i in range(lencarry):
              nextcarryptr[i] = (skip * carryptr[i]) + flatheadptr[advancedptr[i]]
    automatic-tests: false
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_at
    specializations:
      - name: awkward_NumpyArray_getitem_next_at_64
        args:
          - {name: nextcarryptr, type: "List[int64_t]", dir: out}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
          - {name: at, type: "int64_t", dir: in, role: ListArray-at}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_next_at(nextcarryptr, carryptr, lencarry, skip, at):
          for i in range(lencarry):
              nextcarryptr[i] = (skip * carryptr[i]) + at
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_null
    specializations:
      - name: awkward_NumpyArray_getitem_next_null_64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: NumpyArray-ptr}
          - {name: len, type: "int64_t", dir: in, role: default}
          - {name: stride, type: "int64_t", dir: in, role: default}
          - {name: pos, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_range
    specializations:
      - name: awkward_NumpyArray_getitem_next_range_64
        args:
          - {name: nextcarryptr, type: "List[int64_t]", dir: out}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: lenhead, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_next_range(
          nextcarryptr, carryptr, lencarry, lenhead, skip, start, step
      ):
          for i in range(lencarry):
              for j in range(lenhead):
                  nextcarryptr[(i * lenhead) + j] = ((skip * carryptr[i]) + start) + (
                      j * step
                  )
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_getitem_next_range_advanced
    specializations:
      - name: awkward_NumpyArray_getitem_next_range_advanced_64
        args:
          - {name: nextcarryptr, type: "List[int64_t]", dir: out}
          - {name: nextadvancedptr, type: "List[int64_t]", dir: out}
          - {name: carryptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray-ptr}
          - {name: advancedptr, type: "Const[List[int64_t]]", dir: in, role: NumpyArray2-ptr}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: lenhead, type: "int64_t", dir: in, role: default}
          - {name: skip, type: "int64_t", dir: in, role: default}
          - {name: start, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_NumpyArray_getitem_next_range_advanced(
          nextcarryptr,
          nextadvancedptr,
          carryptr,
          advancedptr,
          lencarry,
          lenhead,
          skip,
          start,
          step,
      ):
          for i in range(lencarry):
              for j in range(lenhead):
                  nextcarryptr[(i * lenhead) + j] = ((skip * carryptr[i]) + start) + (
                      j * step
                  )
                  nextadvancedptr[(i * lenhead) + j] = advancedptr[i]
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_reduce_adjust_starts_64
    specializations:
      - name: awkward_NumpyArray_reduce_adjust_starts_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: reducer-starts}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_reduce_adjust_starts_shifts_64
    specializations:
      - name: awkward_NumpyArray_reduce_adjust_starts_shifts_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: starts, type: "Const[List[int64_t]]", dir: in, role: reducer-starts}
          - {name: shifts, type: "Const[List[int64_t]]", dir: in, role: reducer-shifts}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_reduce_mask_ByteMaskedArray_64
    specializations:
      - name: awkward_NumpyArray_reduce_mask_ByteMaskedArray_64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_NumpyArray_sort_asstrings_uint8
    specializations:
      - name: awkward_NumpyArray_sort_asstrings_uint8
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: outoffsets, type: "List[int64_t]", dir: out}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_broadcast_tooffsets
    specializations:
      - name: awkward_RegularArray_broadcast_tooffsets_64
        args:
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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")
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_broadcast_tooffsets_size1
    specializations:
      - name: awkward_RegularArray_broadcast_tooffsets_size1_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_combinations_64
    specializations:
      - name: awkward_RegularArray_combinations_64
        args:
          - {name: tocarry, type: "List[List[int64_t]]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "List[int64_t]", dir: in}
          - {name: n, type: "int64_t", dir: in}
          - {name: replacement, type: "bool", dir: in}
          - {name: size, type: "int64_t", dir: in}
          - {name: length, type: "int64_t", dir: in}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_RegularArray_compact_offsets
    specializations:
      - name: awkward_RegularArray_compact_offsets64
        args:
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      def awkward_RegularArray_compact_offsets(tooffsets, length, size):
          tooffsets[0] = 0
          for i in range(length):
              tooffsets[i + 1] = (i + 1) * size
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_carry
    specializations:
      - name: awkward_RegularArray_getitem_carry_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromcarry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lencarry, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_jagged_expand
    specializations:
      - name: awkward_RegularArray_getitem_jagged_expand_64
        args:
          - {name: multistarts, type: "List[int64_t]", dir: out}
          - {name: multistops, type: "List[int64_t]", dir: out}
          - {name: singleoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: regularsize, type: "int64_t", dir: in, role: RegularArray-size}
          - {name: regularlength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_array
    specializations:
      - name: awkward_RegularArray_getitem_next_array_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_array_advanced
    specializations:
      - name: awkward_RegularArray_getitem_next_array_advanced_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray2-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_array_regularize
    specializations:
      - name: awkward_RegularArray_getitem_next_array_regularize_64
        args:
          - {name: toarray, type: "List[int64_t]", dir: out}
          - {name: fromarray, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenarray, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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")
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_at
    specializations:
      - name: awkward_RegularArray_getitem_next_at_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: at, type: "int64_t", dir: in, role: ListArray-at}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_range
    specializations:
      - name: awkward_RegularArray_getitem_next_range_64
        args:
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: regular_start, type: "int64_t", dir: in, role: default}
          - {name: step, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: default}
          - {name: nextsize, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_getitem_next_range_spreadadvanced
    specializations:
      - name: awkward_RegularArray_getitem_next_range_spreadadvanced_64
        args:
          - {name: toadvanced, type: "List[int64_t]", dir: out}
          - {name: fromadvanced, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: nextsize, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      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]
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_localindex
    specializations:
      - name: awkward_RegularArray_localindex_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_RegularArray_localindex(toindex, size, length):
          for i in range(length):
              for j in range(size):
                  toindex[(i * size) + j] = j
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_num
    specializations:
      - name: awkward_RegularArray_num_64
        args:
          - {name: tonum, type: "List[int64_t]", dir: out}
          - {name: size, type: "int64_t", dir: in, role: RegularArray-size}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_RegularArray_num(tonum, size, length):
          for i in range(length):
              tonum[i] = size
    automatic-tests: true
    manual-tests: []

  - name: awkward_RegularArray_rpad_and_clip_axis1
    specializations:
      - name: awkward_RegularArray_rpad_and_clip_axis1_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: size, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_fillindex
    specializations:
      - name: awkward_UnionArray_fillindex_to64_from32
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray_fillindex_to64_from64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray_fillindex_to64_fromU32
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_fillindex(toindex, toindexoffset, fromindex, length):
          for i in range(length):
              toindex[toindexoffset + i] = float(fromindex[i])
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_fillindex_count
    specializations:
      - name: awkward_UnionArray_fillindex_to64_count
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: toindexoffset, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_fillindex_count(toindex, toindexoffset, length):
          for i in range(length):
              toindex[toindexoffset + i] = float(i)
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_fillna
    specializations:
      - name: awkward_UnionArray_fillna_from32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray_fillna_from64_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray_fillna_fromU32_to64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_fillna(toindex, fromindex, length):
          for i in range(length):
              toindex[i] = fromindex[i] if fromindex[i] >= 0 else 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_filltags
    specializations:
      - name: awkward_UnionArray_filltags_to8_from8
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: totagsoffset, type: "int64_t", dir: in, role: default}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_filltags(totags, totagsoffset, fromtags, length, base):
          for i in range(length):
              totags[totagsoffset + i] = float(fromtags[i] + base)
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_filltags_const
    specializations:
      - name: awkward_UnionArray_filltags_to8_const
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: totagsoffset, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_filltags_const(totags, totagsoffset, length, base):
          for i in range(length):
              totags[totagsoffset + i] = float(base)
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_mergetags_const
    specializations:
      - name: awkward_UnionArray_mergetags_to8_const
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: offset, type: "int64_t", dir: in, role: default}
          - {name: fromoffsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: index, type: "int64_t", dir: in, role: default}
          - {name: tag, type: "int8_t", dir: in, role: default}
          - {name: nextoffset, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_UnionArray_mergetags_const(totags, toindex, offset, fromoffsets, index, tag, nextoffset):
          start = fromoffsets[index]
          stop = fromoffsets[index + 1]
          diff = stop - start
          for i in range(diff):
              totags[offset + i] = tag
              toindex[offset + i] = start + i
          nextoffset = offset + diff - 1
    automatic-tests: false
    manual-tests: []

  - name: awkward_UnionArray_flatten_combine
    specializations:
      - name: awkward_UnionArray32_flatten_combine_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
      - name: awkward_UnionArray64_flatten_combine_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: UnionArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
      - name: awkward_UnionArrayU32_flatten_combine_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: tooffsets, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: UnionArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
    description: null
    definition: |
      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
    automatic-tests: false
    manual-tests: []

  - name: awkward_UnionArray_flatten_length
    specializations:
      - name: awkward_UnionArray32_flatten_length_64
        args:
          - {name: total_length, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
      - name: awkward_UnionArray64_flatten_length_64
        args:
          - {name: total_length, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
      - name: awkward_UnionArrayU32_flatten_length_64
        args:
          - {name: total_length, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsetsraws, type: "List[List[int64_t]]", dir: in, role: ListOffsetArray-rawoffsets}
    description: null
    definition: |
      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)
    automatic-tests: false
    manual-tests: []

  - name: awkward_UnionArray_project
    specializations:
      - name: awkward_UnionArray8_32_project_64
        args:
          - {name: lenout, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_UnionArray8_64_project_64
        args:
          - {name: lenout, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
      - name: awkward_UnionArray8_U32_project_64
        args:
          - {name: lenout, type: "List[int64_t]", dir: out}
          - {name: tocarry, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: which, type: "int64_t", dir: in, role: UnionArray-which}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_regular_index
    specializations:
      - name: awkward_UnionArray8_32_regular_index
        args:
          - {name: toindex, type: "List[int32_t]", dir: out}
          - {name: current, type: "List[int32_t]", dir: out}
          - {name: size, type: "int64_t", dir: in, role: default}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_64_regular_index
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: current, type: "List[int64_t]", dir: out}
          - {name: size, type: "int64_t", dir: in, role: default}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_U32_regular_index
        args:
          - {name: toindex, type: "List[uint32_t]", dir: out}
          - {name: current, type: "List[uint32_t]", dir: out}
          - {name: size, type: "int64_t", dir: in, role: default}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_regular_index_getsize
    specializations:
      - name: awkward_UnionArray8_regular_index_getsize
        args:
          - {name: size, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_simplify
    specializations:
      - name: awkward_UnionArray8_32_simplify8_32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_32_simplify8_64_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_32_simplify8_U32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_64_simplify8_32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_64_simplify8_64_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_64_simplify8_U32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_U32_simplify8_32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_U32_simplify8_64_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_U32_simplify8_U32_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: outertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: outerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: innertags, type: "Const[List[int8_t]]", dir: in, role: UnionArray2-tags}
          - {name: innerindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray2-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: innerwhich, type: "int64_t", dir: in, role: UnionArray1-which}
          - {name: outerwhich, type: "int64_t", dir: in, role: UnionArray2-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_simplify_one
    specializations:
      - name: awkward_UnionArray8_32_simplify_one_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: fromwhich, type: "int64_t", dir: in, role: UnionArray-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_64_simplify_one_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: fromwhich, type: "int64_t", dir: in, role: UnionArray-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
      - name: awkward_UnionArray8_U32_simplify_one_to8_64
        args:
          - {name: totags, type: "List[int8_t]", dir: out}
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromtags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: towhich, type: "int64_t", dir: in, role: default}
          - {name: fromwhich, type: "int64_t", dir: in, role: UnionArray-which}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: base, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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)
    automatic-tests: true
    manual-tests: []

  - name: awkward_UnionArray_validity
    specializations:
      - name: awkward_UnionArray8_32_validity
        args:
          - {name: tags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: index, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: numcontents, type: "int64_t", dir: in, role: UnionArray-length}
          - {name: lencontents, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
      - name: awkward_UnionArray8_64_validity
        args:
          - {name: tags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: numcontents, type: "int64_t", dir: in, role: UnionArray-length}
          - {name: lencontents, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
      - name: awkward_UnionArray8_U32_validity
        args:
          - {name: tags, type: "Const[List[int8_t]]", dir: in, role: UnionArray-tags}
          - {name: index, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: numcontents, type: "int64_t", dir: in, role: UnionArray-length}
          - {name: lencontents, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
    description: null
    definition: |
      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]])")
    automatic-tests: true
    manual-tests: []

  - name: awkward_argsort
    specializations:
      - name: awkward_argsort_bool
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_int8
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_int16
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_int32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_int64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_uint8
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_uint16
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_uint32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_uint64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_float32
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_argsort_float64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_carry_arange
    specializations:
      - name: awkward_carry_arange32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_carry_arange64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_carry_arangeU32
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_carry_arange(toptr, length):
          for i in range(length):
              toptr[i] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_combinations
    specializations:
      - name: awkward_combinations_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: n, type: "int64_t", dir: in, role: default}
          - {name: replacement, type: "bool", dir: in, role: default}
          - {name: singlelen, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_combinations(toindex, n, replacement, singlelen):
          raise ValueError("FIXME: awkward_combinations")
    automatic-tests: true
    manual-tests: []

  - name: awkward_content_reduce_zeroparents_64
    specializations:
      - name: awkward_content_reduce_zeroparents_64
        args:
          - {name: toparents, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: reducer-length}
    description: null
    definition: |
      def awkward_content_reduce_zeroparents_64(toparents, length):
          for i in range(length):
              toparents[i] = 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_index_carry
    specializations:
      - name: awkward_Index32_carry_64
        args:
          - {name: toindex, type: "List[int32_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenfromindex, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Index64_carry_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenfromindex, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Index8_carry_64
        args:
          - {name: toindex, type: "List[int8_t]", dir: out}
          - {name: fromindex, type: "Const[List[int8_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenfromindex, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU32_carry_64
        args:
          - {name: toindex, type: "List[uint32_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenfromindex, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU8_carry_64
        args:
          - {name: toindex, type: "List[uint8_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: lenfromindex, type: "int64_t", dir: in, role: ListOffsetArray-length}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_index_carry(toindex, fromindex, carry, lenfromindex, length):
          for i in range(length):
              j = carry[i]
              if j > lenfromindex:
                  raise ValueError("index out of range")
              toindex[i] = fromindex[j]
    automatic-tests: true
    manual-tests: []

  - name: awkward_index_carry_nocheck
    specializations:
      - name: awkward_Index32_carry_nocheck_64
        args:
          - {name: toindex, type: "List[int32_t]", dir: out}
          - {name: fromindex, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Index64_carry_nocheck_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: fromindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_Index8_carry_nocheck_64
        args:
          - {name: toindex, type: "List[int8_t]", dir: out}
          - {name: fromindex, type: "Const[List[int8_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU32_carry_nocheck_64
        args:
          - {name: toindex, type: "List[uint32_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_IndexU8_carry_nocheck_64
        args:
          - {name: toindex, type: "List[uint8_t]", dir: out}
          - {name: fromindex, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: carry, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_index_carry_nocheck(toindex, fromindex, carry, length):
          for i in range(length):
              toindex[i] = fromindex[carry[i]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_index_rpad_and_clip_axis0
    specializations:
      - name: awkward_index_rpad_and_clip_axis0_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_index_rpad_and_clip_axis1
    specializations:
      - name: awkward_index_rpad_and_clip_axis1_64
        args:
          - {name: tostarts, type: "List[int64_t]", dir: out}
          - {name: tostops, type: "List[int64_t]", dir: out}
          - {name: target, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      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
    automatic-tests: true
    manual-tests: []

  - name: awkward_localindex
    specializations:
      - name: awkward_localindex_64
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_localindex(toindex, length):
          for i in range(length):
              toindex[i] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_missing_repeat
    specializations:
      - name: awkward_missing_repeat_64
        args:
          - {name: outindex, type: "List[int64_t]", dir: out}
          - {name: index, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: indexlength, type: "int64_t", dir: in, role: default}
          - {name: repetitions, type: "int64_t", dir: in, role: default}
          - {name: regularsize, type: "int64_t", dir: in, role: RegularArray-size}
    description: null
    definition: |
      def awkward_missing_repeat(outindex, index, indexlength, repetitions, regularsize):
          for i in range(repetitions):
              for j in range(indexlength):
                  base = index[j]
                  outindex[(i * indexlength) + j] = base + i * regularsize if base >= 0 else 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_new_Identities
    specializations:
      - name: awkward_new_Identities32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_new_Identities64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_new_Identities(toptr, length):
          for i in range(length):
              toptr[i] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_argmax
    specializations:
      - name: awkward_reduce_argmax_int8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_int16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_int32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_uint8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_uint16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_uint32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_uint64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_float32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmax_float64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_argmax(toptr, fromptr, parents, lenparents, outlength):
          for k in range(outlength):
              toptr[k] = -1
          for i in range(lenparents):
              parent = parents[i]
              if (toptr[parent] == -1) or (fromptr[i] > fromptr[toptr[parent]]):
                  toptr[parent] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_argmax_bool_64
    specializations:
      - name: awkward_reduce_argmax_bool_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_argmax_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for k in range(outlength):
              toptr[k] = -1
          for i in range(lenparents):
              parent = parents[i]
              if (toptr[parent] == -1) or ((fromptr[i] != 0) > (fromptr[toptr[parent]] != 0)):
                  toptr[parent] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_argmin
    specializations:
      - name: awkward_reduce_argmin_int8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_int16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_int32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_uint8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_uint16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_uint32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_uint64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_float32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_argmin_float64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_argmin(toptr, fromptr, parents, lenparents, outlength):
          for k in range(outlength):
              toptr[k] = -1
          for i in range(lenparents):
              parent = parents[i]
              if (toptr[parent] == -1) or (fromptr[i] < fromptr[toptr[parent]]):
                  toptr[parent] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_argmin_bool_64
    specializations:
      - name: awkward_reduce_argmin_bool_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_argmin_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for k in range(outlength):
              toptr[k] = -1
          for i in range(lenparents):
              parent = parents[i]
              if (toptr[parent] == -1) or ((fromptr[i] != 0) < (fromptr[toptr[parent]] != 0)):
                  toptr[parent] = i
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_count_64
    specializations:
      - name: awkward_reduce_count_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_count_64(toptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 0
          for i in range(lenparents):
              toptr[parents[i]] = toptr[parents[i]] + 1
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_countnonzero
    specializations:
      - name: awkward_reduce_countnonzero_bool_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_int8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_int16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_int32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_uint8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_uint16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_uint32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_uint64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_float32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_countnonzero_float64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_countnonzero(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 0
          for i in range(lenparents):
              toptr[parents[i]] += fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_max
    specializations:
      - name: awkward_reduce_max_int8_int8_64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int8_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_int16_int16_64
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int16_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_int32_int32_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int32_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_int64_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int64_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_uint8_uint8_64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint8_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_uint16_uint16_64
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint16_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_uint32_uint32_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint32_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_uint64_uint64_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint64_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_float32_float32_64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "float", dir: in, role: reducer-identity}
      - name: awkward_reduce_max_float64_float64_64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "double", dir: in, role: reducer-identity}
    description: null
    definition: |
      def awkward_reduce_max(toptr, fromptr, parents, lenparents, outlength, identity):
          for i in range(outlength):
              toptr[i] = identity
          for i in range(lenparents):
              x = fromptr[i]
              toptr[parents[i]] = x if x > toptr[parents[i]] else toptr[parents[i]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_min
    specializations:
      - name: awkward_reduce_min_int8_int8_64
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int8_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_int16_int16_64
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int16_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_int32_int32_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int32_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_int64_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "int64_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_uint8_uint8_64
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint8_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_uint16_uint16_64
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint16_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_uint32_uint32_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint32_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_uint64_uint64_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "uint64_t", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_float32_float32_64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "float", dir: in, role: reducer-identity}
      - name: awkward_reduce_min_float64_float64_64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
          - {name: identity, type: "double", dir: in, role: reducer-identity}
    description: null
    definition: |
      def awkward_reduce_min(toptr, fromptr, parents, lenparents, outlength, identity):
          for i in range(outlength):
              toptr[i] = identity
          for i in range(lenparents):
              x = fromptr[i]
              toptr[parents[i]] = x if x < toptr[parents[i]] else toptr[parents[i]]
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_prod
    specializations:
      - name: awkward_reduce_prod_int32_int8_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int32_int16_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int32_int32_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int64_int8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int64_int16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int64_int32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_int64_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint32_uint8_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint32_uint16_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint32_uint32_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint64_uint8_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint64_uint16_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint64_uint32_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_uint64_uint64_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_float32_float32_64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_float64_float64_64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_prod(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = float(1)
          for i in range(lenparents):
              toptr[parents[i]] *= float(fromptr[i])
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_prod_bool
    specializations:
      - name: awkward_reduce_prod_bool_bool_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_int8_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_int16_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_int32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_int64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_uint8_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_uint16_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_uint32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_uint64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_float32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_prod_bool_float64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_prod_bool(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = True
          for i in range(lenparents):
              toptr[parents[i]] &= fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_prod_int32_bool_64
    specializations:
      - name: awkward_reduce_prod_int32_bool_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_prod_int32_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 1
          for i in range(lenparents):
              toptr[parents[i]] *= fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_prod_int64_bool_64
    specializations:
      - name: awkward_reduce_prod_int64_bool_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_prod_int64_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 1
          for i in range(lenparents):
              toptr[parents[i]] *= fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_sum
    specializations:
      - name: awkward_reduce_sum_int32_int8_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int32_int16_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int32_int32_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int64_int8_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int64_int16_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int64_int32_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_int64_int64_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint32_uint8_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint32_uint16_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint32_uint32_64
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint64_uint8_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint64_uint16_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint64_uint32_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_uint64_uint64_64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_float32_float32_64
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_float64_float64_64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_sum(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = float(0)
          for i in range(lenparents):
              toptr[parents[i]] += float(fromptr[i])
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_sum_bool
    specializations:
      - name: awkward_reduce_sum_bool_bool_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_int8_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_int16_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_int32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_int64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_uint8_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_uint16_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_uint32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_uint64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_float32_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
      - name: awkward_reduce_sum_bool_float64_64
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_sum_bool(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = False
          for i in range(lenparents):
              toptr[parents[i]] |= fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_sum_int32_bool_64
    specializations:
      - name: awkward_reduce_sum_int32_bool_64
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_sum_int32_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 0
          for i in range(lenparents):
              toptr[parents[i]] += fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_reduce_sum_int64_bool_64
    specializations:
      - name: awkward_reduce_sum_int64_bool_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: reducer-fromptr}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: reducer-parents}
          - {name: lenparents, type: "int64_t", dir: in, role: reducer-lenparents}
          - {name: outlength, type: "int64_t", dir: in, role: reducer-outlength}
    description: null
    definition: |
      def awkward_reduce_sum_int64_bool_64(toptr, fromptr, parents, lenparents, outlength):
          for i in range(outlength):
              toptr[i] = 0
          for i in range(lenparents):
              toptr[parents[i]] += fromptr[i] != 0
    automatic-tests: true
    manual-tests: []

  - name: awkward_regularize_arrayslice
    specializations:
      - name: awkward_regularize_arrayslice_64
        args:
          - {name: flatheadptr, type: "List[int64_t]", dir: in, role: NumpyArray-ptr}
          - {name: lenflathead, type: "int64_t", dir: in, role: default}
          - {name: length, type: "int64_t", dir: in, role: NumpyArray-length}
    description: null
    definition: |
      def awkward_regularize_arrayslice(flatheadptr, lenflathead, length):
          for i in range(lenflathead):
              original = flatheadptr[i]
              if flatheadptr[i] < 0:
                  flatheadptr[i] += length
              if (flatheadptr[i] < 0) or (flatheadptr[i] >= length):
                  raise ValueError("index out of range")
    automatic-tests: true
    manual-tests: []

  - name: awkward_slicearray_ravel
    specializations:
      - name: awkward_slicearray_ravel_64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: ndim, type: "int64_t", dir: in, role: default}
          - {name: shape, type: "Const[List[int64_t]]", dir: in, role: default}
          - {name: strides, type: "Const[List[int64_t]]", dir: in, role: default}
    description: null
    definition: |
      def awkward_slicearray_ravel(toptr, fromptr, ndim, shape, strides):
          if ndim == 1:
              for i in range(shape[0]):
                  toptr[i] = fromptr[i * strides[0]]
          else:
              for i in range(shape[0]):
                  err = awkward_slicearray_ravel(
                      toptr[i * shape[1]],
                      fromptr[i * strides[0]],
                      ndim - 1,
                      shape[1],
                      strides[1],
                  )
                  if err.str != nullptr:
                      return err
    automatic-tests: false
    manual-tests: []

  - name: awkward_slicemissing_check_same
    specializations:
      - name: awkward_slicemissing_check_same
        args:
          - {name: same, type: "List[bool]", dir: out}
          - {name: bytemask, type: "Const[List[int8_t]]", dir: in, role: ByteMaskedArray-mask}
          - {name: missingindex, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_slicemissing_check_same(same, bytemask, missingindex, length):
          same[0] = True
          for i in range(length):
              left = bytemask[i] != 0
              right = missingindex[i] < 0
              if left != right:
                  same[0] = False
                  return
    automatic-tests: true
    manual-tests: []

  - name: awkward_sort
    specializations:
      - name: awkward_sort_bool
        args:
          - {name: toptr, type: "List[bool]", dir: out}
          - {name: fromptr, type: "Const[List[bool]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_int8
        args:
          - {name: toptr, type: "List[int8_t]", dir: out}
          - {name: fromptr, type: "Const[List[int8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_int16
        args:
          - {name: toptr, type: "List[int16_t]", dir: out}
          - {name: fromptr, type: "Const[List[int16_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_int32
        args:
          - {name: toptr, type: "List[int32_t]", dir: out}
          - {name: fromptr, type: "Const[List[int32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_int64
        args:
          - {name: toptr, type: "List[int64_t]", dir: out}
          - {name: fromptr, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_uint8
        args:
          - {name: toptr, type: "List[uint8_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint8_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_uint16
        args:
          - {name: toptr, type: "List[uint16_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint16_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_uint32
        args:
          - {name: toptr, type: "List[uint32_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint32_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_uint64
        args:
          - {name: toptr, type: "List[uint64_t]", dir: out}
          - {name: fromptr, type: "Const[List[uint64_t]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_float32
        args:
          - {name: toptr, type: "List[float]", dir: out}
          - {name: fromptr, type: "Const[List[float]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
      - name: awkward_sort_float64
        args:
          - {name: toptr, type: "List[double]", dir: out}
          - {name: fromptr, type: "Const[List[double]]", dir: in, role: IndexedArray-index}
          - {name: length, type: "int64_t", dir: in, role: default}
          - {name: offsets, type: "Const[List[int64_t]]", dir: in, role: ListOffsetArray-offsets}
          - {name: offsetslength, type: "int64_t", dir: in, role: default}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
          - {name: ascending, type: "bool", dir: in, role: ListArray-replacement}
          - {name: stable, type: "bool", dir: in, role: ListArray-replacement}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_sorting_ranges
    specializations:
      - name: awkward_sorting_ranges
        args:
          - {name: toindex, type: "List[int64_t]", dir: out}
          - {name: tolength, type: "int64_t", dir: in, role: default}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_sorting_ranges_length
    specializations:
      - name: awkward_sorting_ranges_length
        args:
          - {name: tolength, type: "List[int64_t]", dir: out}
          - {name: parents, type: "Const[List[int64_t]]", dir: in, role: IndexedArray-index}
          - {name: parentslength, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      Insert Python definition here
    automatic-tests: false
    manual-tests: []

  - name: awkward_zero_mask
    specializations:
      - name: awkward_zero_mask64
        args:
          - {name: tomask, type: "List[int64_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
      - name: awkward_zero_mask8
        args:
          - {name: tomask, type: "List[int8_t]", dir: out}
          - {name: length, type: "int64_t", dir: in, role: default}
    description: null
    definition: |
      def awkward_zero_mask(tomask, length):
          for i in range(length):
              tomask[i] = 0
    automatic-tests: true
    manual-tests: []

tests:
  reducer: []
  ListArray:
    - ListArray-starts: [2, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
      ListArray-starts-offset: 0
      ListArray-stops: [3, 2, 4, 5, 3, 4, 2, 5, 3, 4, 6, 11]
      ListArray-stops-offset: 0
      ListArray-length: 3
      ListArray-at: 0
    - ListArray-starts: [1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]
      ListArray-starts-offset: 1
      ListArray-stops: [8, 4, 5, 6, 5, 5, 7]
      ListArray-stops-offset: 1
      ListArray-length: 10
      ListArray-at: 5
    - ListArray-starts: [1, 4, 5, 6, 5, 5, 7, 1, 2, 1, 3, 1, 5, 3, 2]
      ListArray-starts-offset: 1
      ListArray-stops: [1, 4, 5, 6, 5, 5, 7, 1, 2, 1, 3, 1, 5, 3, 2]
      ListArray-stops-offset: 1
      ListArray-length: 5
      ListArray-at: 0
    - ListArray-starts: [1, 7, 6, 1, 3, 4, 2, 5, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2]
      ListArray-starts-offset: 2
      ListArray-stops: [1, 9, 6, 2, 4, 5, 3, 6, 3, 4, 2, 4, 5, 5, 7, 8, 2, 3]
      ListArray-stops-offset: 2
      ListArray-length: 3
      ListArray-at: 2
    - ListArray-starts: [0, 0, 0, 0, 0, 0, 0, 0]
      ListArray-starts-offset: 0
      ListArray-stops: [1, 1, 1, 1, 1, 1, 1, 1]
      ListArray-stops-offset: 0
      ListArray-length: 6
      ListArray-at: 1
  ListOffsetArray:
    - ListOffsetArray-offsets: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      ListOffsetArray-offsets-offset: 0
      ListOffsetArray-length: 5
      ListOffsetArray-rawoffsets: [[1, 2, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4], [2, 1, 0, 3, 1, 2, 0, 3, 1, 2, 2, 2, 1, 2, 3, 1, 0, 2, 3, 0, 2, 1]]
    - ListOffsetArray-offsets: [2, 3, 3, 4, 5, 5, 5, 5, 5, 6, 7, 8, 10, 11]
      ListOffsetArray-offsets-offset: 1
      ListOffsetArray-length: 1
      ListOffsetArray-rawoffsets: [[1, 1, 1, 2, 2, 2, 1, 3, 1, 2, 3, 4, 1, 2, 4, 1, 2, 3, 4], [0, 1, 3, 3, 1, 0, 0, 3, 1, 2, 2, 2, 1, 2]]
    - ListOffsetArray-offsets: [2, 1, 0, 1, 2, 0, 1, 2, 2, 2, 1, 2, 1, 0, 0, 0, 0]
      ListOffsetArray-offsets-offset: 1
      ListOffsetArray-length: 6
      ListOffsetArray-rawoffsets: [[3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4], [2, 1, 2, 3, 1, 0, 2, 3, 0, 2, 1]]
    - ListOffsetArray-offsets: [1, 0, 2, 3, 1, 2, 0, 0, 1, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      ListOffsetArray-offsets-offset: 2
      ListOffsetArray-length: 3
      ListOffsetArray-rawoffsets: [[1, 2, 3, 2, 3, 1, 3, 3, 3, 2, 3, 1, 2, 3, 4, 1, 2], [2, 1, 2, 1, 2, 1, 2, 3, 1, 2, 3, 1, 3, 2, 3]]
    - ListOffsetArray-offsets: [0, 0, 0, 0, 0, 0, 0, 0]
      ListOffsetArray-offsets-offset: 0
      ListOffsetArray-length: 6
      ListOffsetArray-rawoffsets: [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]
  Identities:
    - Identities-array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
      Identities-array-offset: 0
    - Identities-array: [0, 2, 1, 1, 1, 1, 2, 0, 1, 2, 0, 1, 0, 2, 0, 1, 1, 1, 0, 2, 2, 2, 1, 2, 0, 1]
      Identities-array-offset: 1
    - Identities-array: [1, 4, 3, 1, 2, 4, 5, 2, 3, 4, 1, 7, 5, 4, 2, 3, 1, 4, 2, 7, 8, 4, 3, 3, 4, 1, 5, 9, 7, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      Identities-array-offset: 2
    - Identities-array: [1, 3, 2, 3, 1, 2, 5, 4, 3, 2, 1, 4, 3, 5, 1, 2, 3, 5, 1, 4, 2, 3, 2, 1, 2, 3, 5, 4, 3, 2, 1, 4, 2, 3, 1, 5, 2, 3, 4, 1, 5, 1, 2, 1, 1, 1]
      Identities-array-offset: 3
    - Identities-array: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      Identities-array-offset: 0
  RegularArray:
    - RegularArray-size: 3
    - RegularArray-size: 2
    - RegularArray-size: 1
    - RegularArray-size: 2
    - RegularArray-size: 0
  IndexedArray:
    - IndexedArray-index: [1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1]
      IndexedArray-index-offset: 0
      IndexedArray-length: 2
      IndexedArray-parents: [1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1]
      IndexedArray-parents-offset: 1
    - IndexedArray-index: [1, 2, 2, 3, 0, 2, 0, 2, 1, 1]
      IndexedArray-index-offset: 0
      IndexedArray-length: 1
      IndexedArray-parents: [0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1]
      IndexedArray-parents-offset: 0
    - IndexedArray-index: [1, 3, 0, 3, 5, 2, 0, 2, 1, 1]
      IndexedArray-index-offset: 0
      IndexedArray-length: 1
      IndexedArray-parents: [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
      IndexedArray-parents-offset: 1
    - IndexedArray-index: [1, 4, 2, 3, 1, 2, 3, 1, 4, 3, 2, 1, 3, 2, 4, 5, 1, 2, 3, 4, 5]
      IndexedArray-index-offset: 1
      IndexedArray-length: 2
      IndexedArray-parents: [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1]
      IndexedArray-parents-offset: 2
    - IndexedArray-index: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      IndexedArray-index-offset: 0
      IndexedArray-length: 5
      IndexedArray-parents: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      IndexedArray-parents-offset: 0
  UnionArray:
    - UnionArray-tags: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      UnionArray-tags-offset: 1
      UnionArray-which: 0
      UnionArray-length: 3
    - UnionArray-tags: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      UnionArray-tags-offset: 0
      UnionArray-which: 1
      UnionArray-length: 2
    - UnionArray-tags: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      UnionArray-tags-offset: 1
      UnionArray-which: 2
      UnionArray-length: 3
    - UnionArray-tags: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      UnionArray-tags-offset: 2
      UnionArray-which: 1
      UnionArray-length: 3
    - UnionArray-tags: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      UnionArray-tags-offset: 0
      UnionArray-which: 0
      UnionArray-length: 10
  NumpyArray:
    - NumpyArray-ptr: [1, 2, 4, 2, 3, 1, 4, 2, 2, 2, 1, 4, 3]
      NumpyArray-ptr-offset: 0
      NumpyArray-length: 5
    - NumpyArray-ptr: [-1, 2, 4, 0, -3]
      NumpyArray-ptr-offset: 1
      NumpyArray-length: 3
    - NumpyArray-ptr: [-1, -3, 2, 1, -5, 7, 8, 9, 2, 3, 4, -1, -5, -3, -7, 5]
      NumpyArray-ptr-offset: 2
      NumpyArray-length: 4
    - NumpyArray-ptr: [1.1, -8.1, 3.1, 9.1, 4.1, 7.1, 9.1]
      NumpyArray-ptr-offset: 1
      NumpyArray-length: 2
    - NumpyArray-ptr: [0, 0, 0, 0, 0, 0, 0]
      NumpyArray-ptr-offset: 0
      NumpyArray-length: 5
  ByteMaskedArray:
    - ByteMaskedArray-mask: [1, 1, 1, 1, 1]
      ByteMaskedArray-mask-offset: 0
      ByteMaskedArray-valid_when: true
      ByteMaskedArray-length: 0
    - ByteMaskedArray-mask: [0, 0, 0, 0, 0]
      ByteMaskedArray-mask-offset: 0
      ByteMaskedArray-valid_when: false
      ByteMaskedArray-length: 5
    - ByteMaskedArray-mask: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      ByteMaskedArray-mask-offset: 1
      ByteMaskedArray-valid_when: true
      ByteMaskedArray-length: 7
    - ByteMaskedArray-mask: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      ByteMaskedArray-mask-offset: 1
      ByteMaskedArray-valid_when: true
      ByteMaskedArray-length: 7
    - ByteMaskedArray-mask: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      ByteMaskedArray-mask-offset: 0
      ByteMaskedArray-valid_when: true
      ByteMaskedArray-length: 7
  BitMaskedArray:
    - BitMaskedArray-mask: [1, 1, 1, 1, 1]
      BitMaskedArray-mask-offset: 0
      BitMaskedArray-valid_when: true
      BitMaskedArray-lsb_order: true
    - BitMaskedArray-mask: [0, 0, 0, 0, 0]
      BitMaskedArray-mask-offset: 0
      BitMaskedArray-valid_when: false
      BitMaskedArray-lsb_order: false
    - BitMaskedArray-mask: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      BitMaskedArray-mask-offset: 1
      BitMaskedArray-valid_when: true
      BitMaskedArray-lsb_order: false
    - BitMaskedArray-mask: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      BitMaskedArray-mask-offset: 2
      BitMaskedArray-valid_when: true
      BitMaskedArray-lsb_order: true
    - BitMaskedArray-mask: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
      BitMaskedArray-mask-offset: 0
      BitMaskedArray-valid_when: false
      BitMaskedArray-lsb_order: false
  num: 3

# These are the names of the reducer roles with a minimial indicator of type.

# If samples.json were samples.yml, we'd be able to include this information in a comment.

#        {
#            "reducer-distincts": [],
#            "reducer-distinctslen": 0,
#            "reducer-fromptr": [],
#            "reducer-gaps": [],
#            "reducer-identity": 0,
#            "reducer-index": [],
#            "reducer-lendistincts": 0,
#            "reducer-length": 0,
#            "reducer-lenparents": 0,
#            "reducer-mask": [],
#            "reducer-maxcount": 0,
#            "reducer-nextlen": 0,
#            "reducer-nextparents": [],
#            "reducer-offsets": [],
#            "reducer-offsetscopy": [],
#            "reducer-outindexlength": 0,
#            "reducer-outlength": 0,
#            "reducer-parents": [],
#            "reducer-starts": [],
#            "reducer-startslength": 0,
#            "reducer-shifts": [],
#            "reducer-validwhen": false
#        }