code: def next_offsets(self):
          # type: (Descriptor) -> Offsets
          
          resume_bytes = self._resume()
          if resume_bytes is None and not self._allocated:
              self._allocate_disk_space()
          with self._meta_lock:
              if self._offset >= self._ase.size:
                  return None, resume_bytes
              if self._offset + self._chunk_size > self._ase.size:
                  chunk = self._ase.size - self._offset
              else:
                  chunk = self._chunk_size
              # on download, num_bytes must be offset by -1 as the x-ms-range
              # header expects it that way. x -> y bytes means first bits of the
              # (x+1)th byte to the last bits of the (y+1)th byte. for example,
              # 0 -> 511 means byte 1 to byte 512
              num_bytes = chunk - 1
              chunk_num = self._chunk_num
              fd_start = self._offset
              range_start = self._offset
              if self._ase.is_encrypted:
                  # ensure start is AES block size aligned
                  range_start = range_start - \
                      (range_start % self._AES_BLOCKSIZE) - \
                      self._AES_BLOCKSIZE
                  if range_start <= 0:
                      range_start = 0
              range_end = self._offset + num_bytes
              self._offset += chunk
              self._chunk_num += 1
              if self._ase.is_encrypted and self._offset >= self._ase.size:
                  unpad = True
              else:
                  unpad = False
              return Offsets(
                  chunk_num=chunk_num,
                  fd_start=fd_start,
                  num_bytes=chunk,
                  range_start=range_start,
                  range_end=range_end,
                  unpad=unpad,
              ), resume_bytes
docs: Retrieve the next offsets
          :param Descriptor self: this
          :rtype: Offsets
          :return: download offsets