docs: def split(self, delimiter, start=None, end=None, count=None,
                bytealigned=None):
          """Return bitstring generator by splittling using a delimiter.
  
          The first item returned is the initial bitstring before the delimiter,
          which may be an empty bitstring.
  
          delimiter -- The bitstring used as the divider.
          start -- The bit position to start the split. Defaults to 0.
          end -- The bit position one past the last bit to use in the split.
                 Defaults to self.len.
          count -- If specified then at most count items are generated.
                   Default is to split as many times as possible.
          bytealigned -- If True splits will only occur on byte boundaries.
  
          Raises ValueError if the delimiter is empty.
  
          """
          delimiter = Bits(delimiter)
          if not delimiter.len:
              raise ValueError("split delimiter cannot be empty.")
          start, end = self._validate_slice(start, end)
          if bytealigned is None:
              bytealigned = globals()['bytealigned']
          if count is not None and count < 0:
              raise ValueError("Cannot split - count must be >= 0.")
          if count == 0:
              return
          if bytealigned and not delimiter.len % 8 and not self._datastore.offset:
              # Use the quick find method
              f = self._findbytes
              x = delimiter._getbytes()
          else:
              f = self._findregex
              x = re.compile(delimiter._getbin())
          found = f(x, start, end, bytealigned)
          if not found:
              # Initial bits are the whole bitstring being searched
              yield self._slice(start, end)
              return
          # yield the bytes before the first occurrence of the delimiter, even if empty
          yield self._slice(start, found[0])
          startpos = pos = found[0]
          c = 1
          while count is None or c < count:
              pos += delimiter.len
              found = f(x, pos, end, bytealigned)
              if not found:
                  # No more occurrences, so return the rest of the bitstring
                  yield self._slice(startpos, end)
                  return
              c += 1
              yield self._slice(startpos, found[0])
              startpos = pos = found[0]
          # Have generated count bitstrings, so time to quit.
          return