code: def plot_compare_evokeds(
      evokeds,
      picks=None,
      colors=None,
      linestyles=None,
      styles=None,
      cmap=None,
      vlines="auto",
      ci=True,
      truncate_yaxis="auto",
      truncate_xaxis=True,
      ylim=None,
      invert_y=False,
      show_sensors=None,
      legend=True,
      split_legend=None,
      axes=None,
      title=None,
      show=True,
      combine=None,
      sphere=None,
      time_unit="s",
  ):
      """Plot evoked time courses for one or more conditions and/or channels.
  
      Parameters
      ----------
      evokeds : instance of mne.Evoked | list | dict
          If a single Evoked instance, it is plotted as a time series.
          If a list of Evokeds, the contents are plotted with their
          ``.comment`` attributes used as condition labels. If no comment is set,
          the index of the respective Evoked the list will be used instead,
          starting with ``1`` for the first Evoked.
          If a dict whose values are Evoked objects, the contents are plotted as
          single time series each and the keys are used as labels.
          If a [dict/list] of lists, the unweighted mean is plotted as a time
          series and the parametric confidence interval is plotted as a shaded
          area. All instances must have the same shape - channel numbers, time
          points etc.
          If dict, keys must be of type str.
      %(picks_all_data)s
  
          * If picks is None or a (collection of) data channel types, the
            global field power will be plotted for all data channels.
            Otherwise, picks will be averaged.
          * If multiple channel types are selected, one
            figure will be returned for each channel type.
          * If the selected channels are gradiometers, the signal from
            corresponding (gradiometer) pairs will be combined.
  
      colors : list | dict | None
          Colors to use when plotting the ERP/F lines and confidence bands. If
          ``cmap`` is not ``None``, ``colors`` must be a :class:`list` or
          :class:`dict` of :class:`ints <int>` or :class:`floats <float>`
          indicating steps or percentiles (respectively) along the colormap. If
          ``cmap`` is ``None``, list elements or dict values of ``colors`` must
          be :class:`ints <int>` or valid :ref:`matplotlib colors
          <matplotlib:colors_def>`; lists are cycled through
          sequentially,
          while dicts must have keys matching the keys or conditions of an
          ``evokeds`` dict (see Notes for details). If ``None``, the current
          :doc:`matplotlib color cycle
          <matplotlib:gallery/color/color_cycle_default>`
          is used. Defaults to ``None``.
      linestyles : list | dict | None
          Styles to use when plotting the ERP/F lines. If a :class:`list` or
          :class:`dict`, elements must be valid :doc:`matplotlib linestyles
          <matplotlib:gallery/lines_bars_and_markers/linestyles>`. Lists are
          cycled through sequentially; dictionaries must have keys matching the
          keys or conditions of an ``evokeds`` dict (see Notes for details). If
          ``None``, all lines will be solid. Defaults to ``None``.
      styles : dict | None
          Dictionary of styles to use when plotting ERP/F lines. Keys must match
          keys or conditions of ``evokeds``, and values must be a :class:`dict`
          of legal inputs to :func:`matplotlib.pyplot.plot`. Those values will be
          passed as parameters to the line plot call of the corresponding
          condition, overriding defaults (e.g.,
          ``styles={"Aud/L": {"linewidth": 3}}`` will set the linewidth for
          "Aud/L" to 3). As with ``colors`` and ``linestyles``, keys matching
          conditions in ``/``-separated ``evokeds`` keys are supported (see Notes
          for details).
      cmap : None | str | tuple | instance of matplotlib.colors.Colormap
          Colormap from which to draw color values when plotting the ERP/F lines
          and confidence bands. If not ``None``, ints or floats in the ``colors``
          parameter are mapped to steps or percentiles (respectively) along the
          colormap. If ``cmap`` is a :class:`str`, it will be passed to
          ``matplotlib.colormaps``; if ``cmap`` is a tuple, its first
          element will be used as a string to label the colorbar, and its
          second element will be passed to ``matplotlib.colormaps`` (unless
          it is already an instance of :class:`~matplotlib.colors.Colormap`).
  
          .. versionchanged:: 0.19
              Support for passing :class:`~matplotlib.colors.Colormap` instances.
  
      vlines : "auto" | list of float
          A list in seconds at which to plot dashed vertical lines.
          If "auto" and the supplied data includes 0, it is set to [0.]
          and a vertical bar is plotted at time 0. If an empty list is passed,
          no vertical lines are plotted.
      ci : float | bool | callable | None
          Confidence band around each ERP/F time series. If ``False`` or ``None``
          no confidence band is drawn. If :class:`float`, ``ci`` must be between
          0 and 1, and will set the threshold for a bootstrap
          (single plot)/parametric (when ``axes=='topo'``)  estimation of the
          confidence band; ``True`` is equivalent to setting a threshold of 0.95
          (i.e., the 95%% confidence band is drawn). If a callable, it must take
          a single array (n_observations × n_times) as input and return upper and
          lower confidence margins (2 × n_times). Defaults to ``True``.
      truncate_yaxis : bool | 'auto'
          Whether to shorten the y-axis spine. If 'auto', the spine is truncated
          at the minimum and maximum ticks. If ``True``, it is truncated at the
          multiple of 0.25 nearest to half the maximum absolute value of the
          data. If ``truncate_xaxis=False``, only the far bound of the y-axis
          will be truncated. Defaults to 'auto'.
      truncate_xaxis : bool
          Whether to shorten the x-axis spine. If ``True``, the spine is
          truncated at the minimum and maximum ticks. If
          ``truncate_yaxis=False``, only the far bound of the x-axis will be
          truncated. Defaults to ``True``.
      ylim : dict | None
          Y-axis limits for plots (after scaling has been applied). :class:`dict`
          keys should match channel types; valid keys are eeg, mag, grad, misc
          (example: ``ylim=dict(eeg=[-20, 20])``). If ``None``, the y-axis limits
          will be set automatically by matplotlib. Defaults to ``None``.
      invert_y : bool
          Whether to plot negative values upward (as is sometimes done
          for ERPs out of tradition). Defaults to ``False``.
      show_sensors : bool | int | str | None
          Whether to display an inset showing sensor locations on a head outline.
          If :class:`int` or :class:`str`, indicates position of the inset (see
          :func:`mpl_toolkits.axes_grid1.inset_locator.inset_axes`). If ``None``,
          treated as ``True`` if there is only one channel in ``picks``. If
          ``True``, location is upper or lower right corner, depending on data
          values. Defaults to ``None``.
      legend : bool | int | str
          Whether to show a legend for the colors/linestyles of the conditions
          plotted. If :class:`int` or :class:`str`, indicates position of the
          legend (see :func:`mpl_toolkits.axes_grid1.inset_locator.inset_axes`).
          If ``True``, equivalent to ``'upper left'``. Defaults to ``True``.
      split_legend : bool | None
          Whether to separate color and linestyle in the legend. If ``None``,
          a separate linestyle legend will still be shown if ``cmap`` is
          specified. Defaults to ``None``.
      axes : None | Axes instance | list of Axes | 'topo'
          :class:`~matplotlib.axes.Axes` object to plot into. If plotting
          multiple channel types (or multiple channels when ``combine=None``),
          ``axes`` should be a list of appropriate length containing
          :class:`~matplotlib.axes.Axes` objects. If ``'topo'``, a new
          :class:`~matplotlib.figure.Figure` is created with one axis for each
          channel, in a topographical layout. If ``None``, a new
          :class:`~matplotlib.figure.Figure` is created for each channel type.
          Defaults to ``None``.
      title : str | None
          Title printed above the plot. If ``None``, a title will be
          automatically generated based on channel name(s) or type(s) and the
          value of the ``combine`` parameter. Defaults to ``None``.
      show : bool
          Whether to show the figure. Defaults to ``True``.
      %(combine)s
          If callable, the callable must accept one positional input (data of
          shape ``(n_evokeds, n_channels, n_times)``) and return an
          :class:`array <numpy.ndarray>` of shape ``(n_epochs, n_times)``. For
          example::
  
              combine = lambda data: np.median(data, axis=1)
  
          If ``combine`` is ``None``, channels are combined by computing GFP,
          unless ``picks`` is a single channel (not channel type) or
          ``axes='topo'``, in which cases no combining is performed. Defaults to
          ``None``.
      %(sphere_topomap_auto)s
      %(time_unit)s
  
          .. versionadded:: 1.1
  
      Returns
      -------
      fig : list of Figure instances
          A list of the figure(s) generated.
  
      Notes
      -----
      If the parameters ``styles``, ``colors``, or ``linestyles`` are passed as
      :class:`dicts <python:dict>`, then ``evokeds`` must also be a
      :class:`python:dict`, and
      the keys of the plot-style parameters must either match the keys of
      ``evokeds``, or match a ``/``-separated partial key ("condition") of
      ``evokeds``. For example, if evokeds has keys "Aud/L", "Aud/R", "Vis/L",
      and "Vis/R", then ``linestyles=dict(L='--', R='-')`` will plot both Aud/L
      and Vis/L conditions with dashed lines and both Aud/R and Vis/R conditions
      with solid lines. Similarly, ``colors=dict(Aud='r', Vis='b')`` will plot
      Aud/L and Aud/R conditions red and Vis/L and Vis/R conditions blue.
  
      Color specification depends on whether a colormap has been provided in the
      ``cmap`` parameter. The following table summarizes how the ``colors``
      parameter is interpreted:
  
      .. cssclass:: table-bordered
      .. rst-class:: midvalign
  
      +-------------+----------------+------------------------------------------+
      | ``cmap``    | ``colors``     | result                                   |
      +=============+================+==========================================+
      |             | None           | matplotlib default color cycle; unique   |
      |             |                | color for each condition                 |
      |             +----------------+------------------------------------------+
      |             |                | matplotlib default color cycle; lowest   |
      |             | list or dict   | integer mapped to first cycle color;     |
      |             | of integers    | conditions with same integer get same    |
      | None        |                | color; unspecified conditions are "gray" |
      |             +----------------+------------------------------------------+
      |             | list or dict   | ``ValueError``                           |
      |             | of floats      |                                          |
      |             +----------------+------------------------------------------+
      |             | list or dict   | the specified hex colors; unspecified    |
      |             | of hexadecimal | conditions are "gray"                    |
      |             | color strings  |                                          |
      +-------------+----------------+------------------------------------------+
      |             | None           | equally spaced colors on the colormap;   |
      |             |                | unique color for each condition          |
      |             +----------------+------------------------------------------+
      |             |                | equally spaced colors on the colormap;   |
      |             | list or dict   | lowest integer mapped to first cycle     |
      | string or   | of integers    | color; conditions with same integer      |
      | instance of |                | get same color                           |
      | matplotlib  +----------------+------------------------------------------+
      | Colormap    | list or dict   | floats mapped to corresponding colormap  |
      |             | of floats      | values                                   |
      |             +----------------+------------------------------------------+
      |             | list or dict   |                                          |
      |             | of hexadecimal | ``TypeError``                            |
      |             | color strings  |                                          |
      +-------------+----------------+------------------------------------------+
      """
      import matplotlib.pyplot as plt
  
      from ..evoked import Evoked, _check_evokeds_ch_names_times
  
      # build up evokeds into a dict, if it's not already
      if isinstance(evokeds, Evoked):
          evokeds = [evokeds]
  
      if isinstance(evokeds, (list, tuple)):
          evokeds_copy = evokeds.copy()
          evokeds = dict()
  
          comments = [
              _ascii_minus_to_unicode(getattr(_evk, "comment", None))
              for _evk in evokeds_copy
          ]
  
          for idx, (comment, _evoked) in enumerate(
              zip(comments, evokeds_copy)
          ):
              key = str(idx + 1)
              if comment:  # only update key if comment is non-empty
                  if comments.count(comment) == 1:  # comment is unique
                      key = comment
                  else:  # comment is non-unique: prepend index
                      key = f"{key}: {comment}"
              evokeds[key] = _evoked
          del evokeds_copy
  
      if not isinstance(evokeds, dict):
          raise TypeError(
              '"evokeds" must be a dict, list, or instance of '
              f"mne.Evoked; got {type(evokeds).__name__}"
          )
      evokeds = deepcopy(
          evokeds
      )  # avoid modifying dict outside function scope
      for cond, evoked in evokeds.items():
          _validate_type(cond, "str", "Conditions")
          if isinstance(evoked, Evoked):
              evokeds[cond] = [
                  evoked
              ]  # wrap singleton evokeds in a list
          for evk in evokeds[cond]:
              _validate_type(
                  evk, Evoked, "All evokeds entries ", "Evoked"
              )
      # ensure same channels and times across all evokeds
      all_evoked = sum(evokeds.values(), [])
      _check_evokeds_ch_names_times(all_evoked)
      del all_evoked
  
      # get some representative info
      conditions = list(evokeds)
      one_evoked = evokeds[conditions[0]][0]
      times = one_evoked.times
      info = one_evoked.info
      sphere = _check_sphere(sphere, info)
      time_unit, times = _check_time_unit(time_unit, one_evoked.times)
      tmin, tmax = times[0], times[-1]
      # set some defaults
      if ylim is None:
          ylim = dict()
      if vlines == "auto":
          vlines = [0.0] if (tmin < 0 < tmax) else []
      _validate_type(vlines, (list, tuple), "vlines", "list or tuple")
  
      # is picks a channel type (or None)?
      orig_picks = deepcopy(picks)
      picks, picked_types = _picks_to_idx(info, picks, return_kind=True)
      # some things that depend on picks:
      ch_names = np.array(one_evoked.ch_names)[picks].tolist()
      all_types = _DATA_CH_TYPES_SPLIT + (
          "misc",  # from ICA
          "emg",
          "ref_meg",
          "eyegaze",
          "pupil",
      )
      ch_types = [
          t
          for t in info.get_channel_types(picks=picks, unique=True)
          if t in all_types
      ]
      picks_by_type = channel_indices_by_type(info, picks)
      # discard picks from non-data channels (e.g., ref_meg)
      good_picks = sum(
          [picks_by_type[ch_type] for ch_type in ch_types], []
      )
      picks = np.intersect1d(picks, good_picks)
      if show_sensors is None:
          show_sensors = len(picks) == 1
  
      _validate_type(
          combine, types=(None, "callable", str), item_name="combine"
      )
      # cannot combine a single channel
      if (len(picks) < 2) and combine is not None:
          warn(
              'Only {} channel in "picks"; cannot combine by method "{}".'.format(
                  len(picks), combine
              )
          )
      # `combine` defaults to GFP unless picked a single channel or axes='topo'
      do_topo = isinstance(axes, str) and axes == "topo"
      if combine is None and len(picks) > 1 and not do_topo:
          combine = "gfp"
      # convert `combine` into callable (if None or str)
      combine_func = _make_combine_callable(combine)
  
      # title
      title = _title_helper_pce(
          title,
          picked_types,
          picks=orig_picks,
          ch_names=ch_names,
          combine=combine,
      )
      topo_disp_title = False
      # setup axes
      if do_topo:
          show_sensors = False
          if len(picks) > 70:
              logger.info(
                  "You are plotting to a topographical layout with >70 "
                  "sensors. This can be extremely slow. Consider using "
                  "mne.viz.plot_topo, which is optimized for speed."
              )
          topo_title = title
          topo_disp_title = True
          axes = ["topo"] * len(ch_types)
      else:
          if axes is None:
              axes = (
                  plt.subplots(figsize=(8, 6), layout="constrained")[1]
                  for _ in ch_types
              )
          elif isinstance(axes, plt.Axes):
              axes = [axes]
              _validate_if_list_of_axes(
                  axes, obligatory_len=len(ch_types)
              )
  
      if len(ch_types) > 1:
          logger.info(
              "Multiple channel types selected, returning one figure "
              "per type."
          )
          figs = list()
          for ch_type, ax in zip(ch_types, axes):
              _picks = picks_by_type[ch_type]
              _ch_names = np.array(one_evoked.ch_names)[_picks].tolist()
              _picks = ch_type if picked_types else _picks
              # don't pass `combine` here; title will run through this helper
              # function a second time & it will get added then
              _title = _title_helper_pce(
                  title,
                  picked_types,
                  picks=_picks,
                  ch_names=_ch_names,
                  combine=None,
              )
              figs.extend(
                  plot_compare_evokeds(
                      evokeds,
                      picks=_picks,
                      colors=colors,
                      cmap=cmap,
                      linestyles=linestyles,
                      styles=styles,
                      vlines=vlines,
                      ci=ci,
                      truncate_yaxis=truncate_yaxis,
                      ylim=ylim,
                      invert_y=invert_y,
                      legend=legend,
                      show_sensors=show_sensors,
                      axes=ax,
                      title=_title,
                      split_legend=split_legend,
                      show=show,
                      sphere=sphere,
                  )
              )
          return figs
  
      # colors and colormap. This yields a `styles` dict with one entry per
      # condition, specifying at least color and linestyle. THIS MUST BE DONE
      # AFTER THE "MULTIPLE CHANNEL TYPES" LOOP
      (
          _styles,
          _linestyles,
          _colors,
          _cmap,
          colorbar_title,
          colorbar_ticks,
      ) = _handle_styles_pce(
          styles, linestyles, colors, cmap, conditions
      )
      # From now on there is only 1 channel type
      if not len(ch_types):
          got_idx = _picks_to_idx(info, picks=orig_picks)
          got = np.unique(
              np.array(info.get_channel_types())[got_idx]
          ).tolist()
          raise RuntimeError(
              f"No valid channel type(s) provided. Got {got}. Valid channel types are:"
              f"\n{all_types}."
          )
      ch_type = ch_types[0]
      # some things that depend on ch_type:
      units = _handle_default("units")[ch_type]
      scalings = _handle_default("scalings")[ch_type]
  
      # prep for topo
      pos_picks = (
          picks  # need this version of picks for sensor location inset
      )
      info = pick_info(info, sel=picks, copy=True)
      all_ch_names = info["ch_names"]
      if not do_topo:
          # add vacuous "index" (needed for topo) so same code works for both
          axes = [(ax, 0) for ax in axes]
          if np.array(picks).ndim < 2:
              picks = [picks]  # enables zipping w/ axes
      else:
          from ..channels.layout import find_layout
          from .topo import iter_topography
  
          fig = plt.figure(
              figsize=(18, 14), layout=None
          )  # Not "constrained" for topo
  
          def click_func(
              ax_,
              pick_,
              evokeds=evokeds,
              colors=colors,
              linestyles=linestyles,
              styles=styles,
              cmap=cmap,
              vlines=vlines,
              ci=ci,
              truncate_yaxis=truncate_yaxis,
              truncate_xaxis=truncate_xaxis,
              ylim=ylim,
              invert_y=invert_y,
              show_sensors=show_sensors,
              legend=legend,
              split_legend=split_legend,
              picks=picks,
              combine=combine,
          ):
              plot_compare_evokeds(
                  evokeds=evokeds,
                  colors=colors,
                  linestyles=linestyles,
                  styles=styles,
                  cmap=cmap,
                  vlines=vlines,
                  ci=ci,
                  truncate_yaxis=truncate_yaxis,
                  truncate_xaxis=truncate_xaxis,
                  ylim=ylim,
                  invert_y=invert_y,
                  show_sensors=show_sensors,
                  legend=legend,
                  split_legend=split_legend,
                  picks=picks[pick_],
                  combine=combine,
                  axes=ax_,
                  show=True,
                  sphere=sphere,
              )
  
          layout = find_layout(info)
          # make sure everything fits nicely. our figsize is (18, 14) so margins
          # of 0.25 inch seem OK
          w_margin = 0.25 / 18
          h_margin = 0.25 / 14
          axes_width = layout.pos[0, 2]
          axes_height = layout.pos[0, 3]
          left_edge = layout.pos[:, 0].min()
          right_edge = layout.pos[:, 0].max() + axes_width
          bottom_edge = layout.pos[:, 1].min()
          top_edge = layout.pos[:, 1].max() + axes_height
          # compute scale. Use less of vertical height (leave room for title)
          w_scale = (0.95 - 2 * w_margin) / (right_edge - left_edge)
          h_scale = (0.9 - 2 * h_margin) / (top_edge - bottom_edge)
          # apply transformation
          layout.pos[:, 0] = (
              (layout.pos[:, 0] - left_edge) * w_scale
              + w_margin
              + 0.025
          )
          layout.pos[:, 1] = (
              (layout.pos[:, 1] - bottom_edge) * h_scale
              + h_margin
              + 0.025
          )
          # make sure there is room for a legend axis (sometimes not if only a
          # few channels were picked)
          data_lefts = layout.pos[:, 0]
          data_bottoms = layout.pos[:, 1]
          legend_left = data_lefts.max()
          legend_bottom = data_bottoms.min()
          overlap = np.any(
              np.logical_and(
                  np.logical_and(
                      data_lefts <= legend_left,
                      legend_left <= (data_lefts + axes_width),
                  ),
                  np.logical_and(
                      data_bottoms <= legend_bottom,
                      legend_bottom <= (data_bottoms + axes_height),
                  ),
              )
          )
          right_edge = legend_left + axes_width
          n_columns = (right_edge - data_lefts.min()) / axes_width
          scale_factor = n_columns / (n_columns + 1)
          if overlap:
              layout.pos[:, [0, 2]] *= scale_factor
          # `axes` will be a list of (axis_object, channel_index) tuples
          axes = list(
              iter_topography(
                  info,
                  layout=layout,
                  on_pick=click_func,
                  fig=fig,
                  fig_facecolor="w",
                  axis_facecolor="w",
                  axis_spinecolor="k",
                  layout_scale=None,
                  legend=True,
              )
          )
          picks = list(picks)
      del info
  
      # for each axis, compute the grand average and (maybe) the CI
      # (per sensor if topo, otherwise aggregating over sensors)
      c_func = None if do_topo else combine_func
      all_data = list()
      all_cis = list()
      for _picks, (ax, idx) in zip(picks, axes):
          data_dict = dict()
          ci_dict = dict()
          for cond in conditions:
              this_evokeds = evokeds[cond]
              # assign ci_fun first to get arg checking
              ci_fun = _get_ci_function_pce(ci, do_topo=do_topo)
              # for bootstrap or parametric CIs, skip when only 1 observation
              if not callable(ci):
                  ci_fun = ci_fun if len(this_evokeds) > 1 else None
              res = _get_data_and_ci(
                  this_evokeds,
                  combine,
                  c_func,
                  picks=_picks,
                  scaling=scalings,
                  ci_fun=ci_fun,
              )
              data_dict[cond] = res[0]
              if ci_fun is not None:
                  ci_dict[cond] = res[1]
          all_data.append(
              data_dict
          )  # grand means, or indiv. sensors if do_topo
          all_cis.append(ci_dict)
      del evokeds
  
      # compute ylims
      allvalues = list()
      for _dict in all_data:
          for _array in list(_dict.values()):
              allvalues.append(
                  _array[np.newaxis]
              )  # to get same .ndim as CIs
      for _dict in all_cis:
          allvalues.extend(list(_dict.values()))
      allvalues = np.concatenate(allvalues)
      norm = np.all(allvalues > 0)
      orig_ymin, orig_ymax = ylim.get(ch_type, [None, None])
      ymin, ymax = _setup_vmin_vmax(
          allvalues, orig_ymin, orig_ymax, norm
      )
      del allvalues
  
      # add empty data and title for the legend axis
      if do_topo:
          all_data.append({cond: np.array([]) for cond in data_dict})
          all_cis.append({cond: None for cond in ci_dict})
          all_ch_names.append("")
  
      # plot!
      for (ax, idx), data, cis in zip(axes, all_data, all_cis):
          if do_topo:
              title = all_ch_names[idx]
          # plot the data
          _times = [] if idx == -1 else times
          _plot_compare_evokeds(
              ax,
              data,
              conditions,
              _times,
              cis,
              _styles,
              title,
              norm,
              do_topo,
          )
          # draw axes & vlines
          skip_axlabel = do_topo and (idx != -1)
          _draw_axes_pce(
              ax,
              ymin,
              ymax,
              truncate_yaxis,
              truncate_xaxis,
              invert_y,
              vlines,
              tmin,
              tmax,
              units,
              skip_axlabel,
              time_unit,
          )
      # add inset scalp plot showing location of sensors picked
      if show_sensors:
          _validate_type(
              show_sensors,
              (np.int64, bool, str, type(None)),
              "show_sensors",
              "numeric, str, None or bool",
          )
          if not _check_ch_locs(info=one_evoked.info, picks=pos_picks):
              warn(
                  "Cannot find channel coordinates in the supplied Evokeds. "
                  "Not showing channel locations."
              )
          else:
              _evoked_sensor_legend(
                  one_evoked.info,
                  pos_picks,
                  ymin,
                  ymax,
                  show_sensors,
                  ax,
                  sphere,
              )
      # add color/linestyle/colormap legend(s)
      if legend:
          _draw_legend_pce(
              legend,
              split_legend,
              _styles,
              _linestyles,
              _colors,
              _cmap,
              do_topo,
              ax,
          )
      if cmap is not None:
          _draw_colorbar_pce(
              ax, _colors, _cmap, colorbar_title, colorbar_ticks
          )
      # finish
      if topo_disp_title:
          ax.figure.suptitle(topo_title)
      plt_show(show)
      return [ax.figure]
  
