'Concatenate raw instances as if they were continuous.
.. note:: Boundaries of the raw files are annotated bad. If you wish to
use the data as continuous recording, you can remove the
boundary annotations after concatenation (see
:meth:`mne.Annotations.delete`).
Parameters
raws : list, or Raw instance
list of Raw instances to concatenate to the current instance
(in order), or a single raw instance to concatenate.
preload : bool, str, or None (default None)
Preload data into memory for data manipulation and faster indexing.
If True, the data will be preloaded into memory (fast, requires
large amount of memory). If preload is a string, preload is the
file name of a memory-mapped file which is used to store the data
on the hard drive (slower, requires less memory). If preload is
None, preload=True or False is inferred using the preload status
of the raw files passed in.'

def append(self, raws, preload=None):

    if (not isinstance(raws, list)):
        raws = [raws]
    all_raws = [self]
    all_raws += raws
    _check_raw_compatibility(all_raws)
    all_preloaded = (self.preload and all((r.preload for r in raws)))
    if (preload is None):
        if all_preloaded:
            preload = True
        else:
            preload = False
    if (preload is False):
        if self.preload:
            self._data = None
        self.preload = False
    else:
        nchan = self.info['nchan']
        c_ns = np.cumsum([rr.n_times for rr in ([self] + raws)])
        nsamp = c_ns[(-1)]
        if (not self.preload):
            this_data = self._read_segment()
        else:
            this_data = self._data
        if isinstance(preload, string_types):
            _data = np.memmap(preload, mode='w+', dtype=this_data.dtype, shape=(nchan, nsamp))
        else:
            _data = np.empty((nchan, nsamp), dtype=this_data.dtype)
        _data[:, 0:c_ns[0]] = this_data
        for ri in range(len(raws)):
            if (not raws[ri].preload):
                data_buffer = _data[:, c_ns[ri]:c_ns[(ri + 1)]]
                raws[ri]._read_segment(data_buffer=data_buffer)
            else:
                _data[:, c_ns[ri]:c_ns[(ri + 1)]] = raws[ri]._data
        self._data = _data
        self.preload = True
    annotations = self.annotations
    edge_samps = list()
    for r in raws:
        annotations = _combine_annotations((annotations, r.annotations), self._last_samps, self._first_samps, self.info['sfreq'], self.info['meas_date'])
        edge_samps.append((sum(self._last_samps) - sum(self._first_samps)))
        self._first_samps = np.r_[(self._first_samps, r._first_samps)]
        self._last_samps = np.r_[(self._last_samps, r._last_samps)]
        self._raw_extras += r._raw_extras
        self._filenames += r._filenames
    self._update_times()
    if (annotations is None):
        annotations = Annotations([], [], [])
    self.annotations = annotations
    for edge_samp in edge_samps:
        onset = _sync_onset(self, (edge_samp / self.info['sfreq']), True)
        self.annotations.append(onset, (1.0 / self.info['sfreq']), 'BAD    boundary')
    if (not (len(self._first_samps) == len(self._last_samps) == len(self._raw_extras) == len(self._filenames))):
        raise RuntimeError('Append    error')
