def str_extractall(arr, pat, flags=<NUM_LIT:0>):
regex = re.compile(pat, flags=flags)<EOL>if regex.groups == <NUM_LIT:0>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if isinstance(arr, ABCIndexClass):<EOL><INDENT>arr = arr.to_series().reset_index(drop=True)<EOL><DEDENT>names = dict(zip(regex.groupindex.values(), regex.groupindex.keys()))<EOL>columns = [names.get(<NUM_LIT:1> + i, i) for i in range(regex.groups)]<EOL>match_list = []<EOL>index_list = []<EOL>is_mi = arr.index.nlevels > <NUM_LIT:1><EOL>for subject_key, subject in arr.iteritems():<EOL><INDENT>if isinstance(subject, str):<EOL><INDENT>if not is_mi:<EOL><INDENT>subject_key = (subject_key, )<EOL><DEDENT>for match_i, match_tuple in enumerate(regex.findall(subject)):<EOL><INDENT>if isinstance(match_tuple, str):<EOL><INDENT>match_tuple = (match_tuple,)<EOL><DEDENT>na_tuple = [np.NaN if group == "<STR_LIT>" else group<EOL>for group in match_tuple]<EOL>match_list.append(na_tuple)<EOL>result_key = tuple(subject_key + (match_i, ))<EOL>index_list.append(result_key)<EOL><DEDENT><DEDENT><DEDENT>from pandas import MultiIndex<EOL>index = MultiIndex.from_tuples(<EOL>index_list, names=arr.index.names + ["<STR_LIT>"])<EOL>result = arr._constructor_expanddim(match_list, index=index,<EOL>columns=columns)<EOL>return result<EOL>
r"""
    For each subject string in the Series, extract groups from all
    matches of regular expression pat. When each subject string in the
    Series has exactly one match, extractall(pat).xs(0, level='match')
    is the same as extract(pat).

    .. versionadded:: 0.18.0

    Parameters
    ----------
    pat : str
        Regular expression pattern with capturing groups.
    flags : int, default 0 (no flags)
        A ``re`` module flag, for example ``re.IGNORECASE``. These allow
        to modify regular expression matching for things like case, spaces,
        etc. Multiple flags can be combined with the bitwise OR operator,
        for example ``re.IGNORECASE | re.MULTILINE``.

    Returns
    -------
    DataFrame
        A ``DataFrame`` with one row for each match, and one column for each
        group. Its rows have a ``MultiIndex`` with first levels that come from
        the subject ``Series``. The last level is named 'match' and indexes the
        matches in each item of the ``Series``. Any capture group names in
        regular expression pat will be used for column names; otherwise capture
        group numbers will be used.

    See Also
    --------
    extract : Returns first match only (not all matches).

    Examples
    --------
    A pattern with one group will return a DataFrame with one column.
    Indices with no matches will not appear in the result.

    >>> s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
    >>> s.str.extractall(r"[ab](\d)")
             0
      match
    A 0      1
      1      2
    B 0      1

    Capture group names are used for column names of the result.

    >>> s.str.extractall(r"[ab](?P<digit>\d)")
            digit
      match
    A 0         1
      1         2
    B 0         1

    A pattern with two groups will return a DataFrame with two columns.

    >>> s.str.extractall(r"(?P<letter>[ab])(?P<digit>\d)")
            letter digit
      match
    A 0          a     1
      1          a     2
    B 0          b     1

    Optional groups that do not match are NaN in the result.

    >>> s.str.extractall(r"(?P<letter>[ab])?(?P<digit>\d)")
            letter digit
      match
    A 0          a     1
      1          a     2
    B 0          b     1
    C 0        NaN     1