imports: from copy import deepcopy
  from functools import partial
  from itertools import cycle
  from numbers import Integral
  import numpy
  from .._fiff.pick import _DATA_CH_TYPES_SPLIT, _PICK_TYPES_DATA_DICT, _VALID_CHANNEL_TYPES, _picks_to_idx, channel_indices_by_type, channel_type, pick_info
  from ..defaults import _handle_default
  from ..fixes import _is_last_row
  from ..utils import _check_ch_locs, _check_if_nan, _clean_names, _is_numeric, _pl, _to_rgb, _validate_type, fill_doc, logger, verbose, warn
  from .topo import _plot_evoked_topo
  from .topomap import _check_sphere, _draw_outlines, _get_pos_outlines, _make_head_outlines, _prepare_topomap, _prepare_topomap_plot, _set_contour_locator, plot_topomap
  from .utils import DraggableColorbar, _check_cov, _check_delayed_ssp, _check_option, _check_time_unit, _draw_proj_checkbox, _get_cmap, _get_color_list, _make_combine_callable, _plot_masked_image, _prepare_joint_axes, _process_times, _prop_kw, _set_title_multiple_electrodes, _set_window_title, _setup_ax_spines, _setup_cmap, _setup_plot_projector, _setup_vmin_vmax, _triage_rank_sss, _trim_ticks, _validate_if_list_of_axes, plt_show
label_desc: Use image node_id 37 for calling a global function with example usage: plot_compare_evokeds(evokeds, picks, colors, linestyles, styles, cmap, vlines, ci, truncate_yaxis, truncate_xaxis, ylim, invert_y, show_sensors, legend, split_legend, axes, title, show, combine, sphere, time_unit) and returns: list, figs