def METHOD_NAME(terms):
    term_index = [i for i, term in enumerate(terms)
                  if hasattr(term.value, 'axes')]
    term_dims = [terms[i].value.ndim for i in term_index]
    ndims = pd.Series(dict(zip(term_index, term_dims)))
    # initial axes are the axes of the largest-axis'd term
    biggest = terms[ndims.idxmax()].value
    typ = biggest._constructor
    axes = biggest.axes
    naxes = len(axes)
    gt_than_one_axis = naxes > 1
    for value in (terms[i].value for i in term_index):
        is_series = isinstance(value, pd.Series)
        is_series_and_gt_one_axis = is_series and gt_than_one_axis
        for axis, items in enumerate(value.axes):
            if is_series_and_gt_one_axis:
                ax, itm = naxes - 1, value.index
            else:
                ax, itm = axis, items
            if not axes[ax].is_(itm):
                axes[ax] = axes[ax].join(itm, how='outer')
    for i, ndim in compat.iteritems(ndims):
        for axis, items in zip(range(ndim), axes):
            ti = terms[i].value
            if hasattr(ti, 'reindex'):
                transpose = isinstance(ti, pd.Series) and naxes > 1
                reindexer = axes[naxes - 1] if transpose else items
                term_axis_size = len(ti.axes[axis])
                reindexer_size = len(reindexer)
                ordm = np.log10(max(1, abs(reindexer_size - term_axis_size)))
                if ordm >= 1 and reindexer_size >= 10000:
                    w = ('Alignment difference on axis {axis} is larger '
                         'than an order of magnitude on term {term!r}, by '
                         'more than {ordm:.4g}; performance may suffer'
                         ).format(axis=axis, term=terms[i].name, ordm=ordm)
                    warnings.warn(w, category=PerformanceWarning, stacklevel=6)
                f = partial(ti.reindex, reindexer, axis=axis, copy=False)
                terms[i].update(f())
        terms[i].update(terms[i].value.values)
    return typ, _zip_axes_from_type(typ, axes)