def block0ThoroughCheck(hexBlocks):
  """
  Look at all consecutive blocks starting with block 0 and see
  if the packet has ended and the rest of the packet is
  zero-filled. If so, ``hexBlocks`` will be altered and all
  remaining blocks will be filled in.

  Args:
    hexBlocks (list): List of 6 hex blocks, each containing a
      string of hex values if already error corrected, or ``None``
      if not error corrected.
      
  Returns:
    tuple: Tuple containing:

    * ``True`` if this packet matched. Else ``False``.
      ``True`` indicates the packet (all 6 blocks) is entirely error corrected.
    * If this was a successful error correction, ``hexBlocks`` is altered
      to contain values for all 6 blocks. Otherwise, the value that
      ``hexBlocks`` contained when the function was called is
      returned.
  """
  
  # If we don't have a block 0, we can't continue
  if hexBlocks[0] == None:
    return False, hexBlocks
  
  # Gather all the consecutive blocks together, starting with block 0
  hexData = hexBlocks[0]
  lastBlock = 0
  for i in range(1,5):
    if hexBlocks[i] != None:
      hexData += hexBlocks[i]
      lastBlock += 1
    else:
      # Stop at the first non-consecutive block
      break

  # Turn hex string back to bytes.
  dataBytes = bytearray.fromhex(hexData)
  dataBytesLen = len(dataBytes)

  # Jump through UAT Frames, looking for an empty frame.
  bytePtr = 8

  # Loop until we have looped over all packets we have.
  while True:
    if bytePtr + 1 >= dataBytesLen:
      break

    uatFrameLen = (dataBytes[bytePtr] << 1) | (dataBytes[bytePtr + 1] >> 7)

    if uatFrameLen == 0:
      # Found end of frame, so we matched.
      currentBlock = (bytePtr + 1) // 72

      # Set all future blocks to zeroes.
      for i in range(currentBlock+1, 6):
        hexBlocks[i] = '00' * 72
      
      return True, hexBlocks

    # Have a next frame, try to proceed to it
    bytePtr += uatFrameLen + 2

  # Didn't find anything
  return False, hexBlocks