<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _flush(self, buffer, start, end):
 """ Flush the write buffer of the stream if applicable. Args: buffer (memoryview):
 Buffer content. start (int):
 Start of buffer position to flush. Supported only with page blobs. end (int):
 End of buffer position to flush. Supported only with page blobs. """

        buffer_size = len(buffer)
        if not buffer_size:
            return

        # Write range normally
        with self._size_lock:
            if end > self._size:
                # Require to resize the blob if note enough space
                with _handle_azure_exception():
                    self._resize(content_length=end, **self._client_kwargs)
                self._reset_head()

        if buffer_size > self.MAX_FLUSH_SIZE:
            # Too large buffer, needs to split in multiples requests
            futures = []
            for part_start in range(0, buffer_size, self.MAX_FLUSH_SIZE):

                # Split buffer
                buffer_part = buffer[
                      part_start:part_start + self.MAX_FLUSH_SIZE]
                if not len(buffer_part):
                    # No more data
                    break

                # Upload split buffer in parallel
                start_range = start + part_start
                futures.append(self._workers.submit(
                    self._update_range, data=buffer_part.tobytes(),
                    start_range=start_range,
                    end_range=start_range + len(buffer_part) - 1,
                    **self._client_kwargs))

            with _handle_azure_exception():
                # Wait for upload completion
                for future in _as_completed(futures):
                    future.result()

        else:
            # Buffer lower than limit, do one requests.
            with _handle_azure_exception():
                self._update_range(
                    data=buffer.tobytes(), start_range=start,
                    end_range=end - 1, **self._client_kwargs)